Veille technologique semaine 12

L'actualité du monde logiciel ne s'arrête pas, je vous propose les sujets suivants :

• IBM est en discussion pour racheter SUN pour 6,5 milliards de dollars.
• Un livre qui vient de sortir, écrit par Robert Cecil Martin, traduit en français "coder proprement" dont la lecture est obligatoire. C'est un expert reconnu par la communauté qui propose des bonnes pratiques qui ont données des résultats.
• un article sur le Domain Driven Design : comment séparer correctement les préoccupations avec un tissage de code réalisé par une technologie de programmation par aspects (AOP) dont les points de coupures sont réalisés par des annotations (@).
• C#4 propose des API pour exprimer le principe de la programmation par contrat : les préconditions, les post conditions et les invariants sont disponible à l'aide d'une librairie. Exemple : string GetDescription(int x){ Contract.Requires(x>0); Contract.Ensures(Contract.Result<string>() != null);
• Les nouveaux langages qui s'execute dans une JVM canditat à l'entrée dans les entreprises : c'est une évolution des JVM qui deviennent multi-langages (comme DotNet).
• le nouveau garbage collector prévu pour le JDK 7 : Garbage First, donne de très bon résultat et SUN l'intègre dans le JDK 6 update 14 actuellement en beta. C'est un garbage collector qui est capable de réduire le temps de latence à quelques millisecondes au lieu de quelques dizaines de milliseconde actuellement.

Bonne lecture.


IBM en discussion pour racheter Sun

IBM serait intéressé par racheter Sun, c'est ce qu'affirme le Wall Street Journal citant des sources proches de ces sociétés. Des discussions seraient en cours mais rien ne garantit qu'elles aboutissent. Toutefois, dans le cas contraire, l'annonce pourrait se faire dès cette semaine.

IBM serait prêt à mettre 6,5 milliards de dollars sur la table (4,9 milliards d'euros) pour acquérir la totalité de Sun. Et de renforcer ainsi sa position face à HP. Sun aurait précedemment abordé HP et Dell pour se faire racheter affirme le quotidien économique. Sun a affiché des pertes de 209 millions de dollars sur son second trimestre fiscal.


Nettoyez votre code et devenez plus performant !
Si un code sale peut fonctionner, il peut également compromettre la pérennité d'une entreprise de développement de logiciels. Chaque année, du temps et des ressources sont gaspillés à cause d'un code mal écrit. Toutefois, ce n'est pas une fatalité.

Grâce à cet ouvrage, vous apprendrez à rédiger du bon code, ainsi qu'à le nettoyer "à la volée", et vous obtiendrez des applications plus robustes, plus évolutives et donc plus durables. Concret et pédagogique, ce manuel se base sur les bonnes pratiques d'une équipe de développeurs aguerris réunie autour de Robert C. Martin, expert logiciel reconnu. Il vous inculquera les valeurs d'un artisan du logiciel et fera de vous un meilleur programmeur.

Coder proprement est décomposé en trois parties. La première décrit les principes, les motifs et les pratiques employés dans l'écriture d'un code propre. La deuxième est constituée de plusieurs études de cas à la complexité croissante. Chacune d'elles est un exercice de nettoyage : vous partirez d'un exemple de code présentant certains problèmes, et l'auteur vous expliquera comment en obtenir une version
saine et performante. La troisième partie, enfin, sera votre récompense. Son unique chapitre contient une liste d'indicateurs éprouvés par l'auteur qui vous seront précieux pour repérer efficacement les défauts de votre code.

Après avoir lu ce livre, vous saurez
• faire la différence entre du bon et du mauvais code ;
• écrire du bon code et transformer le mauvais code en bon code ;
• choisir des noms, des fonctions, des objets et des classes appropriés ;
• mettre en forme le code pour une lisibilité maximale ;
• implémenter le traitement des erreurs sans perturber la logique du code ;
• mener des tests unitaires et pratiquer le développement piloté par les tests.

Véritable manuel du savoir-faire en développement agile, cet ouvrage est un outil indispensable à tout développeur, ingénieur logiciel, chef de projet, responsable d'équipe ou analyste des systèmes dont l'objectif est de produire un meilleur code.

Au sommaire
• Code propre
• Noms significatifs
• Fonctions
• Commentaires
• Mise en forme
• Objets et structures de données
• Gestion des erreurs
• Limites
• Tests unitaires
• Classes
• Systèmes
• Émergences
• Concurrence
• Améliorations successives
• Au coeur de JUnit
• Remaniement de SerialDate
• Indicateurs et heuristiques
• Annexe A : Concurrence II
• Annexe B : org.jfree.date.SerialDate
• Annexe C : Références des heuristiques


Domain-Driven Pointcut Design

• What is a pointcut language?
• The problems with using signature patterns in pointcuts
• Metadata to the rescue?
• Metadata and Ubiquitous Languages
• Bringing it all together: Domain-Driven Pointcut Design

Adopting New JVM Languages in the Enterprise

I'll limit my discussion to these representative (and best known) alternative languages for the JVM.

1. JRuby – Ruby running on the JVM.
2. Scala – A hybrid object-oriented and functional language that runs on .NET as well as the JVM. (Disclaimer: I'm co-writing a book on Scala for O'Reilly.)
3. Clojure – A Lisp dialect.

I picked these languages because they seem to be the most likely candidates for most enterprises considering a new JVM language, although some of the languages listed below could make that claim. There are other deserving languages besides these three, but I don't have the time to do them justice. Hopefully, you can generalize the subsequent discussion for these other languages.


.NET 4 Feature Focus: Code Contracts
Last year we started talking about Spec#, a language based on C# that supports design by contract. Design by contract builds on top of concepts like static typing, where certain actions cannot be performed unless it can be verified at compile time. Contracts usually take the form of pre- and post conditions such as a parameter or return value never being null or only containing a certain range of values.
Rather than force developers to learn a whole new language such as Spec#, Microsoft is working on a language-agnostic library that can beleveraged by any .NET language. In some ways contracts look like assertions, but they are very different under the covers. Contracts are supported by a combination of static code analysis, which can be both inside and outside the compiler, as well as by testing frameworks. They are also executable, meaning they behave like assertions when running a debug build.


New garbage collector G1 available in JDK7 / OpenJDK
Garbage collection forms a big part of languages like Java that support memory management. This post by Jeremy Manson discusses the new garbage collector that will form part of JDK 7, and which is already available in the latest OpenJDK drop.