Category Archives: Everybody Likes a Good Hack!

If SOAP Services are a standard and REST services are not, why bother with REST services?

This seems to be a very powerful statement: why waste any time at all with REST?

With REST, all parties involved (providers and consumers) have to agree on most aspects of the design, as there are no standards beyond the actual (HTTP) GET, POST, PUT and DELETE.

What benefit could come out of REST?

Well, I think that to be able to offer a good operational answer to this question, we should picture a simple scenario.

Let’s suppose that you have an information system that maintains weather information for many locations, and you update that information into the system on a timely basis (like say, every 15 minutes).

As any system, it should support the usual CRUD functions: CREATE (INSERT), READ (SELECT), UPDATE (UPDATE), DELETE (DELETE).

You have many distributed weather data capture stations that send data to a centralized service following the aforementioned update period.

You need to offer a scalable and simple service façade to both the data providers (data capture stations) and the data consumers (other systems that query for weather info).

SOAP web services at first seem to be fine with this requirement (why shouldn’t they?).

But when you start thinking about quality attributes and architectural decisions that would better give support to those attributes, you start wondering…

One characteristic of the entire operation is a thorny issue: within each and every 15-minute period, data does not change!

So, all consumers of data for any given location (with the location ID being in itself a parameter of the query) would get always the same result within one given 15 minute period.

SOAP web services are great for highly transactional systems, that is, systems that are affected by high rates of data changes per unit of time.

For the kind of scenario that we are conceiving, SOAP web services are not necessarily that great, as we would benefit from a service that could make good use of web page caching mechanisms (that are very common on most web servers).

Well, the good thing about REST services is that, from the perspective of the web server where they are hosted, they appear and behave as simple web pages (to the server).

As that is the case, we can actually make good use of standard page caching mechanisms with REST services, in particular, with GET calls.

In WCF REST services, we can use standard Output Cache mechanisms (including cache profiles), starting with VaryByParam, VaryByParams and VaryByCustom.

So now, we have a better understanding of when and how to take advantage of REST services.

KR, GEN

A simple way to swap the ordinal number of any member of a list

 
I am working on the architecture of a very interesting application.
 
On one of the Use Cases, we need to provide to the actors of this use case  the ability to swap the ordinal number of any given member of a list of types of objects.
Let’s say that for one particular scenario of this use case, the types of objects are:
 
Servers, Applications, Business Processes, Business Areas, Regions.
For this Use Case, what matters is not the alphabetical order of these types in the list, but some other functionally significant order, arranged by the actors according to some meaning relative to the particular scenario.
 
Since we also must be able to persist this order, the ordinal number should be one property of the business entity that represents the aformentioned types of objects.
 
The way the actors want to change the order of any given item of the list is by selecting any given item of the list, and then promote it one level up, swapping places with the item on top of it, or demote it one level down, swapping places with the item below it.
One of the characteristics of the list that we must provide to the actors, is that the list should behave like a circular list, or a ring.
 
That means that the actors should be able to select the first item of the list and be able to send it either "up" one level, in which case, being a circular list or ring, it will swap places with the last item of the list, or send it "down" one level, in which case, it will swap places with the second item of the list.
What would be the simplest way that could possibly work for this order swap?
 
Let’s suppose that the name of the class for the types of objects is UniversalObjectType, and that the relevant property for the order swap is OrdinalNumber (you may guess correctly that it is read-write).
 
The class in charge of the responsibility of the realization of the use case (for the order swap), would have a routine very much like this one:
 
Code Sample 1
public void OrderSwap(UniversalObjectType univObjectTypeA, UniversalObjectType univObjectTypeB)
{
      univObjectTypeA.OrdinalNumber = univObjectTypeA.OrdinalNumber + univObjectTypeB.OrdinalNumber;
      univObjectTypeB.OrdinalNumber = univObjectTypeA.OrdinalNumber – univObjectTypeB.OrdinalNumber;
      univObjectTypeA.OrdinalNumber = univObjectTypeA.OrdinalNumber – univObjectTypeB.OrdinalNumber;
 
}
 
This deceptively simple routine makes the trick!
 
Let’s check this out with one scenario:
 
A list of six members, with univObjectTypeA currently at the top (OrdinalNumber = 0) and univObjectTypeB currently
at the bottom (OrdinalNumber = 5).
At the first line, univObjectTypeA.OrdinalNumber will be reassigned the sum of the two values: 0 + 5 = 5.
 
At the second line, univObjectTypeB.OrdinalNumber will be reassigned 5 – 5 = 0, in which case, univObjectTypeB will be promoted to the top of the list.
 
At the third line, univObjectTypeA.OrdinalNumber will be reassigned 5 – 0 = 5, in which case, will be confirmed at the bottom of the list.
 
Bear in mind that only in this particular scenario (where one of the items involved in the swap is the topmost of the list, whose ordinal number is equal to zero), is correct to assume that the third line of code is superfluous. In any other case, where none of the items to swap is the topmost of the list, the third line of code is necessary.
 
Besides, the third line of code would also be always necessary, if the ordinals of the list where to start with 1 instead of 0.
 
After the execution of these three simple lines of code, the two items of the list have effectively swapped places.
 
 

Una simple forma de cambiar el número ordinal de cualquier miembro de una lista

 
Actualmente estoy trabajando en la arquitectura de una aplicación muy interesante.
 
En uno de sus Casos de Uso, debemos proveerle a los actores del mismo la capacidad de cambiar el número ordinal de cualquier miembro de una lista de tipos de objetos.
 
Supongamos que, para un escenario en particular de este Caso de Uso, los tipos de objetos en cuestión son los siguientes:
 
Servers, Aplicaciones, Procesos de Negocios, Areas de Negocios, Regiones.
 
Para este Caso de Uso, lo que importa no es el orden alfabético de estos tipos en la lista, sino mas bien algún otro orden relevante desde el punto de vista funcional, a ser determinado por los actores de acuerdo con algún cierto significado relativo al escenario en particular.
 
Dado que, como tambien tenemos que poder persistir este orden, el número ordinal debería ser una de las propiedades de la Entidad de Negocios que representa a los tipos de objetos ya mencionados.
 
La forma en que los actores quieren poder cambiar el orden de cualquier item de la lista es mediante la selección en la lista del item en cuestión, y luego promoverlo un nivel hacia arriba, en cuyo caso intercambiará lugares con el item que esta encima de el en la lista, o democionarlo un nivel hacia abajo, en cuyo caso itercambiará lugares con el item que se encuentra abajo de el en la lista.
 
Una de las características de la lista que debemos proveer a los actores, es que la misma debería comportarse como una lista circular, o un anillo.
 
Esto significa que los actores deberían, por ejemplo, poder seleccionar el primer item de la lista, y poder enviarlo tanto un nivel "arriba", en cuyo caso, siendo una lista circular, intercambiará lugares con el último item de la lista, o enviarlo un nivel "abajo", en cuyo caso, intercambiará lugares con el segundo item de la lista.
 
Cual sería la expresión mas simple que podría funcionar para este intercambio de número ordinal?
 
Supongamos que el nombre de la clase de los tipos de objetos es UniversalObjectType, y que la propiedad relevante para esta rutina es OrdinalNumber (adivinarán correctamente que esta propiedad es Read-Write).
 
La clase a cargo de la responsabilidad de la realización del Caso de Uso (el cambio del número ordinal) tendría una rutina muy parecida a la que se muestra en Code Sample 1.
 
Esta rutina, engañosamente simple, es capaz de realizar el truco!
 
Verifiquemos que así es, mediante un escenario de ejemplo:
 
Una lista con seis miembros, con univObjectTypeA actualmente al inicio de la lista (OrdinalNumber = 0), y univObjectTypeB actualmente al final de la lista (OrdinalNumber = 5).
 
En la primer línea de la rutina, a univObjectTypeA.OrdinalNumber se le reasignará 5 – 0 = 5, en cuyo caso, será democionado al último lugar de la lista.
 
En la segunda línea, a univObjectTypeB.OrdinalNumber se le reasignará 5 – 5 = 0, en cuyo caso, será promovido al primer lugar de la lista.
 
En la tercer línea, a univObjectTypeA.OrdinalNumber se le reasignará 5 – 0 = 5, en cuyo caso, se lo confirmará como el último item de la lista.
 
Tener presente que sólo en este escenario particular (donde uno de los items a intercambiar es el primero de la lista, cuyo número ordinal es igual a cero) es válido suponer que la tercer línea de código es redudante. Para cualquier otro caso, donde ninguno de los items de la lista a intercambiar es el primero de la misma, la tercer línea de código es necesaria.
 
Por otro lado, tambien sería necesaria la tercer línea de código para todo caso, si los ordinales de lista comenzaran con el 1 en vez del 0.
 
Luego de la ejecución de estas tres simples línea de código, ambos items de la lista habrán efectivamente intercambiado sus lugares en la misma.
 
 

Dates as Numbers and Number of Days

 
 
Some of the leading ERP solutions on the market persist dates in databases as integer numbers.
 
In these cases, the integer number that represents a given date is a function of the year of the date and of the number of days since the beginning of the year.
 
If you manipulate dates from within the tools of the ERP solution, you always "see" dates.
 
But if you use the ETL tools of the database vendor to extract data, you get integer numbers instead of dates.
 
To be able to resolve this problem in .NET, we need to design two services:
 
One service that returns the number of days since the beginning of the year, for a given date, and another service that returns the corresponding date to the number of days (the inverse service).
 
We will implement the solution as a utility (a class that only has static or shared methods).
 
In .NET, it is important to appreciate the subtle differences between DateTime objects (a coordinate or point in the time axis) and TimeSpan objects (a delta between two points or coordinates in the time axis).
 
The number of days is a concept in line with TimeSpan objects, but can use TimeSpan concepts to represent DateTime objects within certain reference frameworks (for instance, within the dates of a given year).
 
In Sample Code 1, the utility is the Class NumberOfDaysInYear.
 
 
 
Fechas como Números y Número de Días
 
Algunas de las soluciones ERP líderes del mercado persisten las fechas en bases de datos como números enteros.
 
En estos casos, el número entero que representa a una fecha dada es una función del año de la fecha y del número de días desde el comienzo del año.
 
Si se manipulan fechas desde dentro de las herramientas de la solución ERP, siempre se "ven" fechas.
 
Pero si se usan las herramientas ETL del proveedor de base de datos para extraer datos, se tienen números enteros en vez de fechas.
 
A fin de resolver este problema en .NET, necesitamos diseñar dos servicios:
 
Un servicio que retorna el número de días desde el comienzo del año, para una fecha dada, y otro servicio que retorna la fecha que se corresponde con el número de días (el servicio inverso).
 
Vamos a implementar la solución como una utility (una clase que sólo tiene métodos static o shared).
 
En .NET, es importante poder apreciar las sutiles diferencias entre objetos DateTime (una coordenada o punto en el eje del tiempo) y objetos TimeSpan (un delta entre dos puntos o coordenadas en el eje del tiempo).
 
El número de días es un concepto en línea con objetos TimeSpan, pero se pueden usar conceptos TimeSpan para representar objetos DateTime dentro de ciertos marcos de referencia (por ejemplo, dentro de las fechas de un año dado).
 
En Sample Code 1, la utility es la clase NumberOfDaysInYear.
 
 
Sample Code 1
using System;
namespace TestNumberOfDaysInYear
{
 
 
 /// <summary>
 /// Description of NumberOfDaysInYear.
 /// </summary>
 public class NumberOfDaysInYear
 {
  
  
  
  // Method GetNumberOfDaysInYear: it returns the number of days
  // since the beginning of the year for a given date.
  // (it returns the value of the DayOfYear property).
  //
  // Metodo GetNumberOfDaysInYear: retorna el numero de dias 
  // desde el comienzo del año para una fecha dada.
  // (este retorna el valor de la propiedad DayOfYear).
  public static int GetNumberOfDaysInYear(System.DateTime _date)
  {
   
   
   return _date.DayOfYear;
   
  
   
  }
  
  // Method GetDateFromDays: it returns the date that corresponds to a number
  // of days since the beginning of the year.
  // (it uses the method AddDays from DateTime to determine the date).
  //
  // Metodo GetDateFromDays: retorna la fecha que corresponde con una
cantidad
  // de dias desde el comienzo del año.
  // (usa el metodo AddDays de DateTime para determinar la fecha).
  public static DateTime GetDateFromDays(int year, int days)
  {
  
   DateTime aDate = new DateTime(year, 1, 1);
   
   DateTime retDate = aDate.AddDays( (double) days-1 );
   
   
   return retDate;
   
  }
  
 }
 
 
 
 class MainClass
 {
  public static void Main()
  {
   
   System.DateTime oneDate =  System.DateTime.Now;
   
   System.DateTime otherDate;
   
   
   
   
   otherDate = NumberOfDaysInYear.GetDateFromDays(oneDate.Year,
NumberOfDaysInYear.GetNumberOfDaysInYear(oneDate));
   
   // Original date
   //
   // Fecha original
   Console.WriteLine("{0}", oneDate.ToString("dd/MM/yyyy"));
   
   // Number of days for the original date.
   //
   // Cantidad de dias para la fecha original.
   Console.WriteLine("{0}",
NumberOfDaysInYear.GetNumberOfDaysInYear(oneDate));
   
   // Reconstructed date from days.
   //
   // Fecha reconstruida desde la cantidad de dias.
   Console.WriteLine("{0}", otherDate.ToString("dd/MM/yyyy"));
   
   
  }
 }
}
 

Not forgetting VB.NET developers

 
The code samples in this blog are in C#.
 
I don’t see that this is going to change any time soon, but some consideration should be given to VB.NET devs.
 
There is a cute open source .NET tool called Reflector for .NET, designed and developed by Lutz Roeder, that can disassemble any .NET app or assembly into the equivalent C# or VB.NET source code.
 
You may find this tool at:
 
 
 
No nos olvidemos de los programadores VB.NET
 
 
Los ejemplos de codigo de este blog están en C#.
 
No aprecio que esto ha de cambiar, pero alguna consideración debe ser tenida con los programadores VB.NET.
 
Hay una herramienta .NET open source muy simpática llamada Reflector for .NET, diseñada y desarrollada por Lutz Roeder, que puede desensamblar cualquier applicación o assembly .NET en su código fuente equivalente en C# o VB.NET
 
Se puede obtener esta tool en:

The Dark Ages

Any Architect that deals with Business Domain OO Applications faces, sooner or later, the need to design a Person class.
 
A common problem in a Person class is the Age property. It is clear that it should be a derived (calculated, read-only) property, in which case
the class should have a DateOfBirth field (DoB) to solve such calculation.
 
Under such conditions, we have to find ways to "compare" the Date Of Birth of the person with today’s date that will allow us
to determine the person’s age.
The business rules to determine the age of a person are, more or less, like this:
If the person’s birthday is already due, then the age of the person is today’s year minus the year of her birth.
If the person’s birthday is not yet due, then the age of the person is today’s year minus the year of her birth minus one (1).
 
These business rules seem to be Ok, but then we realize that we need to add another business rule, to define or determine
the following:
How do we know if the birthday of person is already due or not?
 
To make sure that we have the "right" business rule, we must check that it works fine for whatever the Date Of Birth of the person may
be, even if it falls on a 29th of February (funny thing the leap year!)
 
We may use the services of a helper (private) method for this additional business rule. This helper method could be called:
isBirthDayAlreadyDue(), which returns a boolean.
 
A literal implementation for the business rules that we have discussed so far is available in Sample Code 1 (see below)
For those that really appreciate simplicity and elegant solutions, my favorite implementation for this problem is available in
Sample Code 2 (see below).
 
Cualquier Arquitecto que trabaja con aplicaciones OO de dominios de negocios debe enfrentarse, tarde o temprano, con la necesidad de diseñar una clase Persona.
 
Un problema común en una clase Persona es la propiedad Edad. Está claro que la misma debería ser una propiedad derivada (calculada, read-only),
en cuyo caso esta clase debería tener un campo FechaDeNacimiento (DoB) a fin de resolver tal cálculo.
 
Bajo estas condiciones, debemos contar con formas de "comparar" la Fecha de Nacimiento de la persona con la fecha de hoy que nos permitan
determinar la edad de dicha persona.
 
Las reglas de negocios para determinar la edad de la persona son, mas o menos, así:
Si el cumpleaños de la persona ya ha pasado, entonces la edad de la persona es el año de la fecha de hoy menos el año de su nacimiento.
Si el cumpleaños de la persona no ha pasado todavía, entonces la edad de la persona es el año de la fecha de hoy menos el año de su nacimiento menos uno (1).
Estas reglas de negocios parecen estar Ok, pero luego nos percatamos que necesitamos agregar otra regla de negocios, para definir o determinar
lo siguiente:
Cómo sabemos si el cumpleaños de la persona ha pasado ya o no?
 
A fin de asegurarnos que tenemos la regla de negocios "correcta", debemos verificar que funciona bien para cualquier Fecha de Nacimiento de la persona,
inclusive si dicha fecha cae un 29 de Febrero (cosa simpática esto del año bisiesto!).
 
Podemos usar los servicios de un método helper (private) para esta regla de negocios adicional. Este método helper podría llamarse:
isBirthDayAlreadyDue(), el cual retorna un boolean.
 
Una implementación literal para las reglas de negocios que hemos discutido hasta ahora esta disponible en Sample Code 1 (ver mas abajo).
Para aquellos que realmente aprecian la simplicidad y las soluciones elegantes, mi implementación favorita para este problema esta
disponible en Sample Code 2 (ver mas abajo).
Sample code 1
 
using System;
namespace PersonAge
{
 /// <summary>
 /// Description of Person.
 /// </summary>
 public class Person
 {
  private DateTime DoB;
  private DateTime today;
  
  public Person(DateTime aDateOfBirth)
  {
   DoB = aDateOfBirth;
   today = new DateTime();
   
  }
  
  private bool isBirthDayAlreadyDue()
  {
   // We use today in two methods. To make sure that the comparisons
   // are consistent, we must maintain the same state for today
   // in all methods.
   //
   // Usamos today en dos metodos. Para asegurarnos que las comparaciones
   // son consistentes, debemos mantener el mismo estado para today
   // en todos los metodos.
   
   today =  DateTime.Now;
   
   return (((today.Month*100 + today.Day) / (DoB.Month*100 + DoB.Day)) != 0);
    
  }
  
  public int Age
  {
   get
   {
    
    if (isBirthDayAlreadyDue())
     return ( today.Year – DoB.Year);
    else
     return (today.Year – DoB.Year – 1);
   
   }
  
  }
 }
 
 
 
 
 
}
 
Sample code 2
using System;
namespace PersonAge
{
 /// <summary>
 /// Description of Person.
 /// </summary>
 public class Person
 {
  private DateTime DoB;
  
  public Person(DateTime aDateOfBirth)
  {
   DoB = aDateOfBirth;
   
  }
  
 
  public int Age
  {
   get
   {
    DateTime today =  new DateTime();
    
    today =  DateTime.Now;
    
    return ( today.Year – DoB.Year + ( -1 + Math.Sign((today.Month*100 + today.Day) – (DoB.Month*100 + DoB.Day)))/2   );
   
   }
  
  }
 }
 
 
 
 
 
}