The road to Salamanca

To content | To menu | To search

Thursday, July 16 2009

Salamanca 1.0.1 (alpha 2) is released

The second version of Salamanca has just been released : 1.0.1 (alpha 2).


Changes from the previous release include :

  • A complete refactoring of the libraries : all the base classes are now grouped together in a single assembly (Data Rules, Data Access and Data Activities), available in 2 editions (.NET Framework and .NET Compact Framework). Additional assemblies are available for the use of external libraries (Enterprise Library).
  • The concept of enumerations has been added to the SDML designer.
  • Many bug fixes.

Note that you will have to uninstall the previous version of Salamanca before installing this one.

There are a few things to be noted about the new enumerations :

  • Enumerations defined in the SDML can obviously be used as data types for entity attributes.
  • Enumerations have an underlying type (pretty much like in C#). This defines how enumerated values will be stored in the database.
  • An enumeration translates into a lookup table in the database (each tuple matching an enumerated value).
  • An underlying value must be provided for every enumerated value (this is optional in C#).
  • The default underlying type for an enumeration is a string (impossible in C#). This allows for the use of mnemonics in the database. Your DBA will thank you for this !

And as a conclusion, here is a short list of features that are planned on our roadmap to a final release :

  • Multi database provider SQL code generation : we should at least be able to generate code for Oracle systems.
  • A first pick at a SAML designer. Salamanca looks a lot like (yet) an (other) ORM framework right now, but this is not all there is to it. The ability to design activities (that may use our entities) will bring huge benefits to developers and will show what our vision truly holds.

But for now, enjoy this release. And any feedback will be more than welcome !

Friday, June 19 2009

New blog in town

imageGood news (if you understand French, that is) : Pierre just opened a new blog about Salamanca today called A bord de Salamanca (and yes, it’s in French). In his first post, he says he will, as a Salamanca user, share his experience about Salamanca (some bad, but mostly good I hope…). He will also share tips and tricks about using it.

Now is thus the time to reconsider the use of our Salamanca feeds. If you were a subscriber to this blog feed (, you will also automatically get updates about the new blog (as well as various Salamanca related links as we gather them around the web). If you only want to get updates about this blog (due to an allergy to French, for instance), a new feed is available at the address Links on the website will be updated soon.

Welcome aboard !

Thursday, March 12 2009

Salamanca 1.0 (alpha 1) is released

Great news today : we just released Salamanca 1.0 (alpha 1) !


As promised, this release includes :

  • a SDML designer, and code generation :
    • Domain entities (.NET Framework 3.5).
    • Data mappers (based on Enterprise Library 4.1, .NET Framework 3.5).
    • SQL scripts for tables creation and stored procedures for CRUD access (SQL Server 2005, 2008).
  • Updated libraries, now targeting the .NET Framework (2.0, 3.0 and 3.5) and the .NET Compact Framework (2.0 and 3.5).
  • Complete Visual Studio 2008 integration (via an installer).

There is still a great deal of work to be done, and you should be aware of some limitations for this release :

  • Primary keys for the generated entities are Guids (uniqueidentifier on SQL Server). This cannot be changed.
  • Types for the entities attributes are limited to the following list : bool, DateTime, float, double, int, long, short, Guid and string (by default).
  • Entities can only be linked by one association at a time. This should cover the vast majority of cases though…

You are welcome to play with our brand new Software Factory and give us any feedback about it. I’ll post later about what the future holds for Salamanca.

We hope you will have a pleasant trip !

Monday, February 23 2009

Salamanca in words

It is often said that a picture is worth a thousand words.Wordle: Salamanca How about a picture made of words (click on the image to have a larger view) ?

I just gave this blog the Wordle treatment, and the result is quite cool I think. But the best is that two of the words that stand out the most are '”Data” and “Activity”. These are indeed two concepts that lie at the heart of Salamanca.

Tuesday, September 16 2008

First public release

Today is the day when Salamanca hits its first public release, tagged 0.9.0. You can download it here.

This first release consists of the binaries for the three sets of libraries (Data Rules, Data Access and Data Activities), for the three following environments :

  • .NET Framework 2.0
  • .NET Framework 3.0
  • .NET Compact Framework 2.0

There is also (some) documentation with (some) sample code. Work on this matter is obviously still in progress, but you can find more complete sample code in the source code. Check for the Northwind  projects, that are used for our unit tests, based on the Northwind sample database. They are quite complete at this stage and are used to demonstrate what generated code could look like.

The future looks bright, and there is a lot of very interesting work to be done (most of which has already been introduced in this blog). The following list is unordered and incomplete :

  • Migration to Visual Studio 2008, and .NET Framework 3.5 compatibility.
  • Unity integration.
  • LINQ integration.
  • JSON serialization.
  • ASP .NET AJAX integration.
  • WPF integration.
  • A Domain Model designer, an Activities designer, and related code generation, the whole thing being integrated into Visual Studio : a true and real Software Factory.

If you want to hit the road with us, you are more than welcome. For the time being, Salamanca has never been so close. Olé!

Wednesday, August 20 2008

Visiting Salamanca

Fundamentally, Salamanca is designed around three sets of libraries :Architecture

  1. Data Access is the easiest to explain in a few words : think of it as (yet) an (other) (ORM) library. Why another ? We believe that there is not nor will ever be a perfect solution for this problem ; call us "ORM limitations acceptors". Our belief is that an ORM solution has to be designed to fulfill a specific set of issues under a specific set of constraints (which definitely sounds like a product line to me). After all, if you want to go around and around in circles without going anywhere, you are more likely to win the race with a formula one car. If you want to drive home, you will be better off with a standard commercial car : it has been designed for average roads, and priced accordingly. This library will help us handle business specific data in a (DAL).
  2. Data Activities is a library that helps define the business data lifecycle into a specific layer. The latter is a which lies at the core of our architecture : it manages business data, drives the HMI, and as such acts as a perfect (?) .
  3. Data Rules is a validation framework. It will be used to implement our business rules in our activities transitions and our data.

These libraries represent the fundamental abstractions around which our applications will be built. Best practices can be documented around their use, that can be written with our own (DSLs). We have defined two DSLs so far :

  1. SDML (Salamanca Domain Modeling Language) : this language will help us structure our data in order to implement our DAL. But more than that, it will help us create reusable states for our activities, or reusable component for data edition (user controls in Windows Forms for instance). Its representation is very close to a UML Class Diagram.
  2. SAML (Salamanca Activities Modeling Language) : this will help us define our activities. Activities reuse concepts defined in a SDML model. Its representation is inspired by the (BPMN).

Implementing an application with our libraries once the models are properly defined should be quite straightforward. So straightforward that we will be gain a lot by creating two tools that will greatly enhance our productivity :

  1. A Modeler : a graphical tool that will help us visually model our application and serialize it in SDML and SAML formats.
  2. A Generator : a tool that will implement our best practices and take our model as input, in SDML and SAML formats, and generate our C# code. Though it is imaginable to generate a whole functioning application, the developer will have the possibility to customize the generated code to make it more usable, or implement parts that could not be modeled. Usually, developers will ... develop a usable HMI on top of the generated code.

As for now, the libraries are quite in an advanced state, the DSLs definition is in progress and the tools are part of our to do list.

Monday, August 4 2008

Getting on the tracks

So, if Salamanca is a software factory, what is the product line associated with it? The answer is simple : business applications.

Alright, I think I can be more specific than this. In our context

a business application is a software that handles business specific data while implementing parts of business specific processes (which we will call activities) and enforcing business specific rules.

There are a few things we can infer from this definition :Hotel Du Nord

  • to handle business specific data, we will deal with a database backend ; more often than not a real like Sql Server or Oracle, but also possibly a web service or even a simple file (XML, CSV...). For instance, a hotel room booking application would be built upon a proper database, with structured data such as the rooms, their rates, their vacancies...
  • the data lifecycle has to be integrated into well defined activities. At all times, from the state that we know the system is in, there are only a few well known actions that can be taken. Without this concept, an application like Excel would fit into our definition. For instance, a basic activity involving a hotel room and a customer would be : book, then check in, then check out.
  • rules must be enforced at all times. Some of them are specific only to some piece of data, some others can be also specific to  a specific activity. For instance, a booking date in the system cannot be anterior to the date the hotel was built : this is a general rule. But for new reservations, the same booking date has to be in the future : this is a rule that applies to the same data, but that is specific to the activity called "book a room in the hotel".

Our vision with Salamanca is to be able to design a business application in terms of data, activities and rules and be able to generate a complete and functional (if not user-friendly) software.

But we also want to leave the developer at the center of our factory. There are many libraries and tools (think of code generators) out there in the field that work very well, provided you respect their predicates (data structure, software architecture...). But in real life, you almost always have to adapt your code to business specific conditions : already existing databases, specific procedures, architecture... Applications built with Salamanca must be open to adaptations by developers. Think only of the : would you use a software exclusively designed by automated tools ? I know I would not.

Through the concept of activities, which I will elaborate on more in another post, we also created a new way to clearly separate the concerns of presentation from the core application, which we found to be very promising so far. Once created the core of your business application (data handling, activities and rules), you could develop your HMI layer in any (.NET related) technology you like : Windows Forms, Windows Presentation Foundation, ASP .NET... Or in all of them. Or, maybe wiser, you could develop part of your application as an ASP .NET application, and part of it as a Windows Forms application (on Windows TabletPC or Windows Mobile for instance), while reusing the same set of core libraries with your business specific data, activities and rules.

I really hope I made you want to know more about it. In future posts, I will talk about our libraries, our models and our tools. Stay tuned !

Tuesday, July 29 2008

A first glimpse of Salamanca

Welcome to the team blog of Salamanca!

Salamanca is a business applications software factory. The goal is to enable developers to create business oriented applications in a more efficient, reliable and coherent way through a specific set of libraries, models and tools. To make it short, we define a business application as a software that handles business specific data (you can think of it as a low scale enterprise application). Salamanca is designed to help managing the whole life cycle of business data : storage, display, edition, validation, processing... More on that later.

Salamanca is an open-source project, hosted on CodePlex. Its name is a reference to The Salamanca, the first commercially successful locomotive built in 1812.

We are delighted to have you on board, and we hope we will have a pleasant trip together ;-)