Veille technologique semaine 7

Je vous propose, pour cette semaine, les quelques articles suivants :

• Pourquoi faire de la modélisation UML : le taux de réussite actuel des projets logiciels est de 16% (dans les coûts, les délais et les fonctionnalités). Ce taux passe à 9% dans les grandes entreprises. Que fait-on pour augmenter la probabilité de réussite de nos projets logiciels ?
  La suite de ce cours UML 2 vous sera proposé la semaine prochaine : Diagrammes de composants et Mise en œuvre d'UML.
  Ce cours UML 2 (que je vous recommande) est disponible en entier à l'url suivante :
  http://laurent-audibert.developpez.com/Cours-UML
• Répartition de charge avec Terracotta : l'augmentation de puissance de calcul réalisée avec un cluster.
• Encore le threading pour paralléliser des requêtes SQL sur du multi-core
• Un article pour débuter dans la réflexion Java
• Un exemple d'utilisation du Beans Binding du JSR 295 prévu pour le JDK 7
• La 8° édition de Core JAVA édité par SUN mis à jour avec le JDK 6.

Bonne lecture.

Introduction à la modélisation objet
En 1995, une étude du Standish Group dressait un tableau accablant de la conduite des projets informatiques. Reposant sur un échantillon représentatif de 365 entreprises, totalisant 8380 applications, cette étude établissait que :

- 16,2% seulement des projets étaient conformes aux prévisions initiales,
- 52,7% avaient subi des dépassements en coût et délai d'un facteur 2 à 3 avec diminution du nombre des fonctions offertes,
- 31,1% ont été purement abandonnés durant leur développement.

Pour les grandes entreprises (qui lancent proportionnellement davantage de gros projets), le taux de succès est de 9% seulement, 37% des projets sont arrêtés en cours de réalisation, 50% aboutissent hors délai et hors budget.

Une enquête effectuée aux USA en 1986 auprès de 55 entreprises révèle que 53% du budget total d'un logiciel est affecté à la maintenance.

Implementing Master-Worker with Terracotta
Recently Shine Technologies distributed one of its applications using Terracotta and achieved significant performance gains. In the past, our application performance was generally limited by the server it was running on. With Terracotta this no longer appears to be the case. During our performance testing, when one server was at capacity, we just added another and the overall application throughput increased markedly - to the point that our main limiting factor was the database.

Query by Slice, Parallel Execute, and Join: A Thread Pool Pattern in Java
This article will first show you how to effectively utilize ROWNUM at the database level itself, so that we implement "true pagination": querying data in slices. Of course, you may also want to do some business processing to the fetched data. If you have millions of rows to be processed, you may want to process them in parallel to fully utilize the available processing power. In Java we use threads to do this, but with the advent of Java SE 5's Java.util.concurrent.ThreadPoolExecutor, we also have a means to reuse the threads created. This means our paged data can be sent in batches to available threads in a thread pool. The JDK also provides us a mechanism to "join" back or aggregate the processed results from multiple threads.

Contents

• Query Data in Slices
• Parallel Task Execution in Java: Threads--The Old Mantra
• Pool Your Java Threads: ThreadPoolExecutor--The Smarter Way
• A Sample Demonstration of Thread Pools
• Build and Run the Sample
• Summary
• Resources

Reflection in Action
Reflection is a mechanism that enables dynamic discovery and binding of classes, methods, fields, and all the other elements the language is made of. Reflection can do more than just simply list classes, fields, and methods. Through reflection, we can actually create instances, invoke methods, and access fields if need be.

Beans Binding Via The Road Less Travelled By ((Part 1))

Beans Binding (JSR 295) is a new JCP standard for binding two bean
properties, especially in UI components. In a recent pair of
tutorials, Geertjan Wielenga explains with two short examples how to
create a master-detail UI with Beans Binding and Swing.

Most tutorials on Beans Binding (JSR 295) have, up to now, focused
either on the minute details of this new API, or demonstrated how
NetBeans could automate much of tedium of binding user interface
properties to business objects and vice versa. As a result, much
example code available for Beans Binding is either specific to
NetBeans and its GUI editor, or confined to small snippets
illustrating some detail of the JSR 295 API.

What do you think of the Beans Binding API?

Book Review: Core Java: Volume I, Fundamentals (8th Edition)
The book begins as you might expect, explaining a bit about the Java platform and how to download and install the JDK. It also provides examples so that you can be sure that you're up and running on your computer. By page 35, you get to the meat: programming structures and syntax.