vendredi 29 février 2008

Veille technologique semaine 9



Pour le menu de cette semaine, je vous propose une carte panachée de sujets industriels et techniques :
  • Adobe propose la version 1 de la technologie AIR qui succède au Flash pour le Web bien connu.
  • Microsoft publie ses technologies pour l'interroperabilité : http://www.microsoft.com/interop/principles/default.mspx
  • Première utilisation de la plate-forme Java Android de Google pour les applications de mobilité (smart phone, etc...) ,
  • La suite du cours sur UML 2 : la mise en oeuvre. Je vous rappel que ce cours est disponible à l'adresse suivante : http://laurent-audibert.developpez.com/Cours-UML,
  • Un langage de plus qui commence à être populaire Scala. Il est nativement interroperable avec les plate formes Java et DotNet. On constate, que devant la prolifération des technologies (langages de programmation inclus), il faut essayer de s'en abstraire le plus possible. Il est donc indispensable, plus que jamais, que l'architecture et l'implémentation de nos systèmes logiciels soit indépendante de ces technologies (technologie agnostique).
  • Le péril du typage faible, ou le contraire du Fail Fast : comment trouver les erreurs au plus tôt. THALES a mesuré que le coût de la correction d'une erreur est multiplié par 10 lorsqu elle est trouvé dans la phase suivante celle qui l'a introduite. La moyenne sur les projets logiciels THALES est de 20 fois (avec des pointes à 50 ou 100 fois). Pour la maîtrise des coûts et des délais, il est vital d'avoir un ensemble de technologies qui nous permettent de détecter les erreurs au plus tôt (Model Driven, Composants, typage statique). Ceci est d'autant plus important que THALES a 80% du code développé qui part en maintenance,
  • Quelques réflexions sur le type statique versus le typage dynamique.

Bonne lecture.


Adobe Releases AIR 1.0 and Flex 3.0 - Continues Move to Open Source
12 months after the initial SDK alpha of AIR, Adobe has released Flex 3.0 and the 1.0 version of AIR (Adobe Integrated Runtime). Flex leverages Adobe's Flash player to provide a framework for building interactive rich internet applications (RIAs). AIR in turn allows developers to build desktop applications using either Flex or a combination of HTML/CSS/JavaScript. AIR currently supports Windows XP, Windows Vista, and Mac OS X. Linux support is targeted for AIR 1.1.


Microsoft's Open Protocol Announcement
Microsoft announced a commitment to publishing its document formats this past week under the umbrella of Interoperability Principles
, including document formats for Word, Excel, PowerPoint, and more - with an intent to document most if not all of their communication formats.


La plate-forme ouverte de Google fait ses premiers pas
Trois mois après sa présentation, Android de Google prend forme au Mobile World Congress de Barcelone. Aucun fabricant n'a dévoilé de combiné exploitant la plateforme mais deux grands fondeurs de la planète mobile, ARM et Texas Instruments, ont présenté leurs prototypes.


Mise en oeuvre d'UML
Comme nous l'avons déjà dit, à maintes reprises, UML n'est qu'un langage de modélisation, ce n'est pas une méthode. En effet, UML ne propose pas une démarche de modélisation explicitant et encadrant toutes les étapes d'un projet, de la compréhension des besoins à la production du code de l'application. Une méthode se doit de définir une séquence d'étapes, partiellement ordonnées, dont l'objectif est de produire un logiciel de qualité qui répond aux besoins des utilisateurs dans des temps et des coûts prévisibles. Bien qu'UML ne soit pas une méthode, ses auteurs précisent néanmoins qu'une méthode basée sur l'utilisation UML doit être :

  • Pilotée par les cas d'utilisation
  • Centrée sur l'architecture
  • Itérative et incrémentale

What is Scala?
Scala is a general purpose programming language designed to express common programming patterns in a concise, elegant, and type-safe way
. It smoothly integrates features of object-oriented and functional languages. It is also fully interoperable with Java and .Net.

Scala is the successor of Funnel, a language based on join calculus.

Scala is object-oriented
Scala is a pure object-oriented language in the sense that every value is an object. Types and behavior of objects are described by classes and traits. Class abstractions are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance.

Scala is functional
Scala is also a functional language in the sense that every function is a value. Scala provides a lightweight syntax for defining anonymous functions, it supports higher-order functions, it allows functions to be nested, and supports currying. Scala's case classes and its built-in support for pattern matching model algebraic types used in many functional programming languages.

Furthermore, Scala's notion of pattern matching naturally extends to the processing of XML data with the help of right-ignoring sequence patterns. In this context, sequence comprehensions are useful for formulating queries. These features make Scala ideal for developing applications like web services (external link).

Scala is statically typed
Scala is equipped with an expressive type system that enforces statically that abstractions are used in a safe and coherent manner. In particular, the type system supports:

  • generic classes,
  • variance annotations,
  • upper and lower type bounds,
  • inner classes and abstract types as object members,
  • compound types,
  • explicitly typed self references,
  • views, and
  • polymorphic methods.

A local type inference mechanism takes care that the user is not required to annotate the program with redundant type information. In combination, these features provide a powerful basis for the safe reuse of programming abstractions and for the type-safe extension of software.

Scala is extensible
The design of Scala acknowledges the fact that in practice, the development of domain-specific applications often requires domain-specific language extensions. Scala provides a unique combination of language mechanisms that make it easy to smoothly add new language constructs in form of libraries:

any method may be used as an infix or postfix operator, and closures are constructed automatically depending on the expected type (target typing). A joint use of both features facilitates the definition of new statements without extending the syntax and without using macro-like meta-programming facilities.

Scala interoperates with Java and .NET
Scala is designed to interoperate well with popular programming environments like the Java 2 Runtime Environment (JRE) and the .NET Framework (CLR). In particular, the interaction with mainstream object-oriented languages like Java and C# is as smooth as possible. Scala has the same compilation model (separate compilation, dynamic class loading) like Java and C# and allows access to thousands of high-quality libraries.


THE PERILS OF DUCK TYPING
The idea behind "Duck Typing", which has recently be made popular again by Ruby and other script languages, is to make the concept of types less restrictive.

STRUCTURAL TYPING VS. DUCK TYPING
A while ago, I explained why I thought that Duck Typing was dangerous. More recently, Scala
popularized a different type of typing called Structural Typing, which is often described as
being "type safe Duck Typing". Let's take a closer look at Structural Typing and see if it
delivers on this promise.
With Duck Typing, you send a message to an object in absolute darkness
. You don't know whether this object knows this message and you just trust the caller to have passed you an object that does.


Dependency Injection and Type Safety
I've had a couple interesting discussions recently about dependency injection and type safety. In
particular there is a new article up discussing type safety in the Butterfly DI framework. I think
Jakob makes some good points and argues well that perhaps too much is made of the lack of
type safety in Spring XML config
. (And yes, I know you don't have to do it in XML.)

Type Safety when using Butterfly Container (or Spring XML)
It is often claimed that dynamic reflection based dependency injection (DI), like Spring's XML configurations or Butterfly Container Script, are not type safe, and therefore bad, error prone etc.

vendredi 22 février 2008

Veille technologique semaine 8


Pour le point technologique de cette semaine, je vous propose les articles suivants :
  • Toshiba arrêt le HD DVD
  • Blu-ray Disc Java : Java et le Blu Ray : BD - J.
  • la deuxième partie du cours UML 2 avec la notion de composant : pourquoi faire des composants ?
  • un article sur les Domain Specific Language (DSL) : la définition de Marin Fowler et son application avec Java, Groovy et Ruby. On trouve des applications dans JUnit 4.4 pour les assertThat(), dans JMock avec les Expectactions() et le meilleur (pour Java) étant Quaere, une implémentation Java d'un langage de requête à la LINQ de C#.
  • La gestion des interruptions sur les thread Java.
Bonne lecture.


Toshiba Announces Discontinuation of HD DVD Businesses
Toshiba Corporation today announced that it has undertaken a thorough review of
its overall strategy for HD DVD and has decided it will no longer develop, manufacture and
market HD DVD players and recorders.

DVD Blu Ray et Java : BD - J
DVD is about to be replaced by a new format promising far better audio and HDTV video, far greater storage, and an exciting interactivity platform powered by the same Java Platform, Micro Edition (Java ME) technologies already widely deployed for MHP and OCAP digital TV devices. Blu-ray is backed by most of the major consumer electronics companies, PC vendors, and movie studios and promises to have as great an impact on consumers' movie viewing habits as VCRs and DVD players did.
Whereas HD-DVD used ECMAScript for programming interactivity, Blu-ray uses Java. Thus, Java ended up being an integral part of next generation home video.
In the video, Deep Dive: Blu-ray Disc Java, An Interview With Bill Foote, Sun's Blue-ray Disk Java architect explains how Java facilitates the interactivity of Blue-ray Disks, and walk you through a sample application.

Diagrammes de composants
Pourquoi des composants ?
Parmi tous les facteurs qui concourent à la qualité d'un logiciel, nous avons introduit la notion de réutilisabilité comme étant l'aptitude d'un logiciel à être réutilisé, en tout ou en partie, dans de nouvelles applications. Or, la notion de classe, de part sa faible granularité et ses connexions figées (les associations avec les autres classes matérialisent des liens structurels), ne constitue pas une réponse adaptée à la problématique de la réutilisation.
Pour faire face à ce problème, les notions de patrons et de canevas d'applications ont percé dans les années 1990 pour ensuite laisser la place à un concept plus générique et fédérateur :
celui de composant.
La programmation par composants constitue une évolution technologique soutenue par de nombreuses plateformes (composants EJB, CORBA, .Net, WSDL, . . .). Ce type de programmaiton met l'accent sur la réutilisation du composant et l'indépendance de son évolution vis-à-vis des applications qui l'utilisent.
La programmation orientée composant s'intègre très bien dans le contexte de la programmation
orientée objet puisqu'il ne s'agit, finalement, que d'un facteur d'échelle.
En effet, l'utilisation de composants est assimilable à une approche objet, non pas au niveau du code, mais au niveau de l'architecture générale du logiciel.


Domain Specific Language: DLS by Martin Fowler
The basic idea of a domain specific language (DSL) is a computer language that's
targeted to a particular kind of problem, rather than a general purpose language that's
aimed at any kind of software problem.

An Approach to Internal Domain-Specific Languages in Java
Introduction
A domain-specific language (DSL) is commonly described as a computer language targeted at a particular kind of problem and it is not planned to solve problems outside of its domain. DSLs have been formally studied for many years. Until recently, however, internal DSLs have been written into programs only as a happy accident by programmers simply trying to solve their problems in the most readable and concise way possible. Lately, with
the advent of Ruby and other dynamic languages, there has been a growing interest in DSLs amongst programmers. These loosely structured languages offer an approach to DSLs which allow a minimum of grammar and therefore the most direct representation of a particular language.
However, discarding the compiler and the ability to use the most powerful modern IDEs such as Eclipse is a definite disadvantage with this approach. The authors have successfully compromised between the two approaches, and will argue that is quite possible and helpful to approach API design from the DSL orientation in a structured language such as Java. This article describes how it is possible to write domain-specific languages using the Java language and suggests some patterns for constructing them.


Quaere: LINQ Arrives for Java
Lists the features of Quaere:
  • Ability to perform queries against arrays or data structure implementing the Iterable interface.
  • An internal DSL (based on static imports and fluent interfaces) that lets you integrate the query language with regular Java code. No preprocessing or code generation steps are required to use the DSL, simply add a reference to the quaere.jar file (and its dependencies).
  • A large number of querying operators including restriction, selection, projection, set, partitioning, grouping, ordering, quantification, aggregation and conversion operators.
  • Support for lambda expressions.
  • The ability to dynamically define and instantiate anonymous classes.
  • Many new "keywords" for Java 1.5 and later.


Creating Domain Specific Languages with Groovy
Venkat's session provided information about what DSLs are, there characteristics, the types of DSLs (internal vs. external), as well as, the Groovy features for creating and using them. Venkat primarily focused on creating internal DSLs using some of Groovy's built-in features:


Building Domain-Specific Languages in JRuby
Closing out the Java One conference last week was Rob Harrop's presentation "Exploiting JRuby: Building Domain-Specific Languages for the Java Virtual Machine." Domain specific languages (DSLs) have been gaining popularity, as shown on InfoQ with a presentation on an introduction to domain specific languages by Martin Fowler and posts on the debates in the blogsphere, and provide a way to create a custom language for a specific programming or business purpose.




Thread.interrupt()
As it stands, and has been said, stopping threads dead in their tracks was deprecated as it potentially leads to severe problems, the most prevalent being deadlocking. And I concur that the first suggestion is a textbook example of how not to attack this problem.


There is a fairly recent package giving advanced features to deal with concurrency, namely java.util.concurrent and its subpackages. There are far better books and articles out there than I could possibly put together. But it is also a quite advanced topic, and you're perhaps not ready to go there.


Thread.interrupt() is a powerful tool. This works if your thread is blocked on an interruptible operation like Object.wait(). But the easiest way remains to build your libraries/application so that it is easily interruptible. Consider the following (contrived) example:


void copy(Collection source, Collection destination) {
for
(Object o : source) {
if
(Thread.isInterrupted()) break;
destination.add(o);
} }

However, if your thread is blocked on a non-interruptible operation, then there is typically nothing you can do. Perhaps another thread can unblock you by, say, closing a stream you're reading from if the stream so allows. But usually, it's out of your hands.

So, basically, if the code you invoke is not built to handle interruptions, there's nothing you can do about it. Think about this when you go about writing potentially blocking code of your own.
Hope this clears things up for you, Jonathan

PS: The java.nio package supplies classes to work with non-blocking I/O. If you're trying to interrupt a blocking read from an inputstream, consider checking out channels; those can be configured not to block.

vendredi 15 février 2008

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.


vendredi 8 février 2008

Veille technologique semaine 6

Pour cette semaine, je vous propose :
  • le démarrage d'un projet européen sur un framework Java temps réel : Jeopard. EADS participe.
  • une analyse sur C# 3.5 qui prend l'avantage par rapport à Java avec le langage de requête intégré LINQ
  • la différence entre la notion d'injection de dépendance et la notion de composant logiciel.
  • le projet JoSQL qui propose des requêtes SQL sur des collections d'objets Java : c'est un exemple de séparation des préoccupations de persistance et de quêtes. Les systèmes de gestion de base de données (SGBD) ont toujours mélanger les deux.
  • SUN annonce un concourt avec une prime de $175 000 pour récompenser la meilleur contribution aux projets open sources Java. Clôture des propositions début mars 2008. Préparer vos cahiers ?
  • James Gosling précise qu'il est pour les closures. Cela a toujours été prévu, mais pas fait pour des raisons de temps.
  • un articles sur les différents algorithmes de garbage collectors : c'est un sujet en évolution et amélioration permanente. Des réductions des perturbations de l'application par le garbage collector sont encore prévue pour le JDK 7.

Bonne lecture.


Open Group to Develop New framework for Java Real Time with Jeopard
Jason Stamper in an article reported that Open Group would be partnered with a consortium of European real-time technology developers, industrial manufacturers, and research organizations to develop a new framework for Java-based real-time applications on modern parallel processor systems.

Supported by the European Commission, the Java Environment for Parallel Real-time Development, Jeopard, project is investing over USD 4.9m in an advanced framework for real-time Java running on multicore and parallel systems.

Jeopard consortium includes four universities and research institutes including University of York, Vienna University of Technology, FZI, and the Technical University of Cluj-Napoca. It also includes three industrial manufacturers including EADS, RadioLabs, and SkySoft, and two embedded systems technology suppliers including aicas and Sysgo.

The project will actively contribute to standards required for the development of portable software in the domain, such as the Real-Time Specification for Java (RTSJ). The Jeopard project will develop a platform-independent software development interface for real-time multicore systems. The interface will be based on existing technologies, including the Real-Time Specification for Java and Safety-Critical Java.


Does .NET With LINQ Beat Java?
There is a question some developers are asking: Has LINQ given Microsoft's latest .NET Framework an edge over Java? Industry experts say "yes," but with some caveats.

Microsoft shipped Language Integrated Query as part of the .NET Framework 3.5 in November. LINQ was originally one of many research projects that the company has under way. LINQ integrates query concepts directly into .NET programming languages using a syntax that is similar to SQL, to simplify the querying of data, objects and XML.


Dependency Injection: New Ground or Solid Footing?
McVeigh is an academic that is working on Architecture Description Languages (ADLs) as part of his Ph.D.

McVeigh provides this definition of a software component:

A component is a unit of software that can be instantiated, and is insulated from its environment by explicitly indicating which services (via interfaces) are provided and required.

A Java or .Net class is not a component per se. A class can describe what it provides by means of its interfaces, but it does not declare exactly what it depends on to run.

A major feature of ADL's is the fact that the connectors are explicit. It's not just loose wire, but a cable with an HDMI connector on the end. The explicit nature of the connectors provide ADLs with interesting architecutal features, including improved testability and improved architecural tooling.

In certain ADL's the connectors can be more functional. They can act like components in their own right, by performing extra functions like filtering or error handling.

  • A major feature of ADL's is the fact that the connectors are explicit.
  • Another major differentiator between ADLs and current DI technology is the notion of a Composite Component.

Finally, McVeigh laments the disconnect between academic and industry in software development. Academics aren't interested in the industry's trodden ground and academic work is inaccessible to industry, and may be considered not worthy of production. Yet it's apparent both could gain by a closer relationship.

What is a software component?
Leaf and Composite Components
Composition is a powerful way to hide complexity.

Spring is slightly unusual in this respect. A Spring bean must be associated with a class, so technically speaking it does not offer composite components, at least not in the way that most ADLs would understand them.

Explicit Connectors
A (Biased and Imperial College-Centric) History of ADLs
It may surprise readers to know that the second version of the Unified Modeling Language (UML) contains a perfectly workable ADL somewhere inside the tangled mess of concepts.

Why not just use an ADL?
Given the extensive research and history behind ADLs, why can't we just use these for our production systems? Well, you couldn't even if you wanted to! At least not unless you work in certain closed commercial environments, or are prepared to deal with academic prototypes. ADLs simply didn't catch on in mainstream software engineering. They were perhaps "before their time", and got swept away in the OO-mania of the period. It also didn't help that they weren't promoted outside of the academic community.

The future of Dependency Injection?


What is JoSQL?
There are many Java applications where the use of SQL statements to perform searching/ordering/grouping and selecting of values from Java Objects would be very valuable. However often times the use of a fully-featured SQL database (free or otherwise) is either inappropriate and/or costly.

It would still be useful to be able to perform SQL like queries on Java Objects however, JoSQL is designed to "fill the gap". JoSQL uses SQL to perform operations on objects that are useful to Java programmers and as such diverges from "normal" RDBMS SQL in some areas, you have been warned!


OpenJDK Community Innovators' Challenge
Do you have a great idea for the OpenJDK Community? The OpenJDK Community and Sun Microsystems, Inc. are pleased to announce the OpenJDK Community Innovators' Challenge, a contest with up to $175,000 in awards, intended to encourage and reward developers working together in solving key problems, initiating new innovative projects that promote new uses for the code, developing curricula and training, and porting the OpenJDK code base to new platforms.


James Gosling: on the Java Road
Closures
Closures were left out of Java initially more because of time pressures than anything else.

In the early days of Java the lack of closures was pretty painful, and so inner classes were born: an uncomfortable compromise that attempted to avoid a number of hard issues.

The Closures Controversy

Closures Questions with Joshua Bloch at JavaPolis'07

Garbage Collectors
blog de Jon Masamitsu au sujet des garbages collector des différents JDK.

mardi 5 février 2008

Annonce de SUN pour une JVM multilangages : le projet Da Vinci Machine

L'actualité technologique avance tous les jours avec :

SUN annonce officiellement le support d'une machine virtuelle multi-langages. Le schéma est inspiré (copié) de DotNet. Il était déjà timidement présenté depuis le JDK 6 (standard d'intégration de langage de "script").

Microsoft a déjà intégré un complément de la couche CLR (Commum Language Runtime) une couche DLR (Dynamic Langage Runtime) pour accueillir les langages à typage dynamique comme Python ou Ruby.

Des architectes de SUN ont présenté au dernier Lang.NET symposium, au campus Microsoft à Redmond, des évolutions importantes de la JVM. Ces évolutions complètent le byte code et la JVM pour permettre un accueil plus performant de ces langages dynamiques. Cela va, au passage, accélérer certaines partie du JDK (la réflexion, ...).

C'est une avancée importante de la plate-forme Java (la JVM et les API), qui va dans le même sens que la plate-forme DotNet : unification des runtimes qui deviennent indépendant du langage source. Le langage n'est que un moyen d'accéder au runtime (Threading, Garbage collector, compilateur Just In Time, ...).

L'interopérabilité entre langages est native : le byte code (JVM ou DotNet) ne connais pas le langage source qui l'a généré. Toutes les solutions techniques déjà développé dans un langage pour une plate-forme sont utilisables dans un autre langage. Exemple : des objects écrit avec le langage Groovy sont répliqués entre deux JVM par la solution Terracotta qui sait distribuer des objets JVM (initialement fait pour des objets dont le source est en Java).

Cette unification des runtime est l'avancé la plus importante de ce début de siècle, dans le domaine du logiciel.


SUN parle de renaissance, car il y a déjà près de 200 compilateurs (y comprit le GNAT pour l'ADA avec JGNAT) qui génère du byte code pour la JVM. Le principe est déjà utilisé, mais cela n'est pas très connu. C'est pour cette raison que SUN souhaite en faire un peu plus de publicité.


url : http://openjdk.java.net/projects/mlvm

Bonne lecture.



Sun's Da Vinci Machine broadens JVM coverage
Intent is to make it easier for more languages to run on virtual machines

Sun is working on technology to make it easier to run different languages on the Java Virtual Machine. Called the Da Vinci Machine, the project is being described by Sun as "a multi-language renaissance for the Java Virtual Machine architecture."

The project features prototype JVM extensions to run non-Java languages efficiently as well as architectural support. lthough many languages besides Java have been implemented on the JVM, including Ruby, the intent is to make the JVM more compatible with other languages, said Charles Nutter, core developer of JRuby, which is a version of Ruby to run on the JVM. "For the most part, almost every language that's more than five years old has some kind of implementation on the JVM," he said.


2008 Lang.NET Symposium - Conference Agenda
This week several of us from Sun attended the Lang.NET Symposium.


BRAVO FOR THE DYNAMIC RUNTIME!
The centerpiece of the conference was of course Microsoft's Common Language Runtime, and especially the new Dynamic Language Runtime, Jim Hugunin's encore to IronPython which factors out the reusable logic that glues dynamic languages on top of the CLR.


Dynamic Languages on the JVM and the DLR
Sun announced today the Da Vinci Machine Project, an effort aimed at creating JVM extensions to support dynamic languages as first-class JVM citizens. Writing about the growing interest in new programming languages on the two main runtimes-the JVM and Microsoft's CLR-Sun's John Rose remarks in Bravo for the Dynamic Runtime.


New Languages on the JVM: Pain Points and Remedies
So what's missing?
• Dynamic invocation
• Lightweight method objects
• Lightweight bytecode loading
• Continuations and stack introspection
• Tail calls and tail recursion
• Tuples and value-oriented types
• Immediate wrapper types
• Symbolic freedom (non-Java names)
• And always, higher performance


Da Vinci Machine a multi-language renaissance for the Java Virtual Machine architecture
Mission
We are extending the JVM with first-class architectural support for languages other than Java, especially dynamic languages. This project will prototype a number of extensions to the JVM, so that it can run non-Java languages efficiently, with a performance level comparable to that of Java itself. Our emphasis is on completing the existing bytecode and execution architecture with general purpose extensions, as opposed to a new feature for just one language, or adjoining an unrelated new execution model. We want the new languages to co-exist gracefully with Java in the JVM, and to benefit (like Java) from its powerful and mature technologies.


Sub-Projects and Investigations

  • Dynamic invocation
  • Lightweight method objects
  • Lightweight bytecode loading
  • Interface injection
  • Continuations and stack introspection
  • Tail calls and tail recursion
  • Tuples and value-oriented types
  • Immediate wrapper types
  • Runtime support for closures
  • Faster interface invocation
  • Faster reflection
  • Symbolic freedom (non-Java names)

vendredi 1 février 2008

Veille technologique semaine 5

Je vous propose quelques éléments d'actualité technologique avec :

  • dans la série des grandes manœuvres, Nokia achète Trolltech (fournisseur de la librairie graphique QT),
  • un résumé des concepts du modèle de composant SCA (Service Component Architecture) d'IBM,
  • les nouveautés de C# 3.0 avec en premier plan le langage de requête natif LINQ (Language Integrated Query),
  • quelques spéculations sur les évolutions pour le JDK 7 (fin 2008 ?),
  • JavaFX : c'est quoi ? Pour quoi faire ?,
  • la création du club d'utilisateur Java (JUG : Java User Group) à Paris le mardi 12 février 2008 : comment allez-vous y contribuer ?
  • les chiffres de popularité des langages de programmation pour le mois de Janvier 2008

Bonne lecture.


Nokia Acquires Trolltech


Introducing Service Component Architecture (SCA)
For the past twelve months, I have been involved with the Service Component Architecture (SCA) specifications and two of the open source SCA implementations. Now that SCA is gaining industry traction, I would like to use my weblog here to introduce the technology and demostrate how SCA can be used for building standards-based enterprise class applications using service orineted principles and paradigms, through a series of weblog entries covering both the theory and practical aspects of SCA.


What's New in C# 3.0? Part 1

The release of Visual Studio 2008 updates C# to version, 3.0, with several key language enhancements and LINQ support. Part one of this series will walk you through implicit typing, automatic properties, and other time-saving enhancements.


What's New in C# 3.0 Part 2
One of the key additions to the .NET Framework is the support for Language Integrated Query (LINQ). LINQ allows you to manipulate data just like you manipulate database records using a query language like SQL. So instead of writing complex iterative loops to retrieve the data that you desire, you simply specify the data you want declaratively using LINQ and the compiler will do all the work for you.


Java 7 Predictions
The list you'll find below summarizes the majority of Java 7 features that have been talked about at one point or another and gives my own personal best guess as to the likelihood of inclusion. Note that a) these are my own personal guesses and do not reflect the actual activity of anyone involved in the JCP and b) these don't necessary reflect my own personal desires, just what I think is most likely.


Creating Rich Internet Applications With Compiled JavaFX Script Technology
The JavaFX family of technologies currently contains two products: the JavaFX Script and the JavaFX Mobile platforms. The latter is a platform for mobile phones and other mobile devices. The focus of this series of 18 articles is the JavaFX Script programming language, a simple and elegant scripting language that leverages the power of the Java platform.

As you'll see, JavaFX Script makes it easy to develop rich and responsive graphical user interfaces (GUIs). Part of its appeal is that graphical content developers can develop amazing user interfaces (UIs) even if they do not have an in-depth knowledge of programming.



Inauguration du Paris Java User Group
Le Paris Java User Group est un groupe d'utilisateurs Java ayant pour but de réunir les acteurs du langage
(professionnels, communautés open source, institutions, étudiants, enseignants...) afin d'échanger des idées et de discuter des avancées technologiques de la plateforme Java. Tous les deuxièmes mardis du mois a lieu une conférence ayant pour thème Java au sens large (langage, APIs, frameworks, logiciels, méthodologies,

process, qualité...). Ces évènements sont gratuits et ouverts à tous.


TIOBE Programming Community Index for January 2008

January Headline: TIOBE declares Python as programming language of 2007!

The TIOBE Programming Community index gives an indication of the popularity of programming languages. The index is updated once a month. The ratings are based on the world-wide availability of skilled engineers, courses and third party vendors. The popular search engines Google, MSN, Yahoo!, and YouTube are used to calculate the ratings. Observe that the TIOBE index is not about the best programming language or the language in which most lines of code have been written. The index can be used to check whether your programming skills are still up to date or to make a strategic decision about what programming language should be adopted when starting to build a new software system.