Living in the Material World

understanding ADAM

2007-10-22T14:09:00.000-04:00

Here's a very pedagogic article about ADAM (ok, AD LDS) by Brian Redmond.
Interesting stuff, specially the scenarios, I think they are described in a very simple and understandable way.

White pages directory: use syncro tools to pull data from AD, SQL, etc to ADAM. Then the App talks only to ADAM.

Application-specific: the app needs attributes that are not in the AD schema. Authentication is done against AD but for additional info LDAP queries are made against ADAM

Extranet Authentication: provides web SSO

Legacy LDAP & Bind redirection: for apps that connected to LDAP directories. We replace them with ADAM (after migrationg data form old LDAP to ADAM). In case of Bind redirection, we create in ADAM a userProxy that represents an AD account.

ADAM with SSL

2007-10-22T12:24:00.000-04:00

Ok, it may take some time to make it work. Luckily there's quite a lot of info posted by others who spent days trying to do it properly.

Here's erlend's post with detailed instructions.
Includes all the Certificate Authority stuff that is required.

And here's tom's post with some tips if you have the classical “8009030d The credentials supplied to the package were not recognized” error.

Identity in .net

2007-10-20T10:43:00.000-04:00

Ok, security is one of your main concerns if you work in something more than just atoy application. This article by Keith Brown covers Authentication, Single-Sign-On, Authorization, Azman stuff, federated identities, principals, ADFS, and security in WCF. Too much you might say, but after reading this i think you get the hole picture of security in the .net framework. What you can do and what you can't (o, everything is possible....)

What's on SQL Server's data buffer?

2007-10-07T06:11:00.000-04:00

SQL Server stores data on 8K pages. These pages can be data pages, index pages and others (here you'll find the complete list). These pages (well, some of them at a given time) can be stored on the data buffer of SQL Server. Obviously this is because it is faster to retrieve pages from the buffer (RAM) than from disk (physical access).

But sometimes one asks what's being stored right now in the buffer? We should trust SQL Server's Buffer management policies, but it's better to know exactly what's going on inside. This article by Bill Graziano can be very useful if you need to know....

SQL Server Performance counters

2007-10-07T04:40:00.000-04:00

As usual, the guys from SQL Performance have good tips. this time it's about performance counters. They are very useful if you want to monitor some specific event on your db server, examples:

SQL Server Access Methods object: Page Splits/sec:
SQL Server Buffer Manager Object: Cache Size
SQL Server Buffer Manager Object: Buffer Cache Hit Ratio.
SQLServer: SQL Statistics: Batch Requests/Sec
SQLServer: SQL Statistics: SQL Compilations/Sec counter.
SQL Server General Statistics Object: User Connections
SQL Server Locks Object: Number of Deadlocks/sec

More info here

deadlocks in SQL Server

2007-09-26T17:14:00.000-04:00

In some nasty occasions, we find this kind of exceptions after a batch of transactions has been executed in sql server:

Transaction (Process ID 78) was deadlocked on lock resources with another
process and has been chosen as the deadlock victim. Rerun the transaction.
Description: An unhandled exception occurred during the execution of the
current web request. Please review the stack trace for more information
about the error and where it originated in the code.

Exception Details: System.Data.SqlClient.SqlException: Transaction (Process
ID 78) was deadlocked on lock resources with another process and has been
chosen as the deadlock victim. Rerun the transaction.

There is a quite complete article on the subject by Ron Talmage. I just cite some important statements:

"Lock-based deadlocks involve two or more threads, at least one transaction, and one or more resources. It's useful to view deadlocks as occurring in two stages. The first is a grant stage, where each thread is granted a lock on its resource.[...]The second stage is a blocked request where each thread requests an incompatible lock on the other thread's resource. Each thread waits on the other to release its locks before it can complete."

When SQL Server finds deadlocks, it proceeds to choose one of the threads as the "victim" and kills it (well, rols back its transaction).

The article explains 4 main ways to solve deadlocks:

Remove incompatible lock requests
Change the timing of transactions
Change the order of resource requests
Change the isolation leve

The last one, changing the isolation level, seems to be the only way in some cases. For example, if we allow queries to read uncommitted data, we can set the level as follows:

SET ISOLATION LEVEL READ UNCOMMITTED

So next time you have one of those, this article might help.

SQL Server hierarchyid

2007-09-25T16:19:00.000-04:00

Sometimes we're in the need of representing hierarchical data in a database. Take the example of a Military structure:

General Mihajlovic
|- Colonel Stojakovic
|- Lieutenant Mijatovic
|- Sgt Milinkovic
|- Colonel Dragutinovic
|- Lieutenant Djokovic

One way to store this in tables would be to create a table 'Military Person' with a 'parent' id, where every tuple references its 'father' in the hierarchy.

In Sql Server 2008 there is a new datatype called hierarchyid, that might help in this case. The hierarchyid stores the hierarchical information of a tuple. It is in fact a CLR User-defined type (UDT) but is included in the set of base types of sql server.

The string representation of a hierarchyid field looks something like: '/1/2/'
The slashes '/' represent levels in the hierarchy and the numbers, e.g. '1' denotes the position of the child. So the root of the hierarchy is represented by the slash alone: '/'

For instance the military structure described above could be codified as:

/General Mihajlovic
/1/ Colonel Stojakovic
/1/1/ Lieutenant Mijatovic
/1/1/1/ Sgt Milinkovic
/2/ Colonel Dragutinovic
/2/1/ Lieutenant Djokovic

The hierarchyid type exposes several useful method such as GetLevel(), GetAncestor(), GetDescendant(), GetRoot(), Parse(), etc.

So take a look at this link, there are some examples,
and maybe this one as well,
and you can replay the recording of the LiveMeeting

Schemas in SQL Server 2005

2007-09-18T04:22:00.000-04:00

Although this is not really new (2 years on), it's good to know. Schemas in SQL Server are some kind of "containers of objects" (tables views, etc.)
In this way we are able to specify namespaces for our objects for better organization, and, most imimportant, better security management.

In previous versions of SQL Server, an object name was something like:
DBServer.DBName.Owner.Object, but now it is DBServer.DBName.DBSchema.Object

So now the objects are not bound to a particular DB Owner. In consequence if we want to drop some owner, we don't need to drop all the objects defined under its name.

Official info right here

More useful stuff over here

HL7 v3 Datatypes release 2

2007-09-04T04:49:00.000-04:00

The HL7 v3 Comitee ha published the first draft of Release 2 for HL7 datatypes. It is still a draft but there are a number of interesting changes.

One of them concerns translation of concept labels and names.

The ED and its specialization ST (string) have now a SET of ED/ST called "translation".
This means that any attribute of type ST may have a set of other STs, each one representing a translation in a different language. (the ST type already had a language field if I remember well)

more details at the ballot page: Ballot September 2007

and some comments at the wiki: HL7 wiki

Now we have to see what the comitee decides about these datatype issues...

Zürich: Tech Days 2007

2007-05-02T00:37:00.000-04:00

Microsoft organizes TechDays sessions every year in different countries. this time it was Zürich. It is a good opportunity to share knowledge about the "new" .NET technologies: WF, WPF, WCF, etc and of course to make some advertising for Windows Vista, Exchange and Office.

Many of the guests are NOT working for Microsoft so it's good to know third party's point of view. some of these guys are really experts in the field of 'buying their ideas' so it was nice.

so here's the link, to download all presentations and demos!

on description logics

2007-03-18T23:54:00.000-04:00

One of the goals of computer madness (or science) has been that of representing knowledge in such way that a system is able to reason over it and deduce implicit consequences.

In description logics the basic terminology of the 'world' is represented through Concepts. Using simple primitive concepts we can build coplex ones. for instance if we have defined the concepts Vehicle and FlyingThing , we can define Airplane as

Vehicle and FlyingThing

Very simple. We can use other logical operators as well. But one of the main features of DL is the ability to link Concepts through Roles. For instance we may establish a Role called hasPilot. We can describe all individuals having women as pilots with this expression:

for all hasPilot.Woman

This is a concept expression, notice that only one of the concepts of the relationship is specified (the filler, e.g. Woman). In the following example the instance MILLENIUMFALCON satisfies the previous expression:

Vehicle(MILLENIUMFALCON)
Woman(LEIA)
hasPilot(MILLENIUMFALCON,LEIA)

One more thing, in DL a key concept is Subsumption. If we say that

C subsumes D

it means that C is a more general concept than D. (a kind of IS_A link). With these basic constructs it is possible to construct knowledge representation systems with reasoning capabilities. Obviusly the expressiveness of the representation language makes it computationally harder to reason over concepts and roles. In fact it has been demonstrated that some 'complex' dialects lead to undecidability, unrealistic satisfiability times, etc.

Anyway knowledge representation based in DL seems to be promising for some applications, and important initiatives such as OWL (DL for the semantic web) are hot topics in these days.

see owl!
edit owl files with protégé!

Interoperability blog

2007-01-22T14:16:00.000-04:00

as in any blog sometimes you find pure crap and sometimes you discover the light that has lighted the world.

this serverside .com & .net blog might be of some interest to those working on WS.

maybe i'll stay tuned to this blog for some time...

Spatial databases

2007-01-09T10:44:00.000-04:00

A frequent requirement in information systems is support for spatial data management. Geographical information is an example. Say you want to store information about rivers, mountains, forest areas, etc.
Typically you are forced to model all those things in your DB. You create new attribute where you store points and somehow you manage to know that those points have some spatial semantics.

However the DBMS industry has some alternatives. Since this spatial problem is a recurring one, they have developed some solutions, for better or worse.

Oracle is just one example. They have defined a special data type called 'SDO_GEOMETRY', where you can put everything form points to circles and polygons (and combinations of these). Although this solution is not really clean and makes heavy use of arbitrary codes to define the semantics of the geometry, it is quite interesting.

Give it a try, here are some examples.

JSF

2006-12-16T21:02:00.000-04:00

Coming back to the Java world it's good to see that things have changed. Everything's moving, especially if we talk about web development.

some years ago some frameworks like Struts introduced interesting separation models for webapps. The MVC driven applications were a fine improvement but it was evident that there was a lack of a consistent and complete Web UI framework.

With Java ServerFaces everything is becoming clearer and clearer.:

- API's for UI components
- tag libraries
- event modeling
- state management
- managed beans
- navigation model
- etc etc.

What a pity I had not seen this before....

OO + RDB in oracle

2006-11-26T16:58:00.000-04:00

Object oriented solutions for DBMS are still a novelty, most people tend to rely on the good old relational stuff.

But major DB vendors realized that OO support may become profitable. One good example is Oracle. If you don't have an Oracle server right beside you, try to download the XE edition and take a look at some of the OO features (download it for free).

You can declare object types (just like classes) in which you specify attributes and member functions (i.e. methods):

CREATE OR REPLACE TYPE "SEGMENTTYPE" as object(
name varchar2(20),
avgDescentTime decimal(6,2),
member function difficulty return char);
/

The implementation of the methods can be written using the BODY keyword:

create type body segmenttype as
member function difficulty return char is
begin
return 'X';
end;
end;
/

And of course you can inherit from a super-type using the UNDER keyword:

CREATE OR REPLACE TYPE "CROSSINGPOINTTYPE" under referencepointtype(
attractions attractionlist,
skilifts skiliftlist);
/

But this is only a definition of types. In order to have populated data, you create tables with rows of the previous defined types:

create table attraction of attractiontype;

It is indeed an interesting approach, take a look at this basic tutorial for more info.

Dynamic Parallel Schedules

2006-11-10T19:15:00.000-04:00

The old idea of using several processors in order to achieve higher performance still bothers us. Some low level specifications and implementations like MPI have been available for years, but we always have news prom people devoting their lives to develop new prototypes and frameworks.

Dynamic Parallel Schedules or DPS is an interesting effort in this field. The idea is to provide a not-so-low-level implementation of parallel schedules that obey a non-cyclic graph which describes the parallel application.

The model is applicable to distributed-memory clusters. The graph is a high level abstraction of the application. It simply specifies the split and merge operations that may occur during execution. A split is simply an operation that "cuts" data, so that each resulting piece can later be processed by a different thread (eventually in a different node). A merge operation does the opposite job.

Written in C++, it seems quite easy to use this library. All the constructs (Splits, Merge and Others) are classes that can be inherited by application-specific sub-classes.

More info and the downloadable pack (GPL) can be found here. Examples are available, so if you have some minutes, you may experience some of its features...

Heisenbug

2006-10-27T17:24:00.000-04:00

Suele suceder que la solución de ciertos bugs se esconde en las esquinas más obscuras. Y lo peor es que por más que se trate de aislar el problema, el bug se burla de nosotros y su causa se rehusa a salir a la luz.

Heisenberg y la física cuántica tal vez tienen algo que ver. Los bugs siguen el comportamiento de una partícula según el principio de indeterminación de Heisenberg. Por lo menos si lo vemos del lado cómico.

De ahí el nombre Heisenbug y su antónimo el Bohrbug.

Quién tuvo la idea de hacer esa clasificación (hay más!) debió haber llorado sangre al resolver uno de esos heisenbugs.

Sobre el nombre mismo "Bug" hay toda una historia, solo para ociosos.

Biztalk: DTA purge

2006-09-19T11:38:00.000-04:00

After having your Biztalk application running for some weeks, you may notice that the MessageBox and Tracking database are growing insanely. Just before you commit suicide, take a look at the SQL Server jobs available:

It might be particularly interesting to regularly clean the Tracking Database, so you may use the DTA purge and Archive Job. Other useful jobs are available, up to you to give them a try or read the documentation.

Scheduling these jobs seems to be quite easy, so do it before your SQL Server file become untreatable.

.NET Web Services: OneWay property

2006-09-14T20:19:00.000-04:00

I've spent half an hour trying to figure out why on earth certain Web Service's exceptions were not being caught by the client. I was sure the Web Service was being called, sure the exceptions were being produced, but the exceptions never arrived to the client.

I was beggining to think someone was joking me till I decided to take a look at the [SoapDocumentMethodAttribute] attribute. And I saw this "OneWay=true" property.
It was there, don't know how or why. But that property set to true means that the client is not going to wait for the service's answer. So be sure not to set that property if you actually expect some answer from the server.

More accurate information might be found here.

strong names in .NET

2006-09-08T10:13:00.000-04:00

When you build an assembly (DLL, for instance) you provide a name, version number, culture and stuff like that. (Ok sometimes people forget about deployment details like these, but whatever)
Then you install your assembly in some server (say Biztalk) and it works nicely. So far so good.

However imagine that some malicious entity writes another library and compiles his assembly using the same name. He would be able to replace your assembly with his and execute whatever execrable code he wants. Same thing with the version number, someone can claim to have an upgraded version of the assembly, install it and kaboom. Or in an even more bizarre situation you could have someone modifying your assembly in some way and you would have a compromised server.

So, to overcome these issues, we have Strong Names. Using a Private Key, you create a “Strong Name File” for your assembly. In this way, since no-one else knows your private key, no-one else that you is able to generate the same assembly name. Same thing applies for the version number. And additionally, an integrity check is made in order to prevent modifications of the assembly “in-the-middle”.

How to create a strong name? Quite simple:

Get a VS2005 console and type: sn –k mylittleprettystrongnamefile.snk

Et voilà le strong-name.

To associate the strong name file to your assembly, you go to Project Properties->Signing. Check “Sign the assembly” and choose the strong name key file.

If it is a Biztalk Project, go to ProjectProperties->Common Properties->Assembly->Strong Name: Assembly Key File. Choose the file and that’s it.

If you work with Biztalk this is one of the first things you do, since Biztalk requires Strong-named Assemblies.

Be sure to read the “official info” about strong names.
And of course take a look at the syntax of the sk.exe utility.

Biztalk Server2006 and XPath

2006-08-25T20:51:00.000-04:00

Fancy stuff in Biztalk Server 2006. Play with Ports, Messages, XPath, Schemas, Flat Files and Web Services. Any resources you have available, you can put them together and build crazy integrated applications.

Well, after the excitment of my first experience with BTS i came to face the usual problems of almighty tools. It consumes all the memory you may have available. I'll stop testing all this stuff only on my laptop;Running BTS, SQLServer and several instances of VS2005 on the same machine is a plain bad idea.

And now some XPath stuff. The "Expression" Shape in BTS Orchestration is fantastic. I still have thousands of things to learn, I believe, but I found some useful things that are good to know:

- you can construct messages with a simple expression shape, by using the "construct" keyword:

construct Message_1
{
Message_1.caseAct = MedISCaseMessage.caseAct;
}

- Messages ARE IMMUTABLE. So once you construct a message, it is absolutely impossible to modify it. (I'm a strange kind of mule, so I insisted on trying to do so, and failed miserably)

- Whenever you want to modify messages, you are forced to create a new one (you can easily assign a message to another in order to pre-fill it) . You can also define Variables of type XmlDocument and do whatever manipulation you want, and then assign them to Message Instances.

- you can set Message element values with xpath expressions in a straight forward way:

xpath(MyMessage,"//MyElement")= myVariableValue;

- however you must be aware that the nodes you make reference to, should actually exist, otherwise you'll have very pretty error messages on the EventViewer.

- You should also be careful when using namespaces. You won't find your nodes if you don't use a "correct" xpath syntax:

/*[local-name()='Myelement' and namespace-uri()='http://myNamespace.ch/BeautifulNamespace/

- You can easily store string values with xpath, BUT don't forget to use the string() xpath function!:

var = xpath(MyMessage,"string(//myBeautifulXPathString)");

sayonara

ISAPI filter: SF_NOTIFY_AUTH_COMPLETE

2006-08-09T11:24:00.000-04:00

This notification comes to the rescue if you have troubles to determine the identity of the client while processing a request.

The PreProcHeaders notification is triggered before authentication son there's no chance of getting AUTH_USER or REMOTE_USER.
However it is important to notice that AuthComplete is not launched for all requests involving authentication. For example if the authentication method is NTLM, the response sequence is 401, 401, 200. Only the request corresponding to the last message is considered by AuthComplete.

For the rest, the same possibilities as for PreProcHeaders are available. Changing headers, changing the URL, etc.

ADO Stored Procedures in C++

2006-07-27T17:11:00.000-04:00

Ok, Why bother to do db access in c++, having fancy .NET available? More often than you can imagine you find yourself doing some "back to basics" stuff, C++ included.

Luckily, for those like me who are considerably lazy, we have nice resources on the net, so that we can do some nice and dirty copy-paste and get things to work.

CoderSource.NET has ready-to-use examples, and this particular Stored Procedures example saved me a lot of work. Used it for SQL Server and Oracle and everything went fine.

By the way, make sure not to use Unicode configuration in your Visual Studio project or you'll get some nasty compilation errors with the strings.

I'm posting some connection strings, just in case:

SQL Server,Oracle, Oracle ODBC:
"Provider=SQLOLEDB.1;Persist Security Info=False;Initial Catalog=UserTest;Data Source=jpc;Integrated Security=SSPI;"

"Provider=OraOLEDB.Oracle;User ID=system;Password=tiger;Data Source=XE"

"Driver={Microsoft ODBC pour Oracle};Server=jpc;pwd=tiger;"

ITALIA CAMPIONE

2006-07-09T18:44:00.000-04:00

Las noches de Lausanne -y particualrmente las de domingo- traen a la mente escenas de pueblos fantasma. Cada paso produce más ruido del que debería, y cualquier sombra que se aproxima tiene un aire sospechoso. Pero ésta noche es algo distinta. Caravanas hacen su entrada en el centro de la villa, todas debidamente embanderadas y provistas de ruidosos claxons. Quienes están a bordo de los vehículos portan orgullosos los uniformes y escudos de la facción a la que representan. Poco a poco aparecen más y más de esas carrocerías, a las que se añaden peatones, que como infantería, avanzan con la consigna de tomar el corazón de Lausanne.

Es una invasión. Miles y miles de italianos quiebran la monotonía dominical y corean el nombre de su patria al ritmo de bombos, tambores y cacerolas que de todos modos hacen ruido. Y siguen llegando. Son demasiados y han bloqueado todo el sector de St. François, Bel Air y la Rue du Grand Chêne. La masa humana prohíbe el paso de naíves conductores que creen que aún tienen algún privilegio sobre éstas calles. Pues no, las calles pertenecen a las celebraciones.

Pero entre el mar de uniformes azules, en los que se distinguen con frecuencia los nombres "totti" "del piero" o "cannavaro", se pueden percibir individuos cubiertos de resignación y desconsuelo. Sus camisetas son similares pero su escudo destaca un gallo en el medio. Franceses que no pueden disimular la pena.

A qué se debe tanto alboroto? L'Italia e' campione del Mondo. Así de sencillo. Cuando se habla de la copa del mundo (que por cierto ni siquiera es copa) no es necesario precisar que se trata de fútbol, porque las connotaciones son mayores. Y cuánto para Italia, que ve coronarse por cuarta vez, habiendo llegado a Alemania en medio de dudas.

Sobre el partido, creo que hay gente que dedica su vida a analizar el fútbol y seguramente ya habrán disectado éste partido. Me limito a poner en relieve que en ambos casos se trataba de equipos que buscaban resultados antes que magia, y el partido reflejó un poco de eso. También fue una oportunidad para mostrar que incluso un maestro que es capaz de transformar un burdo penal en perla; bajo una provocación adecuada puede convertirse en el bribón más ingénuo.

Por su parte Italia mostró que puede mandar al traste el embrujo histórico de los penales, y mostrar que el trabajo sacrificado tiene sus frutos. Y ese sacrificio se ve reflejado en Cannavaro, Gattuso, Materazzi, el mismísimo Pirlo y el resto de la banda. Por lo menos esa es la impresión que queda, un equipo compuesto por puro peones, cada uno de los cuales puede aparecer en el momento preciso. Buffon en las tapadas, Materazzi bajando contrincantes, Zambrotta conteniendo y golpeando cuando se require, Cannavaro anulando el ataque contrario, Perotta haciendo el aguante, Grosso apareciendo en los momento claves, Totti haciendo dar respiros, Toni buscando espacios, Iaquinta y Gilardino lo propio cuando tenían la oportunidad, Camoranesi tratando de ser explosivo, Del Piero aportando clase y serenidad, Pirlo tomando el timón y Gattuso funcionando a todo vapor, omnipresente y fundamental. Cuál es el protagonista? Parece un elenco formado de actores de reparto.

En fin, tutta Italia si tigne d'azzurro, moi aussi.

Virtual Node Algorithm

2006-06-15T21:18:00.000-04:00

Now it's all about graphics!

Ever wondered how to simulate fractures and spliting meshes?

This nice paper talks about a specific interesting algorithm but also mentions some of the problems you have when you try to do this kind of computation (fractures, collision handling, dynamics, etc.)

Maybe I could further talk about the miracles of computer graphics sometime later eh?...

let's kill some DTO's

2006-05-23T19:22:00.000-04:00

Dealing with persisted objects can be a pain in the neck if managed inappropriately. This is specially the case if your objects need to be transferred in a distributed environment. We have learned from Fowler about the controversial DTOs. In theory we should use this kind of “stupid” objects whenever we need to transfer data to a “foreign” entity. However the introduction of such objects includes adding some mapping code. Tiresome code with the only purpose of copying data. This can be bearable at some extent but the big problem arises when DTOs are overused. Even within the boundaries of a WebApplication, sometimes we see hundreds of DTOs circulating, adding tons of uninteresting and useless code and complexity to the application.

More thoughts on this old post by Jon Tirsen.

Native and enabled

2006-05-11T06:48:00.000-04:00

Sometimes xml and relational databases don't seem to be able to live together in harmony.
The problem is the completely different approach of each of the two technologies. However, when looking at the easy to grasp examples of xml schemas and relational schemas, mappings may seem to be possible. This easyness has led some people to mix up things and think xml and relational schemas are fully compatible. Practice says it is not so simple.

Some people even get to the point of writing database schemas, based blindly on xml schemas. This kind of ideas lead to poor realtional designs. Xml is about documents. Relational models are about data. That's all the idea. Documents follow a certain tree-like structure, an specific order and other precise constraints. All this characteristics cannot be found or are expensive to implement under a relational model. Only the order of document elements is already a big issue. In tables, order is irrelevant, only taken into account when explicitly requested on a query. Parent-child relationships might be extremely complex in a document, contrary to tables, where relationships are "limited enough" in order to avoid join explosion. Documents follow a more flexible structure., changes on the xml schema are far more common that changes on the relational model.

These are only a some examples of problems of "compatibility" betwen the two technologies. For most applications filesystem storage is not an option. Blobs are sometimes an even worse solutin. Since industry does not wish to throw away decades of rdb experience, hybrids came to rescue some years ago. Most "serious" rdbms are "xml-enabled", so that they have special features in order to support "kind-of" xml native support. This normally involves some mapping algorithms and other tricks. Being quite new, these technologies may not be fully trusted by the industry, but they are gaining terrain.

Xml-native technologies have an even less trusted status (exist , tamino) . Without the legacy of rdbms behind them, xml-native db vendors may have quite a hard time trying to make the industry understand the "document-centered" concepts and the advantages of their "pure" approach.

Unfortunately magic formulas do not exist in order to decide which technology to choose and which tool to buy. The best way might be to learn by mistake and share your depressive xml experiences with the community.

to schema or not to schema

2006-04-13T12:51:00.000-04:00

After so many years of having XML technologies available, this should not be a tough question. It is quite amazing that some professional developers still rely on well-formed documents only. The result is obviously chaotic. Well-formed documents grow quickly and inconsistently. What was here an element is an attribute over there, similar structures are found repeated everywhere, the document becomes not-at-all understandable and messy. And all this beacause time can't be "wasted" on creating a simple and easy schema.

And I have not yet talked about the obvious advantage of checking validity of instace documents, which is another good reason for writing schemas. some people tend to say that doing this kind of tasks breaks the geeky code of a good programmer. But for my money it simply puts thing in order and makes your life easier IF you consider yourself professional and not some kind of sleepwalker programmer.

This kind of schema issues become even more important in the case of Web Services. The key word in WS is interoperability. So the main idea is to have a well designed document model (analogous to data model) on which the involved parties have previously agreeed. This concept of document agreement and interoperability might also be crucial even out of the scope of WS.

Tabs and Poor UI Design

2006-03-31T05:53:00.000-04:00

Tabbed Interfaces, used everywhere, and now massively on the net.
However it is interesting to see how a nice idea can turn into something evil...

A fairly complete article about tabs at the Interface Hall Of Shame, good stuff if you are involved on design decisions and UI development.

Quorums

2006-03-21T13:08:00.000-04:00

When the members of the congress (legislative power) want to take decisions, they verify the "quorum". This means they check if the number of representatives is large enough to make the votation valid. If the number of congressmen is too low, any votation would not be legitimate.

Coming back to geek world, quorums are useful in the context of fault tolerance. In a quorum system, we group the servers in such a way that an intersection between any two groups is never empty.

For example, if we consider three servers s1,s2 and s3, this could be a quorum system:

{ {s1,s2},{s2,s3},{s1,s3} }

Each of the groups is called a quorum. For instance, {s1,s2} is a quorum.

In this way, whenever a client requests a service, it works with one of the quorums. The intersection property of the quorum system gurantees that the state is always kept consistently (if correct algorithms are used of course).

Distributed Decisions

2006-03-20T17:46:00.000-04:00

Sometimes the execution of a task can be simplified to the basic concept of making a decision. For example if is a database transaction, the decision could be to commit or abort the transaction.

In the case of a single processing unit this is quite straightforward, but it happens that some systems may not rely on only one processing unit. It's clear that if the single unit crashes, the service is no longer available.

The rule of "throwing hardware" to the problem could seem suitable in order to solve thi issue. By adding several processing units or service providers, if one crashes, there would be another available for subsequent requests. Fine.

But then arrives the nice problem of consistency. Let's assume a minimalist example: clients write and read values of a register replicated in several servers.
Client c1 happily writes "v1" in server s1. The state of the other servers must be updated with the value "v1". Otherwise the state of the system is obviously inconsistent, since different values can be read in a sequential execution.

Maintaining the consistency of the system is not a trivial task, if we consider that machines can crash during the process.

Programming Tips?

2006-02-14T16:46:00.000-04:00

Kristian Dupont, in chrylers.com, published a list of Top Ten NOTS of programming, available here .

Some may appear even controversial (keep in mind this is a list of tips you should NOT follow):

Don't use exceptions: By double negation, DO use exceptions. I agree on this one at least at some extent. Dirty "error codes" and stuff like that are likely to bring unexpected behaviour and some work for bug trackers.
Use unsigned integers for positive values: I've never really cared much about signed or unsigned variables. If it's a sin or not, je m'en fou.
Design classes parallel to their physical counterparts: I must say I believe some level of parallelism is indeed needed. However strict parallelism may lead to nonsense.
Make sure your team shares a common coding standard: Here the author complains about indenting and spacing and that kind of stuff. I once tried to standardize even that, but it was mostly a waste of time. However some other coding standards ARE important.
Write lots of comments: I believe in self-describing code, so I must say tons of comments only turn code dirtier.
Use accessors rather than public fields: This sentence appears to be weird, but I think the author discusses the fact of mis-using accessors.
Use the singleton pattern for variables that you know you should have only one instance: Bof
Be tolerant with intput and strict with output: I agree on validation problems because of this. I've experienced undeterminism and It's a pain in the neck.
Code all corner cases or you'll never fix things: I'm lazy so I like this one.
Design first, then code: This is particulary controversial. And I think it deserves more analysis and further reading. Coding right from start usually leads to nightmares, but I think no design can cover all corners "in-extense". So I think I'll be thinking about this for a while.

JaWE still rocks

2006-02-05T15:36:00.000-04:00

It's been a while since my workflow days. In fact more than a year and a half since I finished my last workflow-realted project.

In those days I used to heavily use a nice Workflow XML Editor known as JaWE (Java Workflow Editor), developed by Together Serbia (as far as I know). The cool thing about JaWE was that it tried to follow as strictly as possible the WFMC (Workflow Management Coalition) standards, and that was the same model I was using.

Recently I saw they released JaWE 2.0. And I decided to take a brief look. At first glance I could see they have really improved the user interface and added a good bunch of functionalities. I think I will take a deeper look at it and to the "Shark" Workflow Engine they have also developed. Even Microsoft is working on workflow-related stuff, so it's my turn, I guess.

I think people overlook Workflow-based systems and the advantages they provide. However I will not claim anything else without diving deeper into the subject.

Anyway it's nice to see JaWE is still alive and kicking.

Software Architect

2005-12-16T12:19:00.000-04:00

Even the term is discussed. Some say such a job does not exist. But I will assume it does. Some people have tried to identify the tasks of a SoftArch, although no final statement can be made yet.

For instance, Rob van Ommering tells us his experience here. More literature is available here. The Soviet Style is a nice comparison, I think.

While working with small teams I have faced similar problems as Rob's, so I dare to cite some of the things he did, and seemed to work (and I also think they should work):

Define concepts
Communicate the concepts
Select technology
Define top-level architecture
Communicate top-level architecture: explain it to everyone else!
Maintain a build environment
Define Documentation
Set up a distributed repository
Organize team meetings
Keep in contact with requirements/product manager
Tutoring
Selecting People

Semantic Web

2005-11-27T12:31:00.000-04:00

RDF: this is what you should know!

w3c's documentation about rdf. there's also a parser and triple/graph online generator

Dijkstra on COBOL: classical quote

2005-10-31T05:46:00.000-04:00

"The use of COBOL cripples the mind; its teaching should, therefore, be regarded as a criminal offence." (1968)

Source: Used in How do we tell truths that might hurt? in Selected Writings on Computing:A Personal Perspective.

async pages in .net 2.0

2005-10-26T02:47:00.000-04:00

About async pages. some thoughts on scalability. try it. Seems to be very useful in case of I/O operations on page loading (such as db-querying and that stuff).

Microsoft on WF

2005-10-08T15:06:00.000-04:00

Microsoft is seriously working on workflow solutions. Or at least they're trying. Anyway it seems to be interesting.

Some general concepts & the walkthrough

Got to try it.

Avalon Guided Tour

2005-10-08T14:59:00.000-04:00

The Windows Presentation Foundation (aka Avalon) is nicely described here.

For those who haven't played with it yet, download the PDC and try it.

Smash the giant

2005-10-05T08:24:00.000-04:00

Ok, the new giant is slowly trying to take the master's place. See him and his new ally!

Well well well, will the open source approach finally take the lead? Still have to wait, but the menace is surely frightening the Gate's guys

JBoss & Microsoft: sleeping with the enemy

2005-09-28T14:33:00.000-04:00

If you can't beat him, join him. It is not exactly what's happening between the JBoss and the Gate's guys but anyway it seems they realized they can profit of an alliance. Ifyou don't believe it, take a look at the article.

Is Microsoft shooting itself on the foot? Maybe they want to keep on learning from the Java Community and the Open Source community (ok, "free software" for someones). However, it seems that Jboss will take the big part of the cake this time.

More on unsafe code

2005-09-20T12:09:00.000-04:00

Look at this, MSDN's official words

and c# corner's

even the codersourcer's

Authorization Management 2

2005-09-20T11:36:00.000-04:00

Security is driving me crazy. Now it is authorization management.

Do we have to rely on role-based authorization management? Is it true that we can really handle comlex system's permissions through roles?

I start to doubt it. Now, with AzMan we have a more detailed auth framework, but I'm afraid it still doesn't fit well enough with .NET and ASP.NET. All the ASP.NET nice features including the RoleProvider for AzMan are still Role-oriented and do not provide real support for operatins and/or tasks.

Je m'excuse, but the AzMan API is still too rough for me. I'm forced to use it but I think I'll have to wait for a patch solving this issue.

By the way:

MSDN on AzMan(basics) here.

Azman & ASP.NET

ASP.NET syntax basics

2005-04-28T06:52:00.000-04:00

This may clear some doubts about server side scripts in ASP.NET, data binding an stuff.
For those who start with ASP.NET or those who are still guessing!

http://beta.asp.net/QUICKSTART/aspnet/doc/pages/syntax.aspx

Accessing existing COM+ Components with C#

2005-02-11T08:04:00.000-04:00

The Code Project's got something about it, altought i haven't proved myself.
If you're using VS.NET some steps may be avoidable...

Quoting Indigo's product manager

2005-01-31T06:52:00.000-04:00

Quoting Ari Bixhorn, lead product manager of Web Services Strategy in the Developer and Platform Division at Microsoft, in an interview with Patrick Meader.

Indigo?

Indigo provides a unified programming model that enables developers to build service-oriented applications explicitly—loosely coupled, autonomous services that provide end-to-end security and reliable messaging assurances.
Today, there are a variety of programming models for building distributed apps—ASMX, Web Services Enhancements (WSE), .NET Enterprise Services, and so on.
Our desire is to simplify this process with a unified programming model that enables developers to build connected systems in a productive manner.

Unified Programming Model

We take the functionalities that are provided in our existing distributed application programming models, and we expose them to the developer through a single namespace within the .NET Framework. Whereas today, developers have to use separate programming models provided by WSE, ASMX, System.Messaging, System.EnterpriseServices, and .NET Remoting, Indigo will bring the best aspects of these together. If you're a VB.NET or C# programmer, you simply reference the System.ServiceModel assembly, then import that into your code. This gives you access to all the functionality that exists in today's disparate technologies and more through a consistent, productive programming model.

Indigo reduces the complexity of creating these (distributed) apps. People are already providing these kinds of solutions, but they take a lot of work; Microsoft is providing a tool that will help them do this faster, more easily, and with greater productivity. Indigo reduces the amount of code developers have to write and the number of programming models that have to know to implement the functionality they need.

Single technology space

If you look across the technology stack for building distributed applications with Microsoft tools today, each technology provides a powerful way of building a distinct type of application. For example, WSE provides you with support for the WS-* protocols for interoperability. .NET Remoting has a great extensibility model, provides location transparency, and so on. But what many developers want is a way to have access to these different elements together within a single application or technology space. They want to combine the interoperability you get with ASMX or WSE with the transaction support you get with Enterprise Services. Today, there is an impedance mismatch across all these existing stacks that makes it difficult to combine all this functionality.
Our early adopters tell us one of Indigo's biggest benefits is the unified model to combine that functionality within a single application. You get all the benefits of interoperability, you get end-to-end Web services-based security, and you can still do things like reliable messaging.
Indigo will provide additional class libraries for VS 2005 developers to incorporate into their applications. In that sense, it is an extension to the .NET Framework 2.0. In terms of operating system support, Indigo will ship as a core subsystem of Windows code-name Longhorn and will also run on Windows XP and Windows Server 2003.

Security

Indigo provides support for security, reliable messaging, and transactions through support of the WS-* specifications. We're not only providing end-to-end security for messages sent from one service to another, but we're doing so in a way that is interoperable. Security in Indigo relies on a token-based model. When an Indigo message comes into a service, it has a token attached to it, and that token asserts various things about the message. For example, in a simple authentication scenario, a token might help you determine the identity of a message—in other words, where it came from. The Indigo authentication system will look at that message and go, "You claim you were sent by Ari Bixhorn. How can I verify that?"
In a simple scenario, you might have two Indigo services running on a Windows domain. The domain controller would be the trusted authority for those two services. So, my Indigo service would check with the domain controller to verify the authenticity of that message. We also have an extensive authorization model—the same authorization model that is used for ASP.NET—so it supports integration with the Windows Authorization Manager, as well as a config-based authorization model, where you can have a config file that specifies your access control list.

Compact Framework

We're not planning on providing Indigo support for the Compact Framework for version 1, but we've heard from quite a few customers who would like such support, so we're looking at that carefully for future versions of the technology.

Backward Compatibility

Microsoft will continue to support today's technologies for building distributed applications after Indigo launches. It is also doing work with Indigo to ensure that Indigo services can communicate with apps built using these technologies. That said, developers can take a number of steps to ready themselves for programming with Indigo, and we'll be posting several white papers on MSDN that will detail some of the strategies developers can take in the near future.

Regexp quicklist

2005-01-20T13:38:00.000-04:00

Here it goes:

\ : the escape character - used to find an instance of a metacharacter like a period, brackets, etc.
. (period) match any character except newline
x match any instance of x
^x match any character except x
[x] match any instance of x in the bracketed range - [abxyz] will match any instance of a, b, x, y, or z
(pipe) an OR operator - [xy] will match an instance of x or y
() used to group sequences of characters or matches
{} used to define numeric quantifiers
{x} match must occur exactly x times
{x,} match must occur at least x times
{x,y} match must occur at least x times, but no more than y times
? preceding match is optional or one only, same as {0,1}
* find 0 or more of preceding match, same as {0,}
+ find 1 or more of preceding match, same as {1,}
^ match the beginning of the line
$ match the end of a line

Win XP SP2 conflict with MSDTC!

2005-01-18T13:45:00.000-04:00

Here you may find how to solve it:

http://www.nimbus.co.nz/Manuals/NimbusManual/Public/WinXPSP2.htm

If you're working with COM+ or Transactions in MSSQL Server, you should check this out

C#: if you want to be unsafe...

2005-01-14T13:45:00.000-04:00

The Dot Net Spider's got an article if you want to deal with pointers, dragons and devils

http://www.dotnetspider.com/Technology/KBPages/331.aspx

log4net: look out!

2004-12-01T11:59:00.000-04:00

A nice article about log4net in the Code Project. A nice way to start logging.

http://www.codeproject.com/csharp/log4net_intro.asp

Workflow Management Systems

2004-11-23T18:44:00.000-04:00

Currently a vast number of software enterprise solutions exist in every domain, such as manufacturing, procurement, educational, clinical, etc. However these systems usually need to be adapted to some company-specific requirements. It is impossible to think about two companies having exactly the same functional organization. Each one of these enterprises has its own set of peculiar activities and procedures – which we will call business processes – and therefore their systems, require a way of automating their business processes based on a set of defined rules.

Thus the necessity of supplying a business process automation system based on previous formal definitions and models. Such a system is known as a Workflow Management System. Using a workflow system, existing information systems can interoperate with it in order to let it handle the business processes.

Not only does this technology allow automating any business processes, but also brings flexibility and ease on maintaining systems, because all business processes are not embedded in the source code. So, if a company decides to change the way it works, it only needs to modify the process definition, without necessarily changing the application code.

C#: Reference and Value Types

2004-11-15T10:54:00.000-04:00

For those confused about reference and value types, and passing parameters, this should be helpful:

http://www.yoda.arachsys.com/csharp/parameters.html

An old article about EAI

2004-11-11T17:41:00.000-04:00

An Old Article about Enterprise Application Integration, take a brief look:

http://www.webservicesarchitect.com/content/articles/samtani01print.asp

Data Transfer Objects once again

2004-11-11T11:20:00.000-04:00

Remote methods often carry the following problem:

“To satisfy a single client request, you find yourself making multiple calls to a remote interface, which increases the response time beyond acceptable levels”. Well, I’m quoting Microsoft’s Solution Patterns if you don’t mind.

But why do we have response-time problems when invoking remote services? Let’s quote MSDN again: “Remote calls (those that have to cross the network) are slow. Although many remote invocation frameworks can hide the complexities of making a remote call, they cannot eliminate the steps that are required for the communication to take place. For example, the remote object location has to be looked up, and a connection to the remote computer has to be made before the data can be serialized into a byte stream, possibly encrypted, and then transmitted to the remote computer.”

So what can we do? The pattern is simple. Create a simple object that holds all data that is required for the call. Thus the remote method should accept the DTO as input or output parameter. Using this pattern avoids declaring multiple parameter methods, which are harder to maintain.

Normally a DTO may look like a Domain Object but we must keep them separated. A DTO can hold data from multiple Domain Objects and even expose additional fields (e.g. calculated values). Additionally, it is also important to remark that DTO’s don’t ever have business logic. Their purpose is only to hold information; it would be a sin to handle DB connections in a DTO for example.

You may immediately think that it would be usually unreasonable to create different DTOs for each method. It is a good practice to reuse the DTOs among several different methods. That’s why sometimes DTOs are someway related to Domain Objects.

Drawbacks? Sure. Think of additional programming you need for building DTO’s. Nevertheless I think the trade is favorable.

Façade Pattern

2004-11-08T19:12:00.000-04:00

After having the Domain Model built, the Domain Logic is supposed to be completely modeled (If your systems look like mines this isn’t really true, for me the DM is never really finished). But then you need to accomplish your functional requirements. These are usually modeled through use cases, and of course each use case may involve interactions between several Business Objects. So it seems there’s something missing, there is an additional step to be taken.

This step is to model the Application Logic. Domain Logic only cares about interactions between Domain Objects; there are no application requirements at this scope. And a good way of designing Application Logic is by using the Façade Pattern.

Let’s quote Tingz Abraham: “It provides a unified interface to a set of interfaces in a subsystem. It defines a higher-level interface that makes the subsystem easier to use”.
So we can put the Façade in front of the Business Domain Logic and expose a simpler interface. Although there’s usually a tight relationship between use cases and façades, grouping criteria is “up to the architect and designer”.

Let’s see the pros:

Simpler interface: The client doesn’t need to know about complexities of the Domain Model. A simple interface exposes just what the client needs.
Improved performance: A single call to the façade is needed instead of calling multiple domain objects’ methods.
Weak coupling between the Business Rules Tier and the Presentation tier.
Clearer separation of scope.
Possibility of building different façades with different behavior and different purposes, but the same DM.

If you’re building a distributed system, you should take a look at this pattern and consider applying it. It was after Distributed System that this pattern actually appeared.

Domain Model: any ideas?

2004-11-08T09:51:00.000-04:00

Software terms are often victims of multiple and diverse interpretations. One of the most controversial is indeed the “Domain Model”. As usual, I’ll try to steal some thoughts from different sources, so you may pick the one(s) you like the most. Eventually, I might throw some personal thoughts, so don’t be surprised to find odd comments.

A Domain Model is an object model of a problem domain. Elements of a domain model are Domain Object classes, and the relationships between them.

So what does it mean? As always, it depends. We’re always looking through a Glass Onion, aren’t we? Well, you usually develop software in order to solve a concrete problem. This problem is enclosed in a particular domain (field, area). And if our brains keep on abstracting this domain, we finally discover the domain entities of the problem. These “entities” (this term is banned in many OO circles, beware of darkness!) are the base of what the Domain Objects will be, and thus what the Domain Model will be.

If you want to find examples of this Domain Objects, think of the classic “customer”, “product”, or “purchase order”. Those abstractions of reality are the Domain Objects, and that’s all.

But why would we want a domain model? Oops, everyone thinks different. You may think of the Domain Model as the pure Object Oriented abstraction of your problem domain. As the DM represents all the interactions between the Domain Objects, it is easy to use them for application purposes. Different Applications would use the same Domain Model, but everyone for its own purposes. Whenever we talk about applications, think of them as systems, modules, or simply components of a complex system. So that’s it, Domain Model reusability through an OO approach; pas mal.

But now there’s a detail missing. We’re talking ‘bout Persistence. Why is it always related to the Domain Model? Although it is not a rule, normally you may want to persist certain Domain Objects, say a customer, a product or any other Domain Object. When talking about persistence, you may immediately think about Relational Databases. Be aware, it is not necessary the case. You may choose another media such as XML, binary files, etc. No matter the persistence media, persistence-specific features must be kept away from the Domain Model. It must be as pure as possible.

VSTS: Waiting for a BETA?

2004-10-07T18:34:00.000-04:00

Visual Studio Team System is a Community Tech Preview. It seems Microsoft really means it, it's really far from a decent version. So I think we'll have to keep on waiting.