Les tweets de la semaine

http://twitter.com/penderi/statuses/7514754215 Souvent cité comme l’outil indispensable de Visual Studio, Resharper 5 est en beta et la dernière version semble prometteuse

http://twitter.com/dougcunha/status/7496302216 un aide-mémoire sur les principaux opérateurs Linq sous la forme de 101 exemples.

http://twitter.com/escobar5/statuses/7406606555 attention long article sur les fondamentaux de Linq

La question Stackoverflow

 http://stackoverflow.com/questions/2030636/c-read-only-calculated-properties-should-they-be-methods les propriétés calculées en .NET : doit-on coder une méthode ou une propriété en lecture seule ?

Actualités Microsoft

C’est peut-être une des nouvelles fonctionnalités de Silverlight 4 les moins discutées : l’incorporation de MEF dans le runtime. MEF est un framework open-source soutenu par Microsoft pour construire des applications extensibles en fournissant un système de plug-ins. Voici une série de vidéos pour aborder le nouveau couple MEF et Silverlight.

Actualités “Alt.NET”

Une des évolutions du TDD, BDD (Behaviour Driven Design) se propose de fournir une définition des tests en langage presque naturel et surtout très proche du domaine métier (c’est en cela qu’on présente le BDD comme étant du TDD + DDD). Cucumber est un framework BDD ruby mais qui supporte .NET et Java, Gojko Adzic en donne un exemple dans un billet.

De l’autre côté

Django est un framework web fondé sur le langage Python. Il a fait à Python ce que Ruby on Rails a fait à Ruby : démocratiser l’usage d’un langage pas très populaire. Ce développeur parle de son expérience en mettant en avant les fonctionnalités souvent citées : ORM, templating, interface d’administration. De plus le langage a connu un regain d’intérêt quand Google l’a choisi pour sa plate-forme cloud Google App Engine (depuis complétée avec Java).

Un projet

Script# est peu reconnu car c’est plus un outil qu’un Framework web classique comme ASP.NET MVC. Son développeur, Nikhil Kothari, est connu dans la communauté .NET pour fabriquer beaucoup de choses dans son “garage”. Script# est un compilateur C# vers Javascript pour être utilisé dans des applications web ou des gadgets Vista par exemple. L’une des applications de Microsoft qui l’utilise est Office Web, la version en ligne des applications bureautiques.

L’expérience de codage en C# :

Le debug :

Script# permet aussi la communication avec le serveur (JSON), incorpore une bibliothèque de composants graphiques de base comme la textbox mais aussi des textboxes avec des comportements auto-complétion ou watermaquée  etc.

Pour avoir une idée plus précise des possibilités et des limitations n’oubliez pas de parcourir le fichier PDF readme (40 pages) qui est une vraie documentation.

Les tweets de la semaine

 http://twitter.com/pedeveloper/statuses/6046161616 les index en base de données, on connaît mais les index clustérisés ? Un rapide et intéressant tour d’horizon des index sous SQL Server.

http://twitter.com/prodotnet pour apprendre (ou ré-apprendre) .NET un tweet à la fois.

La question Stackoverflow

 http://stackoverflow.com/questions/129389/how-do-you-do-a-deep-copy-an-object-in-net-c-specifically Copier un objet de type valeur est facile, copier un objet de type référence l’est moins car il a souvent lui même des références vers d’autres objets d’où le concept de “deep copy”, “deep”car on doit gérer un graphe d’objets.

Actualités Microsoft

C’est le grand calme après la tempête PDC. Que retenir de cette édition ? D’après Keith Elder dans un post sur dzone il faut faire le pari de Silverlight 4 et Entity Framework. Il est vrai qu’avec la version 4 de Silverlight on arrive au WPF/E (Everywhere) annoncé lors de sa première incarnation. De son côté le framework de mapping objet relationnel semble être le plus stable des investissements fait dans  ce domaine et son orientation “POCO” est un très bon signe.

Actualités “Alt.NET”

Depuis que Volta a été abandonné par Microsoft, il y a une place pour un framework comme GWT en .NET. Script# est similaire mais incomplet. Un message sur la liste de discussion altnet parle d’un effort par un développeur, Frank, de répondre à ce besoin. Est-ce qu’il y une place entre Silverlight et le couple ASP.NET MVC + jQuery ? Si cela ne vient pas de Microsoft peut-être que la communauté délivrera, appel à contribution lancé donc.

De l’autre côté

 La beta d’Adobe Air 2 est sortie en même temps que celle de Silverlight 4. Flash a connu 4 grandes étapes :

• la création du plugin en 1996-97 qui a permis d’utiliser (et d'abuser) des animations vectorielles
• le codec vidéo qui a révolutionné le streaming de vidéo sur le web (et de perdre beaucoup de temps sur youtube.com)
• Flex : peu connu du grand public (sauf pour les 10.000 clients Twitter), c’est avec Flex et ActionScript (le langage) que Macromedia a fait son entrée dans le monde du développement d’entreprise (avec un back-end en Java)
• Air : qui permet d’exécuter un programme en dehors du navigateur.

On compare souvent Air et Silverlight car ils se positionnent comme la plate-forme “smart client” (et sont souvent cités comme les concurrents de HTML5). Silverlight a l’avantage d’offrir une expérience de développement unifiée (client et serveur en .NET), Flash/Flex/Air celui du pourcentage de déploiement sur les postes des particuliers. Dans sa dernière incarnation Adobe fournit dans la suite un nouvel outil Catalyst qui permet de passer plus facilement d’un design de contrôle purement vectoriel à un “skin”réutilisable dans l’environnement de développement. 

Un projet

dotlesscss (.less{}) se propose de moderniser la manipulation et la définition  des feuilles de styles (CSS). Il existe des techniques pour optimiser les styles en utilisant les bons sélecteurs mais il est vrai que la maintenance peut être fastidieuse.

dotlesscss supporte par exemple la déclaration de variables globales, ici une couleur :

          
@brand_color: #4D926F; 
          
          
          
            #header { 
          
            color: @brand_color; 
          
}

          
          
          
            h2 { 
          
            color: @brand_color; 
          
}
        

ou encore les propriétés calculées :

          
@the-border: 1px; 
          
@base-color: #111; 
          
          
          
            #header { 
          
            color: @base-color
* 3; 
          
            border-left: @the-border; 
          
            border-right: @the-border
* 2; 
          
}

          
          
          
            #footer { 
          
            color: (@base-color
+ #111) * 1.5; 
          
}

          
          
        

Autopromotion (juste un peu)

nVentive sera présente lors des TechDays à Montréal : Erik Renaud animera une présentation d’introduction sur le Test-Driven Development (TDD).

Nous organisons un atelier sur le TDD, Test-Driven Developement,  le vendredi 27 novembre. Cette journée attache beaucoup d’importance aux exercices et aux outils que vous utiliserez dans la vie de tous les jours pour pratiquer un développement agile.

Voici un extrait de la description – consulter le lien ci-dessous pour plus de détails sur l’agenda.

Dans la première partie de ce cours, nous répondrons à la question "Qu'est-ce le  TDD ?" mais aussi le "pourquoi, dans quel but et à quel coût ?"
La deuxième phase est plus axée sur la mise en pratique avec les outils et frameworks orientés « xUnit » autour de cas pratiques. On verra également dans cette partie l'utilisation des « stubs » et « mocks » ainsi que les différences entre les différents types de faux objets qui permettent l’isolation des tests.
Pour terminer, on explorera les meilleures pratiques du TDD, les  pièges à éviter. On jettera également un regard sur les méthodes périphériques comme le « Behavior-Driven Development » et l'íntégration continue.

Inscription : http://nventive.eventbrite.com/
Contact : info@nventive.net

More fun with dictionaries on the way. We’ve seen how to read from a dictionary with the GetValueOrDefault() extension method but that’s not enough.

We usually need a way to add items to a dictionary if they aren’t already there. Here’s a simple example of a caching mechanism that relies on in-memory dictionaries:

Given:

A simple caching mechanism can be obtained using the Decorator pattern:

What basically happens here is that we’ll first try to find the value from the local dictionary (hence the cache) and if not present, go to the real repository to fetch the value and then create an entry in the local cache with the result. So what the code really wants to say is:

A simple refactoring of the previous implementation into an extension method would lead to something like:

Note again that we’re extending the minimal interface, IDictionary<T>, and leveraging an existing delegate type, Func<T>.

() => “Francois”

So far, we’ve seen useful tricks to extend basic collection types like IEnumerable<T> and ICollection<T> but more complex collections deserve attention too!

Let’s look at IDictionary<T>. Here’s some code I stumbled upon recently; it is a partial implementation of IDataErrorInfo:

The interesting part is:

What’s the intent of this code? Pretty obvious isn’t it? It checks whether the dictionary has a value for a given key, then returns the value. If the key isn’t found, it returns the default value. This is similar to how the Nullable<T> type works:

Here, for obvious reasons, indexValue’s value will equal 0. But what’s interesting is the GetValueOrDefault() method. It clearly expresses the intent as opposed to:

The same thing could apply to dictionaries but hasn’t been provided as part of the Base Class Library:

Here’s Umbrella’s implementation:

The first method is an overload that will return default(T) if a default value is required.

The second method takes the defaultValue as a parameter

The third method contains the actual implementation and relies on a delegate to obtain the value since the defaultValue could either take some time to process or cannot be known in advance.

Again, these extension methods are small helpers to reduce the friction of th BCL. They are not meant to completely change the programming paradigm. They aren’t intrusive either. They should increase predictability of the source code with a side effect of decreasing the total lines of code count.

() => “Francois”

There is code what we type over and over again without realizing how many mistakes can be made in a few lines. Let’s take the example where we want to remove items from a collection. Intuitively, the code should be something like:

However, this will fail miserably with an “InvalidOperationException: Collection was modified; enumeration operation may not execute.”

In fact, it doesn’t fail on the Remove() call, it fails on the MoveNext() as we can’t enumerate a modified collection or can’t modify a collection while enumerating. In order to work correctly, we learned that we need to first keep track of the items to remove and then enumerate through those and remove them from the collection:

Wow! That is a huge amount of code. At least it can be refactored in a generic extension method:

And then be used as:

In Umbrella, we go the extra mile and “simplify” the implementation of the Remove() extension method and dog food our own extensions:

What basically happens here is that we:

1. Filter the original collection to keep only the items to remove (Sounds familiar?)
2. Copy those items to a temporary list (Remember?)
3. For each of those items, call Remove() on the original collection (Rings a bell?)

() => “Francois”

Some extension methods in Umbrella are simple but yet useful. It usually ends up being exiting methods from the Base Class Library that weren’t defined on the simplest interface required but more as a helper method on more concrete types:

Let’s start with the most straighforward example:

Given:

We’ll usually see something like:

But when the item to add to the collection has a default constructor, we could have a shorter syntax:

But AddNew() isn’t a member of List<T>. Have you guessed how AddNew() is implemented? Using extension methods, of course but what should be extended? List<T>? It is actually ICollection<T> as it is the interface containing the Add method.

A generic constraint on T having a default constructor is required so that new() can be called.

I mentioned that some helper methods have been defined on concrete types on the past where now, with extension methods, they could be extending simple interfaces. It is the case of List<T>.AddRange():

What AddRange logically does, is call Add for each new item. If we were to boil it down to its simplest form:

Don’t get confused by the “collection.Add” syntax, it is the method group syntax. The equivalent lambda expression would be:

That’s it for Part 2!

() => “Francois”

For the last couple of days, Michael, a friend of us has changed his Messenger tagline to: “If the code speaks for itself, don’t interrupt”.

It expresses clearly the intent of Umbrella… To allow the developer to create code that speaks for itself as opposed to code that requires a translator.

Let’s take the following code:

If we were to “listen” to the code, it would say that for each arg in the args list, if the string has a value, it should be displayed in the console.

So in order to let the code speak more clearly, we should be able to write something like:

In order to obtain this simpler syntax, we simply leverage the extension methods paradigm from C# 3.0 and LINQ for the Where clause:

Remember, to code an extension it takes 3 ingredients:

1. A static class
2. A static method
3. The this modified on the first method parameter

As you probably guessed, the ForEach implementation is as simple:

Two important things to node with the ForEach extension:

1. We’ve extended the minimal interface required (IEnumerable<T>)
2. We’ve leveraged the existing Action<T> delegate as opposed to defining a custom one

In the following posts, we’ll show how much more the code can say!

() => “Francois”

In an agile team, things go fast. And when things go fast, it usually gets messy. But then, why agile teams have proven record of success?

An agile method is based on a set of values and principles that embrace and  support each other. When one aspect of the philosophy looks like it’s not “formal” enough, another practice supports its weaknesses.

Environment

In order to stay focused on the task at hand, an agile team will have to setup its environment to make sure everything runs smoothly. They will create unit tests and make sure they get the green light prior to a check-in; but that’s usually not enough. They need to make sure it works on their machine and that it can work on any other box matching the requirements.Those requirements represent the environment the software needs to live in to run smoothly (or at all). It will vary but can usually include:

• A specific version of the runtime
• Third party assemblies deployed (locally or in the gac)
• Configuration files at different URIs (ideally relative)
• Environment variables
• WMI schema registered
• Registry entries

Continuous Integration

An many variables come into play, we need to make sure that for a given set of values, the software always works the same. In order to do so, agile teams will setup a clean environment (build server), seal it and automatically test that whatever changes in the software, it will continue to run on this environment. That’s what continuous integration (CI) is all about: continuously integrating the latest changes into a given environment and automatically checking that it installs correctly, that it runs as expected.

Contamination

Why isn’t the dev environment clean enough? Because we all know many things are going on and aren’t ideal on a dev box:

• A newer version of a component is installed to test out features we might need in the future
• A beta is installed and then uninstalled (partially)
• Registry entries get deleted or manually added
• Parallel versions are running
• Debug versions are running
• Bits exist locally but aren’t in sync with source control (think Lib folder)

Those are all reasons why it might “work on your machine” but not on “every machine”. Choose your side.

Long and External

When code changes, it might break existing assumption. Agile teams will try to document those assumptions in some executable format, usually unit tests. But not all tests are born equal. Some are bigger and broader that simple units. Some are testing the integration, the system and the use case as a whole. Should a developer wait for every single test to pass when he changes a string.Format() argument before he commits the change back to the repository? Ideally yes. But that’s not ideal; he might end up having to wait for a while for those exhaustive tests to pass (or will they?).

When you have a CI mechanism with a dedicated build machine; the whole suite of tests will automatically run in the background when something changes in the source code repository. While the developer continue working on new problems, he will get notified if something broke the build. The context the breaking change was made in has still not totally dissipated and it is easy to figure out what went wrong.

A long running test is one thing, but what about external tests? Some other teams might have some dependencies on your code. Some other projects of your own might have some dependencies on these modified bits? What then? Well they should also be part of the CI build so that they too can receive quick feedback that something is going wrong.

Tools

There are many tools to help you with CI. Cruise Control .net is one of the most popular. CI factory is a facade over CC.net that eases the configuration process.

Process

CI should be put in place as soon as possible; usually during Sprint 0 so that the team is up and running for Sprint 1 and leverage the short feedback loop quickly. A good enough CI environment can usually be setup in less than a day.

But what if it fails? What if it fails between the new tests have been committed and they don’t make sense? What if code shows a flaw in the acceptance criteria? What if you have a dedicated test team as opposed to a truly cross-functional dev team? That’s where things get interesting.

There’s no absolute truth to this one. However, depending on the type of test that failed (integrated or unit), it might end up being the dedicated test team that lives on the front line, assesses the bug and then informs the dev team that something went wrong.

() => “Francois”

As you know, nVentive's founders Erik Renaud and Francois Tanguay are both MVPs. Now that means that we get an opportunity to work with Microsoft in order to provide feedback from our clients and the community. Now if you'd like to read more on what it means to Erik, go ahead and read it here !