Software engineering blog of Clément Bouillier

Agile teaching thoughts

2011-11-10T01:06:00.001+01:00

I come back from an event organized by Institut Agile (Paris). It was a first workshop on what could be done to leverage Agile learning in initial formation. First, we have shared visions in the afternoon (think big, too big some would say ;)), and we had not enough time to talk in detail about action plan (act small).
I have to say that I appreciate that type of event, mostly for point of views diversity, which leads to lots of exchanges.

Then in the evening, we had some experience feedback from Claude Aubry, Jean-Luc Lambert, Frédéric Dufau-Joël and Alexandre Boutin. Lots of interesting feedbacks, I keep in mind :

Avoid lecture, prefer interactive course, use lots of games (role playing)
In France, we have the challenge to change student mindset, which has been inculcated in until they get to (under-)graduate level. They have been too much protected and now they are not enough autonomous, confident and too naïve about reality and scared by errors, they need to be given sense of responsability and to let them do errors without reprimands
Avoid compartmentalized course, integrate them to make a coherent whole teaching project
Take care (avoid) of individual grading, encourage team collaboration and so team grading
Give real projects to lead using learned techniques

My current vision of Agile teaching

From our discussion, I would summarize the vision to adopt through answers to the following questions (it is my point of view, not necessarily shared with every members of the community) :

Why do we need to teach Agile ? To share Agile spirit that promotes fun, motivation, responsability, commitment, questionning..much more than techniques, it is a mindset. In the end, it would result for sure in a world with much more common sense than the one we live in.
Where do we like to go ? We need to influence public authorities, teaching program management through "lobbying" and why not leverage fundamental research in this field (even if I think it is partially covered with several human sciences and computer science researches)
What is the content to teach ? We have to build sort of referential of Agile practices and techniques and requirements to be able to understand Agile.
How do we teach Agile ? We need to share teaching practices, to make more and more experience feedback (in fact, to apply Agile principle to our approach...).
Who is targeted ? Every student that could be involved in an IT project given its initial formation, from the "classic" software engineers to management/commercial profiles (and even any student if we want to spread only the Why...).

Things I would like to dig

First, I would like to start teaching Agile with small courses. But then, I think it would be great to build incrementally a teaching project around following axes:

Around technical, behavioral and methodological integrated/related courses,
With lots of practice and games rather than lecture,
The whole applied through real projects that are needed by their customers (not fake ones)
With implication of professionals strongly related to teaching staff (ex: close relationship between almuni and teaching staff)

Now it is time for action. And I will continue to participate to this new community for sure. Thanks to all participants, I enjoy this moment.

Specialization in Agile (part 1) : other visions than hyperspecialization

2011-10-07T23:14:00.001+02:00

I would like to write a post on this subject for a while (amongst lots of other…), and a post of Mike Cohn about Agile in the Age of Hyperspecialization reminds me the subject (in addition it is also a recurring subject at work for me). I wrote some comments on his blog, but I would like to detail a little bit here.

First of all, I am not confortable with the analogy done between manufacturing activities (or buildings and civil works) and IT industry, which basically leads to reduce developers to “simple” workers that could work in a production line (cf. Ford, with respect for manufacturing workers)…and I think that’s a point that is totally missed with hyper-specialisation.

I prefer other visions more suitable to our industry. In this first post, I will talk about “cultivate your code” analogy, “mentofacturing”, and feature teams approach.
Then in a second post, I will dive into an illustration of what could be stereotypical organization nowadays with “hyperspecialization” and my vision (shared and applied in my team), which is best aligned with Agile and Lean principles from my point of view.

“Cultivate your code”, a refreshing analogy

Classic analogies applied to IT industry are with buildings and civil works or manufacturing. But IT industry is fundamentally different from these industries. I will expose some arguments of another analogy, called “cultivate your code” I discover through Benoît Gantaume (in French but page translation can help non French speaker).

We often mimic processes of buildings and civil works. They are justified by the fact that once you have built a building, it is very hard to change it, it will not evolve as much as an application will. So they need to make lots of studies, to check every details before they lay the foundations. At the opposite, in software, it is very important to be able to build an application that can evolve quickly and potentially in depth (i.e not only on the surface). Moreover, an application that is not evolving will degrade through surface maintenance only, that’s why Benoît Gantaume compares it to vegetal with lots of comparison of day to day activities with those we can see in a garden (I let you read his post). The main idea is that a garden needs constant cares and a software is comparable in this way.

We like (in IT industry) to use manufacturing wording, notably industrialization. Note also that products are completely different, in manufacturing, products are designed once and built several times on production line. Software is absolutely not in the same case, it is unique, designed once and built once. About industrialization, we apply recipes of the XXth century (or even XIXth) with industrialization through (overly-)manual production line adapted to IT through hyper-specialisation. We do not use enough tools and automation at the service of individuals in IT whereas it is far more simple and cheaper than in manufacturing (installing software versus building robots). These arguments are not covered by Benoît, but I think it is like using the good tools to maintain your garden, rather than using only your hands. Even worst, we often use tools that constrain individuals, as if you would try to dig with a rake…

“Mentofactoring”

I heard for the first this word at USI 2011 event (for those understanding french – even if you have an english traduction also – here is the webcast). It was presented by Vincent Lextrait. He started writing a book and first chapters are available at http://www.mentofacturing.com/. I try to summarize key points, but encourage you to read at least home page, which give a good overview.

The reasons why Adam Smith advises divison of labor was based on different parameters than those that characterize work today. First, there was a shift with computers, that minimize cost of loosing time by switching tools. Second, there is far more variations in intellectual productivity than in manual productivity. Third, there is far more interpersonal dependency in intellectual activities than in manual ones.

It concludes that management (and so work organization) of these kind of activities cannot be the same as in classical industries (buildings or manufacturing typically).

Feature Teams

I read this from Craig Larman and Bas Voode book on Agile scaling about organizational tools http://bit.ly/oFtSAM, and specifically in chapter Feature Team (accessible here). The authors focus on Lean manufactoring in their book (finally even manufacturing has new vision…). It is really well explained, I will just paraphrase some part.

The main idea is “one single cross-functional team that completes end-to-end customer features”. It is justified by Lean theory : “In lean hinking, minimizing the wastes of handoff, waiting, WIP, information scatter, and underutilized people is critical”. They also insist on the fact that each team member has not only one speciality, each one has primary skills, but with help of other team members, each member can complete an end-to-end customer feature (reference to “generalizing specialist” introduced by Scott Ambler). Moreover, learning is at the center to share skills and knowledge.

The difference between Feature Team and Feature Project is also very important. With Feature Team, you have less organizational noise due to needed coordination when several Feature Project are involved on one application. It also capitalize on a group that learn and does not break up at end of a project. And third, a Feature Team has shared ownership of code, process and skills.

This three visions illustrate other visions than the mainstream that advocates hyperspecialisation. Next post will focus on an example.

Data backup solution based on RSync with a NAS

2011-01-03T00:36:00.000+01:00

I have once experienced in the past some limited data loss due to a hard disk crash, and lastly, my first external hard drive starts to have some issues…I can just reiterate popular recommendations to think seriously to backup previous data as soon as you got more and more alerts, like repeated hard drive scans at startup (or when you plug it for external drives), suspicious behavior when reading data on drive…that’s what I have done lastly and I avoid lost of plenty of personal photos and videos…
From that moment forward, I decided to set a permanent backup solution. After having a look at web hosted solutions (not convinced completely convinced), I finally went for my own NAS, a DLink DNS-323, which is really easy to configure and extend (Linux embedded). It was also a chance to get hands dirty with Linux toys (long time…), but don’t be afraid to try! (except if you are just able to write documents and mails with a computer…else it could take you several long nights to get it running)

Rsync over SSH as the main toys

Rsync is an incremental files synchronization software for Unix systems. It is command-line based, but could be really powerful along with scripts. I let you search over the web for details on this tools, I will only show how I use it for backup. Note that there is several shared solutions around RSync. I was particularly inspired by wiki.dns323.info and BackupNetClone. I created my own scripts since the first one is too minimalist (based on BAT scripts…outch) and I found the second one too intrusive on clients computer (need SSH deamon and RSync server on each).

SSH will be used to secure RSync file synchronization.

To use it with Windows clients, the first thing is to install Cygwin (or other Linux emulator), really simple, you just have to click Next until package selection, then you select RSync and OpenSSH packages (just the main, dependencies will be grabbed automatically), and then you click Next until the end.

I will come back to client set up (don’t be afraid, it is just script that will have to be scheduled…) after a quick view on the server side, i.e. the NAS.

Set up NAS

My NAS, a DLink DNS-323, is Linux based. You have to use a fun_plug script that will be loaded at NAS startup. You can use ffp that includes some applications, particularly SSH and RSync daemons. Follow instructions in the following link to install it: wiki.dns323.info/howto:ffp.

Typically, you will set up a backup account on DNS-323 through admin interface (http://[NAS IP]), add a "backup" account in the Advanced tab. Next, you can change home and shell in /etc/passwd.

Set up clients

First, you have to configure the client once, then you would probably change configuration of which folders to backup.

First time set up

I explain here what you have to do once for each client computer (i.e. one to backup):

1. generate SSH keys that will be used next:

ssh-kengen -t dsa –b1024

You can let the default key path. Do not provide any passphrase if you want to automate your backups (it would ask it each time you want to backup).

2. copy SSH public key of client to the NAS with:

ssh-copy-id -i ~/.ssh/id_dsa.pub backup@[dns-323 IP]

I have packaged this in a script along with some simple configuration (IP, backup user name…).

What to backup?

My scripts (explained below) will search for configuration files, each giving one path to backup with its destination path on the NAS:

# Local path to backup, use /cygdrive/[drive letter]/... syntax
LOCAL_PATH_TO_BACKUP="/cygdrive/c/testbackup"

# [Optional] Target Rsync module -> override global settings
#TARGET_MODULE="backup"

# Target path in module
TARGET_PATH="test"

Launch a backup

I have a launchBackup.bat script that launches the backup.sh script through Cygwin. In this script, I load configuration from setup, I set up a SSH tunnel, then start rsync and finally close SSH tunnel.

RSync command is:

rsync -aivx --port ${SSH_TUNNEL_LOCAL_PORT} --chmod +rwx ${LOCAL_PATH_TO_BACKUP} 127.0.0.1::${TARGET_MODULE}/${TARGET_PATH}

Parameters name talk by themselves, –aivx are some common options of rsync. I don’t have yet set up incremental backup with --link-dest (hard linking option) and I am wondering about using –-delete that removes on server also what have been removed from your client folders (then you have to make sure that one server path is only used by one client to avoid massive deletions…).

Don’t forget to check your Firewall settings if you get some “Connection refused”-like errors.

Scheduling

You can simply rely on Windows Tasks scheduler. And you are done!

Assessment…

Not so pricy, I got the NAS for 100€ + 70€ for 1,5To hard disk drive. It is quite easy to set up, open as you are the only master of your backup, and then easily configurable/extendable and with unlimited possibilities.

About security, it removes hardware failure but do not protect from other more serious domestic risks like burglary, fire…but for that I got an idea, it is to build a small network of NAS like that (two to start…) with some parents for example, providing us a backup solution by the way …

And a final word about environment impacts, I have bough an energy meter and it consumes only 10 Watts when idle (most of the time), quite good finally.

Combine Hierarchy/Work Item/Date dimensions in TFS 2010 cube

2011-01-02T01:10:00.000+01:00

I start using TFS 2010 cube to make a Product Burndown chart based on Story Points (Y axis) over time (X axis) and State (series) of User Story and Defect work item types of our custom process template (customized from User Story and Bug ones found in MSF Agile process template).

Basics...

With Excel, it was really simple to do it: connect to the cube, use Date and Work Item Dimensions with Story Points Measure and tada, it is done. Ok, well, in fact, it was not exactly what we would like, because we work on a legacy application...so we have User Stories and Defects on different subjects, what we have modelled using a Project work item type that contains related User Stories and Defects.

For example, we have a "Maintenance" Project (not really ending btw...) which contains all production bugs we are fixing, and "Project A" and "Project B" Projects, each ones classically having a given budget and start/end dates.

...deeper...outch ! Problem !

My team has several Projects on one application at the same time, each from 20 man days up to several hundreds man days, but we keep only one iteration/product backlogs for the whole team on this application. Then, each Product Backlog item is related to one Project.

Then, I would like to have a Product Burndown chart restricted to items related to a particular Project. It would help to see how its Product Backlog items are evolving over time and to manage effort needed to keep this Project on track.

I would think that Work Item Tree Dimension would help me...but trying to add it as filter to my Excel report, it does nothing !

In fact, it is an expected behaviour. I understand it digging into SQL Server Analysis Services features (I never had a look at before...) and TFS 2010 cube configuration. There are several explanations:

Dimensions are associated to one/several Measure Group, and the 3 dimensions I 'd like to use are not all together in a same Measure Group, Measure Group examples:
- Work Item includes Work Item and Date Dimensions, but not Work Item Tree one
- Work Item To Tree includes Work Item and Work Item Tree Dimensions, but not Date one
Story Points Measure is a calculated member associated with Work Item History Measure Group, and it is calculated based on hidden Story Points Measure of this Measure Group

Trust me that other Measure Groups do not include at least 2 of these Dimensions...and none include the 3.

Solution

So the solution was:

to add a view to TFS datawharehouse combining Fact tables containing Work Item facts and Hierarchy facts (no change to datawharehouse loading process!)

   ALTER VIEW vFactWorkItemHistoryToTree
    AS
    SELECT wih.*, witt.WorkItemTreeSk
    FROM dbo.FactWorkItemHistory wih
     INNER JOIN dbo.DimWorkItem wi1 on wih.WorkItemSK = wi1.WorkItemSK
     INNER JOIN dbo.DimWorkItem wi2 on wi2.System_Id = wi1.System_Id
     INNER JOIN dbo.vFactWorkItemToTree witt on wi2.WorkItemSK = witt.WorkItemSK
    GO

to change TFS cube DataSource to add the new view and link it to related Dim tables (derived from FactWorkItemHistory for example), just use the designer included in Business Intelligence Studio (you open Analysis Services database directly on server with it)

to add a new Measure Group with the 3 Dimensions I need (derived from Work Item History Measure Group for example, with Work Item Tree dimension added)

to add a calculated member based on hidden Story Points Measure of the new Measure Group (within Business Intelligence Studio, open Team System cube –> Calculations tab to add the new calculated member, and associate it with Measure Group with Calculation Properties icon)

   -- Story Points with Hierarchy Tree dimension
    -- Just a part of MDX request to show we use vFactWorkItemHistoryToTree member of our new measure group...
    CREATE MEMBER CURRENTCUBE.[Measures].
    
    [Microsoft_VSTS_Scheduling_StoryPoints_Tree] AS 
    ...
    Sum
    (
    [Date].[Date].[Date].MEMBERS.Item(0) : [Date].[Date].CurrentMember
    ,[Measures].[vFactWorkItemHistoryToTree Microsoft_VSTS_Scheduling_StoryPoints]
    )
    ...

...even deeper with the same solution

Then, I can do what I wanted with Excel, i.e filter on each Project to have a Burndown chart on each.

Note it can be declined with any work item hierarchy. For example, we also have a Release work item type in our process template, allowing to manage releases contents. Then we can follow how Release backlog evolves through a Burndown chart.

Don't be afraid to look at TFS cube, it took me 2 days to find out what I need (starting with no skills in SSAS...). It can be very powerful.

Alt.Net Paris session summary : "Build your own service bus" by Romain Verdier & Julien Lavigne du Cadet

2010-11-30T21:40:00.003+01:00

Romain and Julien made a presentation/feedback about their experience in implementing their own Service Bus in ABC Arbitrage (thanks for the commodities). In addition to this summary, I encourage you to have a look at their (impressive Prezi) presentation.

They started with an overview of the context in which service bus notion is considered, reviewing some low-level concepts of MOM (Message Oriented Middleware) and giving a quick view on EAI/ESB concepts. These are the two exterme sides of the subject and set their implementation around two goals:

- add an abstraction layer to the MOM solutions, with lot of wanted conventions that help to simplify configuration, but keeping the power of these tools like interoperability, reliable message infrastructure...

- make far more simpler than EAI/ESB solutions and platform specific

Obviously, this subject is around Message driven architecture.

Next they went deeper in service bus concepts, that some solution they cited also implement. As they said, they did not invent anything.

First subject was about Message dispatching (how):

send: a message to one conterparty waiting a response
publish: a message to anyone who wants to pull it without any response

From these two methods, we see that there is two sorts of Message that they implements with two distinct Message concepts:

Command that are sent -> tell someone to do something (note the imperative tense)
Event that are published -> tell anyone wants to listen that something happened (note the passive tense)

Next, they talked about Sagas that allow to take care of long-running transactions. Their example of a trading application was judicious to understand it. Basically, it receives a "complex" trading order that will be decomposed in simpler orders (in order to accomplish the requested order without revealing the whole intention to the market...).

A Saga is initiated by a Command or an Event
It starts a process that send Command/publish Events
It goes to sleep until waken by another Command or Event
...and it starts over, until the Saga determines it has reached its goal, then it ends.

They also quickly talked about some other (important) details like Pipelines for cross-cutting concerns, Time Service to manage Saga time out typically, Prototype Buffer for interoperable message serialization...

The main thing I would remind about implementation is the convention based aspect. It simplifies configuration (5 lines as they said) and hides some technical details, and then it allows to build the software with a bigger insight in Business value that any software should give to their users. It could be seen as a restrictive framework (just two concepts), but I truely think that it helps abstract from technical topics and focus on business value, and that these concepts are well suited to describe business goals.

Note that we did not talk about lots of related subjects like Event Sourcing, DDD...perhaps the next time :)...but we can say that Message driven architecture does not exclude other paradigms.

error MSB6006: "ResGen.exe" exited with code -532459699

2010-11-30T21:13:00.004+01:00

I write my first tip blog post to talk about the following error I got stuck one hour (far too long...) without any search results on Google:

error MSB6006: "ResGen.exe" exited with code -532459699

I got this error when compiling a project targeting 3.5 framework with VS2010, which includes some resource file with CustomAction set to generate associated code.

In fact, I was doing some change to my configuration. Long time ago, I had set up the use of DEVPATH (configure it in the machine.config on dev machine). Due to a problem explained next, I have removed the DEVPATH environement variable, but keeping machine.config as is (to avoid full reconfiguration in case I would need temporarily the DEVPATH...ok I am really lazy :)).

Then, I discover that ResGen.exe fails, I find it when I launched compilation from command line with MSBuild and it was clear in exception trace details...really bad! (note that it works when you do not have RESX files...)

By the way, you should avoid using DEVPATH. It tries to replace GAC, but in fact it fails since it does not take care of DLL versions. But do not through it away to quickly, it could be useful to debug tier DLL for example without modifying all your references...

I found it when I have to install EntLib 5.0 side to side with EntLib 4.1...then only DLL found in first path referenced in DEVPATH was taken in account.

So 2 solutions: you are not lazy and you remove configuration in machine.config OR you are lazy and you set DEVPATH environment variable to something else than empty one (for example "D:").

Team Foundation Server Check In Policy Pack

2010-11-23T22:20:00.005+01:00

I search over the web for some Check In Policies for TFS, and some were founds, some really interesting in my case. I think to:

old reference but interesting http://msmvps.com/blogs/vstsblog/archive/2006/12/08/available-check-in-policies-for-team-foundation-server.aspx
newer references http://checkinpolicypack.codeplex.com/

But there are several drawbacks:

TFS Power Tools Check In Policy pack is lacking open source...you cannot contribute, too bad when you miss just an adjustment to an existing policy
Configurability go from none to too much
Too much packages with different heterogeneous deliverables (package, docs...)

So why not an open sourced Check In Policy pack, on codeplex for example...I think we can gain from homogenization of development practices for Check-In Policies.

Here are some practices I think to:

MSI deployment with Wix : one feature by policy for example to allow flexible installation
Policy configuration management unified
Encapsulate common functionnalities in shared components (path exclusion...)

I was thinking to this pack to share my first Check In policy around Work Items, when I discovered that TFS bundled one and TFS Power Tools one are really basic and not contributable (do not allow link/hierarchy query) !!

Could be great if several projects could merge in one...

First ALM France UG session

2010-11-04T23:07:00.004+01:00

The session

I do not remember how I found this new user group, but I was really happy to assist to this first session.

Contents were "ecumenical", differents points of view and different communities represented (ok a little bit more of .NET one...oddly...). It was a first good point :).

Next, very important, I meet and talk with interesting people, and I hope we will share more in the future through this group.

Quickly about content, what is ALM? François Merand gives 3 major axes : Governance, Dev and Exploitation. Simple, great. So it is not just source control or continuous integration...

Then, Lucian Precup and Arnaud Heritier have made a quick overview of Open Source ALM ecosystem : Maven, IDE, IceScrum, Mantis, Git...and many more.

Daniel Cohen-Zardi followed with a presentation of his company and their product Code Fluent Entities, that proposes a DSL abstracting languages (he does not use the term DSL...but it seems like that to me).

The main points were around 3 concepts : agility, model-driven and executable models. I agree with him on these points. But for the solution, I remain to be convinced for now by this type of product...I prefer coding approach around DDD architecture.

Finally, François Tonic talked about his vision of ALM.

The group

To start, for french people, go to http://blog.alm-france.org/, for others hope it will develop in other countries ! :)

I am looking forward to Google Group discussion list to continue discussions...

Some ideas/reflexions to discuss...

1) We heard a lot the word "industrialization"...opposed to "craftsmanship"...we have to take care of these words use, there are a lot of misconception around industrialization...like over-standardization/normalization (quality ivory tower), over-specialization (like in classic industry)...to be discussed in the group :)

2) I consider ALM practices as central in day to day work, and badly initial formation are lacking in this field (at least mine and some of my colleagues...). There is certainly something to do about that.

3) I would like to share my current experience around ALM, and more importantly to have feedback...my boss and me were thinking about that...perhaps a good chance to try...:)

Thanks again for the creation of this group !

DDD and CQRS resources

2010-04-09T00:13:00.007+02:00

I see CQRS as a great extension of DDD approach. Some people say that you cannot do DDD without...I am not convinced yet.
DDD and CQRS are a lot discussed on the web, but I would like to try to keep in this post a list of resources that are really useful to start...but it depends from where you start.

DDD is becoming more and more known by the community, based on the "bible" of Eric Evans. You could go through the book and other conceptual resources, but I have to admit that it is not always easy to conceptualize without concrete application. That's why I point you to some resources that lead you to enter in DDD and CQRS world through really concrete examples starting from what most people knows.

Today, I think that Anemic Domain Model along with Transactional Script "business services" are a wide spread use of how OOP is used in enterprise (talking about Java and .NET world mainly).

First you can start with great series "Strenghtening your model" of Jimmy Bogard to understand DDD basics, and what are the differences with OOP basics. In his last post, you will see the reference to a great article of Udi Dahan about the concept of Domain Events.
Obviously, there are a lot of DDD concepts that are not covered (bounded contexts for example), but I think that starting from what people knows is a really great approach. You could then dig in other concepts of DDD.

From there, you would better understand CQRS. I think these DDD basics are all shared by CQRS leaders, in addition to the fact that CQRS prones the segregation of Query and Command in two parallel "layers", i.e Query to display some information and Command to treat business users' actions (through Domain Model).
As said by Greg Young, I see today mainly two major differences between CQRS proposed implementation, it concerns domain model persistence :

Event Sourcing, a pattern originally described by Martin Fowler
ORM persistence, as in "classic" data access layer

Main resources are some blogs of "concept leaders" :

Greg Young proposes first the CQRS term derived from the old CQS concept by Bertrand Meyer, he advocates for Event Sourcing approach on persistence
Udi Dahan advocates for "classic" ORM persistence, he is also leader of NServiceBus ESB
Mark Nijhof has done a full CQRS example "à la Greg Young" (explained on his blog)
Jonathan Oliver gives several implementation tips around CQRS
Jérémie Chassaing (Think Before Coding) also gives several implementation tips around CQRS, and he represents Frenches in the field ;)

To start, Greg, Jonathan and Udi have published theirs presentations of CQRS (video). It is a good start before reading blogs. Here is some of these :

Let's try now...for french people, Alt.Net France community has started a sort of Dojo Design around CQRS, we are also trying Google Wave for this. Join Alt.Net France to follow.

PS : Rinat Abdullin has tried to summarize and give some key points to start with DDD, CQRS and others buzz words

About communication mediums in general, but especially in enterprise

2010-02-16T22:36:00.003+01:00

I'd like to give my point of view about the subject of communication mediums in general, It is just a first try on this subject. I will dig communication mediums in enterprise through communication tooling. The goal of this post is to analyse which communication medium should be for which purpose.

This post is quite general and focused on concepts (even if I am not an expert in the field), I will publish an example of what I mean with an example around tools that can implement what I explain in this post.

Note : I do not talk about how people can change communication according to their behaviour, which is more psychology, I just talk about means, even it is sure that the way you communicate is also an important subject.

I think communication as the main factor of success in any project in general, because a project is rarely a personal one but the one of a community in general (which could be a couple, a team, a service, a department, an enterprise, and so on...). Good communication leads to more efficiency and comprehension.

A quick analysis of common communication mediums

Since I am not an expert in sociology, psychology or communication mediums history, I just give a quick analysis of my understanding of what communication is becoming today.

Our society is called today "information society", because more and more information is exchanged between more and more people.

I see several main technologies that bring us to it:

In first days, there were just physical meeting and mail (and carrier pigeon...)
The first major discoveries that make evolve communication were radio and phone, which allow long distance communication with voice only (first unidirectional and broadcast, and then bidirectional)
Then there was television that allows broadcasting a communication with voice and image
And lastly, there were computer, networks and internet that allow to communicate with voice, image, writing...and disclosed to everyone today and with many means (email, chat, community sites, twitter, blogs,...), which makes communication so important in our society

But if we look at the means that are used today, we can see that email has a place of choice in our communications mediums, even more in professional world. Innovation in communications mediums are mainly spread on the internet and mostly by younger people who were born with them.
I think last point is a major reason why communications mediums in entreprise are so badly developed and late, since there, there is people from 20 to 70 years old. But it is time to change our use of technology in entreprise to avoid what I call "email trash for all" syndrom, i.e using your email box as the only "last generation" communications mediums (I do not take in account phone in this category), which leads to too many email boxes with hundreds emails a day...

Some characteristics of communications mediums

I see 3 main characteristics of communications mediums. I do not take them from reading, just from situation analysis, so it must be incomplete. They are important to define in order to analyse how to use which communications medium for which purpose:

Delay between messages of a communication
- Synchronous: the most interactive way, quick message exchanges (ex: phone, face to face conversation)
- Asynchronous: there is different level of latency in the exchange, from seconds (ex: chat) to months or years (ex: documents that persist...)
Basic characteristics
- Presence: perception of people reactions and feelings, possibility to share concrete material (for example goods, paper documents or board)
- Sight: perception of some people reactions, possibility to share visual aid
- Speech: perception of some people reactions, limited expression if you have not sight
- Dynamic visual aid: people can interactively exchange through it, with two distinct types
  - Free to make any representation (text, graph, diagram, drawing...)
  - Constrained to some representation
- Static visual aid: people can only exchange asynchronously on it
Types of organisation
- Presentation: very directive, poor interactivity (ex: lecture...)
- Interactive presentation: restricted number of participants, directed by a leader but more interactive, self-censorship because of the group and given direction by leader (ex: committee, meeting, class...)
- Group discussion: directed by the group, even more interactive, less self-censorship since there is no imposed direction (ex: workshop, open session...)
- Face to face: (ex: with your manager, with someone of your staff, interview...)

Given these definitions, I can try to explain why and how communication must not be reduced to meeting, phone and email, especially in entreprise world. Moreover, about meeting, they need more formality and simplicity.

About delay between messages in a communication, meeting and phone are good mediums for synchronous communications, but email cannot be the only medium for all asynchronous communications! First, because the purpose is too much different between an instant communication and an entreprise directive to be followed for example. Second, because our email boxes are exploding, and I do not believe that search and incoming email rules could be enough to bypass the problem (even if, of course, it is a good practice to use it!)

About basic characteristics, meeting, phone and email combine all of these. However, nowadays, there are more and more distributed teams, and more and more interactions, so these three "old" mediums have to complemented. Solutions exist, just have to implement and distribute it.

About types of organisation, there are all used more or less depending on people involved and on corporate culture. I think there is nothing really new about that. But, what is interesting is to see how they are used, for example: how is a meeting prepared? how are meeting minutes spread? how actions are tracked? And for that, I think we can win in simplicity with new mediums.

Now it's time to see how to implement these principles with real tools. I will propose this in a future post mainly around Microsoft products.

My technological playground...

2010-02-13T21:40:00.012+01:00

Well, it has been a long time since my last published post...in fact, I got several post waiting to be finalized...about application architecture, conception and communication.

Waiting for these post to be published, I would like to blog on the last evolution of my "technological playground".

My technological playground
For a little more than 5 years, I have done technological survey through web review, beta software test, community frameworks discovery...and I always consider this activity as a necessity to leverage my competencies.

For 2 years, I also maintain my own personal web site, using last Microsoft technology. It is a good way to dig some technologies (even if sometimes my wife complains of instability of our site...).

And now, for 1 year, I got a MSDN licence with Visual Studio Team Developer. With it, I can make tests environment. Now, I plan to build several virtual tests environments.

So today my technological playground is made of:

A computer with several virtual test environment (see below for details)
A Google Reader account to follow RSS and share great technological news grab here and there (shared items RSS)
A Delicious account to organize my bookmarks
Some Alt.Net meetings in Paris or starting DDD Paris user group
And...this blog to try to make synthesis of my thoughts on IT

I am not on Twitter yet...but wondering, I see Google Buzz coming out or just Comment Sharing on Google Reader.

My virtual tests environments
I used to have a robust computer but a little undersized to be used as an efficient playground...but it was enough for the minimum. Now I reach a point where I need a little more powerful environment.

So I buy a new laptop, briefly Asus UL80vt boosted with an Intel Postville SSD drive, using hard drive in an external USB box for VMs as well as two hot USB keys (16Go Corsair Flash Voyager GT). Work well, great autonomy and powerfull...just a deception : I haven't an eSATA port, I have to rely only on USB...what a shame. But it is just what I need to support my plans.

So with this configuration, I can run several virtual machines given the 4Go RAM and 64bits host OS. For now, I am using VMWare Player as virtual hosting environment (mainly because Virtual PC does not support 64bits guests).

VMs allow me to separate tests. For now, for instance, I got the following VMs:

Windows Server 2008 with TFS2010 Beta2 (I need to upgrade to just released RC I know...)
Windows 7 with VS2010 Beta2
Windows 7 with VS2008

To build these VMs, I always keep a clean copy of each OS VM with base software I am used to. It is a little bit as if I do snapshot with VMWare Workstation.
Moreover, I track what I installed on each VMs (software version) in an Excel sheet.

My Google Reader & Delicious accounts
I use it to track RSS feeds on the web. There are mainly of three types:

Community lists/forums (NHibernate, DDD, DDD Paris, TDD, Alt.net, Alt.net Paris…)
Individual blogs (ScottGu, Udi Dahan, Martin Fowler, Ayende Rahien…)
Blog community (CodeBetter, Los Techies, devlicious...)
Feed agregators & news site (DotNetGuru.org, Dotnetshoutout, InfoQ...)

I use my Share Items to share news. I prefer Delicious to bookmark and share my favorite web pages. On Delicious, I can better and simpler organize bookmarks through tags.

Participating in community
That the part I discovered last year with Alt.Net Paris community starting. It is the best place to learn and share with maximum interactivity. You learn a lot from others experiences, you meet some great people with rich experience.
Definitively a great experience!! Come to join us.

And finally this blog
I started this blog one year ago, and I experience difficulty to post regularly...I try my best and hope I will improve.

Expression Trees and Reflection performances

2009-07-02T23:52:00.016+02:00

Context

Lots of people think Reflection is evil for performance, but if you can tune your code to avoid some problems, and even better, you can write code as quick as "good old fashion C# code" (I mean writing code without Reflection).

Beware, I am not justifying use of Reflection in any application to implement the "graal of generic code". I think that Reflection could be used in some frameworks, but application code must be strongly typed for readability and maintainability. Example of framework is Object/Relational Mapping, and that's why I would like to talk here of Reflection and performance, because ORM performance can be a performance bottle-neck in an enterprise application.

I worked on a project that uses a "home maid" ORM, which one uses Reflection to create object instances (entities) and to hydrate them. Working on performance with a memory profiler, I saw that a lot of time was spent in Type.GetProperty PropertyInfo.SetValue method (both in same proportion). So I had a look at code and saw that first I could cache the PropertyInfo retrieved by Type.GetProperty, which give me a 50% performance win relative to overhead time spent in Reflection.
It is a first lesson on Reflection performance, cache Reflection objects relative to objects you use.

Then, I think about the old time when we only have Reflection.Emit to improve more this piece of code : you can reduce the overhead to zero using it, I let you find it on the web or see the implementation in NHibernate that uses this, because it seems a little bit painful since it is IL generation, i.e "improved assembler" more or less ;). Second lesson, time spent in Reflection could be reduce to the time taken to setup your application, and then with a zero overhead due to Reflection after that.

Finally, I had a look at new features of C#3.0 and .NET3.5 API, around LINQ and lambda expressions, then I was free from using Reflection.Emit. The main class is Expression found in System.Linq.Expressions. I am not sure, but probably it is less powerful than Reflection.Emit (I think of complex method generation...).

Now let's go into code with a simple case of setting a property one one million objects.

First try (lesson one learned)
I give you the following simple code : first with GetProperty and SetValue inside the iteration, and second, with GetProperty outside the iteration. Here is the code:

   1:  // Set using GetProperty + SetValue

   2:  init = DateTime.Now;

   3:  start = DateTime.Now;

   4:  foreach (SimpleObjectA o in objects)

   5:  {

   6:      prop = o.GetType().GetProperty("Name");

   7:      prop.SetValue(o, "plip", null);

   8:  }

   9:  end = DateTime.Now;

  10:  Console.WriteLine("Set using GetProperty + SetValue : {0} + {1}", start.Subtract(init), end.Subtract(start));

11:

  12:  // Set using GetProperty only once + SetValue

  13:  init = DateTime.Now;

  14:  prop = typeof(SimpleObjectA).GetProperty("Name");

  15:  start = DateTime.Now;

  16:  foreach (SimpleObjectA o in objects)

  17:  {

  18:      prop.SetValue(o, "plip", null);

  19:  }

  20:  end = DateTime.Now;

  21:  Console.WriteLine("Set using GetProperty only once + SetValue : {0} + {1}", start.Subtract(init), end.Subtract(start));

Second try
Then, I tried to make it with Linq.Expressions. And it gives me some interesting thoughts about how to prepare the setter at initialization.
First, I thought to create a strongly typed Expression of the type Action where T is the object which has a property to set, PT is the type of the property to set, in my example, it was very simple, but in ORM context for example, it could be a little bit more tricky. Here is the code for example:

   1:  // Set using typed LambdaExpression (Action<T,I>)

   2:  init = DateTime.Now;

   3:  param = Expression.Parameter(typeof(SimpleObjectA), "x");

   4:  value = Expression.Parameter(typeof(string), "y");

   5:  setter = typeof(SimpleObjectA).GetProperty("Name").GetSetMethod();

   6:  Expression<Action<SimpleObjectA, string>> typedExpression = Expression.Lambda<Action<SimpleObjectA, string>>(Expression.Call(param, setter, value), param, value);

   7:  Action<SimpleObjectA, string> set = typedExpression.Compile();

   8:  start = DateTime.Now;

   9:  foreach (SimpleObjectA o in objects)

  10:  {

  11:      set(o, "plip");

  12:  }

  13:  end = DateTime.Now;

  14:  Console.WriteLine("Set using typed LambdaExpression (Action<T,I>) : {0} + {1}", start.Subtract(init), end.Subtract(start));

In fact, when doing mapping, you do not know the T type, then I think to use Action (Delegate in fact). Now you have to use Delegate and DynamicInvoke which far more bad than SetValue, so I searched for an other solution. For example, here is the code:

   1:  // Set using LambdaExpression + DynamicInvoke

   2:  init = DateTime.Now;

   3:  param = Expression.Parameter(typeof(SimpleObjectA), "x");

   4:  value = Expression.Parameter(typeof(string), "y");

   5:  setter = typeof(SimpleObjectA).GetProperty("Name").GetSetMethod();

   6:  LambdaExpression dynamicExpression = Expression.Lambda(Expression.Call(param, setter, value), param, value);

   7:  Delegate dynamic = dynamicExpression.Compile();

   8:  start = DateTime.Now;

   9:  foreach (SimpleObjectA o in objects)

  10:  {

  11:      dynamic.DynamicInvoke(o, "plip");

  12:  }

  13:  end = DateTime.Now;

  14:  Console.WriteLine("Set using LambdaExpression + DynamicInvoke : {0} + {1}", start.Subtract(init), end.Subtract(start));

So I found this article from Nate Kohari on Late Bound Invocation with Expression Trees. Then we use an Action and bound to real types inside the expression tree (which can be cached). Now, performance are equivalent to use the property setter directly. Here is the code:

   1:  // Set using typed LambdaExpression (Action<object,object>) -> late bound

   2:  init = DateTime.Now;

   3:  param = Expression.Parameter(typeof(object), "x");

   4:  value = Expression.Parameter(typeof(object), "y");

   5:  setter = typeof(SimpleObjectA).GetProperty("Name").GetSetMethod();

   6:  Expression<Action<object, object>> lateBoundTypedExpression = Expression.Lambda<Action<object, object>>(Expression.Call(Expression.Convert(param, setter.DeclaringType), setter, Expression.Convert(value, setter.GetParameters()[0].ParameterType)), param, value);

   7:  Action<object, object> lateBoundSet = lateBoundTypedExpression.Compile();

   8:  start = DateTime.Now;

   9:  foreach (SimpleObjectA o in objects)

  10:  {

  11:      lateBoundSet(o, "plip");

  12:  }

  13:  end = DateTime.Now;

  14:  Console.WriteLine("Set using typed LambdaExpression (Action<object,object>) -> late bound : {0} + {1}", start.Subtract(init), end.Subtract(start));

In conclusion, you will find time in ms I got on my laptop :

Strategy	Initialization time	One million iterations time
GetProperty + SetValue inside iteration	0	2891
GetProperty once & SetValue inside iteration	0	1953
Delagate + DynamicInvoke	187	6234
Latebound Lambda Expressions	0	31
Strongly typed Lambda Expressions	0	31
Property setter directly	0	31

I tried to go with 10 millions iterations, and I got approximatively 10x time in the previous table.
With 60 millions iterations, I try only the three most performant solutions and we starting to see little differences between them (I could have tried a realist situation with several properties bound, but in fact, I would try 10 millions iterations with 6 properties and it should give the same results):

Strategy	Initialization time	60 million iterations time
Latebound Lambda Expressions	0	2219
Strongly typed Lambda Expressions	0	1797
Property setter directly	0	1578

Applying IoC/DI in application architecture

2009-04-09T05:00:00.014+02:00

IoC and DI are two patterns more or less equivalent, I let Martin Fowler explains the details. IoC stands for Inversion of Control and DI for Dependancy Injection.
We will see in this post how to use effectively this pattern inside an application architecture, and which are the benefits of its use.

Application Architecture
There are a lot of architecture styles, but here we will focus on common approches : the layered architecture with generally 3 principal layers (that could be splitted in other layers themself, but we do not talk about it in this post...).
There are several approches :

in "classical" approach (Microsoft UI/BLL/DAL or Java Struts/Bean/DAO), we often talk about Presentation (or UI)/Business/Data
in DDD (Domain Driven Design), if I simply we have UI/Application Core/Infrastructure (I take the word of Jeffrey Pallermo in its "Onion architecture"

The "Onion architecture as described by Jeffrey Pallermo certainly leads to implement some good practices as IoC and DI, but it is also possible to do it in "classical" approach. I will come back on one project of my first project (starting at end of 2005) where I have to lead the application architecture (it was in .NET/C# but all in this post could apply to any OO language).

A little project story
When I started , I was aware of some good practices (thanks to DotNetGuru.org French community) like interfacing your classes, splitting in layers, using POCO, persistance ignorance, applying patterns (principally GoF patterns at this time)...but I wasn't aware of "Onion Architecture" approach then, so I try to implement a "classical" architecture (for the background, we do not use TDD).
This architecture was a little bit heavy to manipulate : for each new Web page, we need to create 3 interfaces and the 3 implementations, adding instanciation in some "home maid" Abstract Factory...and what we can notice it is that we do not realize why exactly we were coding this way, a little bit like robots in fact just because "it was the good practices".
And now I am working again on this project and nothing has changed, and it is great. Why ? Because I have learned some things I did not heard about 3 years ago, and I think it legitimates this architecture (and more over the Onion one in fact). It is what we will see next, but before have a quick overview of IoC/DI.

Overview of IoC/DI
I already give a reference to Martin Fowler post on the subject, but I would like to draw an overview of IoC/DI here for the purpose of the post. I will take an example with interfaces which represents the best exemple of IoC/DI use (even if you could imagine other use cases).
Typically, you have a class Client that relies on an interface IMyInterfaceA, which have an implementation MyImplA which one relies on IMyInterfaceB, which have an implementation MyImplB. So to link all these classes together, I have either:

to call MyImplA constructor in Client and MyImplB constructor in MyImplA, which create dependancy between all the implementations, loosing the benefits of interfacing (even if it is possible to enforce "localized" instanciation...but it needs to carefully control code which could be more )
to implement AbstractFactory pattern (I do not detail this point...)
or to use a IoC/DI framework

The IoC/DI framework will use the configuration file or configuration code to inject the dependancy of MyImplA when needing IMyInterfaceA and so on. Another thing to note is that it will inject recursively the dependancies, then when in Client class, I will request a IMyInterfaceA object, it will inject MyImplA as IMyInterfaceA, and MyImplB as IMyInterfaceB on which relies MyImplA class. I invite you to see details of the different injection mecanism : constructor injection, setter injection, method injection, interface injection...
So now, I think you should start to understand where I would like to go...
Applying IoC/DI
To resume, we have (or we need if starting) :

a layered application architecture using interfaces to separate layers (or even sub-layers)
one of the numerous IoC/DI frameworks (see here for .NET, Spring for Java...)

We are near done : we just have to use an IoC/DI framework in our application. We can certainly create a dependance on the framework everywhere we need it, but I would prefer creating a simple class that will be the only one that relies on the framework.
Then, for example (I do not assert that it is the best architecture), if we have consider the following layers :

UI
Business
- Business Services which take care of business processes = 2 projects, one for interfaces, one for implementation
- Business Entities which bring business rules = 2 projects, one for interfaces, one for implementation
Data Access Services which manage data access and manipulates Business Entities = 2 projects, one for interfaces, one for implementation

We can have the following hard dependancies :
We can add some dependancies, for example from BusinessEntityImpl to IBusinessService or from AnotherBusinessService to IBusinessService, but then a central point is that we have to take care of circular dependancies that could be made (for example if BusinessService depends on IAnotherBusinessService).
Nota that finally you no more need any new statement!

Ok ! But why using this finally ?
Yes, you are right if you are asking this question, but I have some answers beside the "ivory tour architect" answer : "because it is the right way" ;).
Since instanciation is delegated to the IoC/DI framework, you can then imagine a lot of things, but the one I prefer sounds like AOP (Aspect Oriented Programming). But it is not AOP with combined byte code, i.e byte code of generic cross-cutting concerns and your business byte code, it is done at runtime (yes then it could leads to performance issues but only in special cases...).
I give you an example in .NET with EntLib Policy Injection AB, it is really simple to add AOP if you already had IoC/DI :

In your Factory class that is the only one dependent on IoC/DI framework, rather than just calling the IoC/DI framework, call Wrap method of EntLib PolicyInjection class (David Hayden for more details)
Add in EntLib PolicyInjection AB configuration all the cross-cutting concerns you care applying only to a 'defined perimeter" (via policy, matching rules, see MSDN for more details).

Oh great ! How can I apply it to my project ?
If you are starting a new project, consider all the elements given in this post and be sure to understand what you are doing else it could lead to a disaster...
If you have an existing application, I see 2 cases :

either you are in a similar situation to the one I described (using interfaces, layers and other good practices...) and then it would be relatively easy to change your application step by step to reduce the technical debt (if considered like that).
either you are far from this situation, then consider a technical refactoring or if not possible, bear, cry or leave it depends ;)...but note that a technical refactoring could be done step by step also (but each step costs more than in the first case).

Hum...and what about performance ?
I think the performance problem should not be up front problematic to take care. Certainly, you should try to envision the performance issues you could encounter during developement to avoid starting again if the performance issue comes, but we should never say "I will never use this or that because it could lead to performance issues", it has to be studied in every cases.
Then I give here some advices to study performance impacts that could IoC/DI could have :

it is the "dynamic" instanciation (it does not necessarily use reflection since configuration could be done in code or configuration files could be loaded once at start) that costs more than a new, then consider instanciation strategies
consider using singleton pattern, it will avoid several instanciation when your class does support any state management
consider IoC/DI just for some of your objects, the relevant ones, but do not ban IoC/DI because one of your objects does not allow to use it

If I apply this in my last example, I could for example say that I would use IoC/DI for Business Services and Data Access Services classes with singleton strategy and do not use it for Business Entities (but then notice you will need dependancies to Business Entities implementation from Business and Data Access Services...)

TDD meeting at Alt.NET France

2009-03-27T22:48:00.004+01:00

On wednesday March, 25th, we have a meeting on TDD at Alt.NET France. It was animated by two Octo consultants, Frédéric Schäfer and Djamel Zouaoui. Again, we reach a new assistance record, around 30 people.

You can find a more detailed minutes I wrote in French on Alt.NET France site. I give here a quick synthesis of the conclusion I take from this meeting.

The presentation started with an overview on why testing or why not testing? The discussion raises a lot of stereotypes : "longer", "more expensive", "I'll make them later" (=never ;)) and so on...

Then we get to when testing is useful (and indeed more or less why) :

get code that just reveals developer intention (not more),
test at the right granularity,
protect yourself against inevitable application changes (regression),
loss of time in repetitive debugging and other test console applications which are not reusable.

Frédéric and Djamel presented some code samples around MasterMind game to underline how to apply TDD. Main points were :

make test first else you never will...
make simple test first, and increment complexity step by step,
don't try to conceptualize/develop the perfect thing on first try (let iterations drive you to the most accurate design),
use some UML diagrams to guide your global intention but do not lose yourself in details,
use the following virtuous circle : intention > test code (do not compile) > code to compile test code that fails the test (red test) > code that passes the test (green) > refactor (your code or your tests, not both in the same iteration)
write test correctly = AAA : Actor, Act, Assertions (be careful of tests without assertions)
a declared bug needs a test to ensure its correction
always run all the tests (which should be automatic and fast)

Finally, we get to deeper subjects, and I conclude that TDD is a practice that lead developers to a set of well-known and good design practices :

Apply patterns : dependency injection, GoF, M-V-VM for WPF was some of the examples, DDD...
Use mocks/stubs to isolate tested objects,
Continuous integration : to build and run tests continuously (and much more...),
Code coverage : beware of 100% coverage illusion, it does mean that your code is perfect because of entry data combinations problem.

I was already convienced with TDD, but I think I get a more precise vision of it now. To conclude, I think TDD brings :

code documentation (executable specifications),
protection againts regressions and during refactoring,
accurate and flexible design for your code.

Thanks again to Octo company, Frédéric and Djamel for hosting and organizing this meeting.

ALT.NET France is more and more active

2009-03-05T10:03:00.003+01:00

I am pleased to participate to ALT.NET France since August 2008, it beguns a little bit earlier on the impulsion of some people that continue to spend time on this great technical social community : Robert Pickering, Julien Lavigne du Cadet, Gauthier Segay, Romain Verdier and more (do not offuscate if I forget some people :o))...

We start with a Google group list and some informal meetings once a month in a bar, and since november, we meet around a defined subject presented by one of the community members. You can find on several blogs some comments about these meetings.

We know reach another step, Julien has setup a new web site, it will (or have to and/or should) be updated by the community.

So enjoy and join us, even if you are not fluent in French, you will be able to share with us, we have several not french members.

Object to object mapping : a painful task

2008-09-06T11:07:00.005+02:00

Remark : I have to refine this post, but I publish it since there is some news on the subject : AutoMapper has been published on CodePlex (see this post on Jimmy Bogard blog).

Context
In August 2008, I have got the same needs as Jimmy, so I have started to search on the community, I did not find any existing tool but I found these three links :
http://blog.jagregory.com/2008/05/06/futility-transforming-entities-into-dtos/
http://tech.groups.yahoo.com/group/altdotnet/message/14263
http://ayende.com/Blog/archive/2007/12/05/Object--Object-mapping.aspx

I also have a look at "the other side" (i.e. Java), and it exists a framework named Dozer. It makes implicit mapping as you explain, but for more complicated mapping, you make the mapping in XML files like (N)Hibernate does.

I would like here to detail a little bit the why I found this type of tool useful.

Requirements
In the first link I give, James Gregory talked about three requirements:

Refactoring friendly. No strings for property names, changing names should give compiler errors.
Must simplify code.
Must improve maintainability.

So, on the first requirement, configuration approach fails more or less, because in fact, you will unit test your classes which make use of the mapper (and not make unit tests for string inspection, that have no value as said by James). More over, I have got a feedback from a Alt.net meeting that was I should add a fluent interface, which makes configuration much more reliable and refactoring friendly. I am more and more open to this type of API.

On the second requirement, it is the one I prefer because I am bored to write mapping code, and implicit mapping simplify it. There is a difference between mapping code and configuration complexity because in mapping code, you have to create object instances, to recurse on collections, to handle inheritance mapping (and that code is very boring), whereas with configuration, I just declare mapping between types and fields and I have implicit mapping.

On the third requirement, I think configuration is simpler than code, even if it needs to understand mapping framework.

Implementation
The central point of my first implementation was a huge use of Lambda expression and it simplifies a lot the code of the mapper.
The principal features I have implemented for now are:

explicit mapping through XML configuration (fluent interface or at least API in mind)
implicit mapping based on properties name
recursive mapping
inheritance mapping (in progress)
conversion during mapping (through Convert class)
types in scope : basic types, nullables, all enumerables (including generic ones), classes with public properties

I have several elements in an Excel sheets...I will share it.
I try to use a TDD approach so unit tests exists for these features.

I am very impatient to have a look at the Jimmy implementation (AutoMapper) and perhaps to participate to this tool improvement.

Subjects I would like to blog...

2008-08-28T22:56:00.000+02:00

In this post, I will keep a list of some subjects on which I would like to blog (in italic drafted ones):

General purpose
- Alt.Net Meeting Feedback : Object Oriented : an historical mistake or to be continued
- Software vendors: opened on communities Vs proprietarism
- Software quality: technical VS process ?
- Agile and Team organization
- Classify items : hierarchical Vs relational (ex mails, docs...)
Technical
- Object graph consistency, querying and (lazy) loading
- Object Application Cache
- SOA and legacy applications concrete integration by example: objectives, solutions, advantages/disavantages (how to integrate read/write operations)
- Application architecture: taking best pratices together
- Web State Management : client and server side (sessions, cache...)
Process & Tools
- Test Strategy : automation of Unit + Functional Tests (both coded, not recorded)
- Functional Test with Fitnesse and configuration management processes
- TFS Agile Process Template
- TFS customization

I will try to write on these subjects "shortly"...;)

Blog content

2008-08-28T22:48:00.007+02:00

I would to open a blog for long time, but I think I have more to learn from others reading their blogs until now. Today, I am always learning a lot from others in the community, but I would like to give my 2 cents on some subjects :

Microsoft technologies and others (because I think there is a lot to learn from other technologies)
Software architecture, including every levels : business, functional, applicative, technical
"Software world" industrialisation, around tooling and quality

My inspiration will come from :

"Software world" actualities
Reflexion about my job and the working environment
Community activities (forums, informal meetings, blogs...)

I would like to warn you that I could scratch english sometimes (since it is not my mother tongue, which is the french), please be indulgent but let me know when it is unsupportable ;), I would like to improve my english also.

I often say things bluntly, it is volunteer, in order to emphasize the message I want to share, and then must not be interpreted as opinionated behavior. I have some conviction I like to talk about, but I would like to change them if I am truly convinced by any other points of view.

Now, it is time to read some posts...do not hesitate to share your thoughts, but stay correct.