vendredi 8 octobre 2010

Veille technologique semaine 40

Pour le bulletin de la semaine 40, je vous propose les sujets suivants :
  • la conférence Eclipse Day à Paris le 5 novembre 2010 : inscription gratuite,
  • sortie de la version 2.8 de mono qui est l'implémentation open source du framework DotNet : il propose toutes les fonctionnalité du langage C# 4.0,
  • sortie de la version 2.9 de LLVM (Low Level Virtual Machine) : le principe de la machine virtuelle pour le C, C++, Objectif C,
  • VMKit : l'unification des machines virtuelles : une base pour construire des machines virtuelles Java ou DotNet,
  • La programmation concurrente et le matériel,
  • La programmation concurrente : le point de vue du logiciel. La théorie du Fork/Join de Java 7 par son auteur Doug Lea,
  • Les options du compilateur Javac : pour des vérifications plus stricte du code source Java.
Bonne lecture

Eclipse Day Paris 2010 - Accueil
L'Eclipse Day Paris 2010 est l'événement français Eclipse de l'année 2010 rassemblant la communauté Eclipse autour d'une même et unique synergie.

Il se tiendra au Pavillon Royal le vendredi 5 Novembre 2010.
Il réunira les acteurs industriels français de l'écosystème Eclipse autour des thématiques suivantes :
  • Runtime
  • e4
  • embarqué
  • modélisation
  • data management
Cet événement est idéal pour les décideurs informatiques, les architectes logiciels et les responsables processus et méthodes qui souhaitent mettre en place Eclipse dans leurs projet.

A cette occasion vous aurez l'opportunité de rencontrer et discuter avec les acteurs qui font vivre l'écosystème Eclipse, les commiteurs, les éditeurs de solutions, ainsi que les membres de la fondation.

L'événement est ouvert à tous, dans la limite des places disponibles, de manière gratuite.

Mono 2.8 released with full support for C# 4.0
The Mono project, which produces an open source implementation of the .NET runtime, has released version 2.8. The update brings full support for version 4.0 of the C# programming language, substantial improvements to the optional LLVM-based Mono backend, and a new garbage collection implementation that is more efficient.

Mono was originally created to accelerate Linux application development and enable Windows developers to bring some of their existing code and skills to the Linux platform. The focus of the project has expanded in recent years as Novell has explored ways to monetize the underlying technology. Mono is increasingly viewed as a compelling tool for supporting rich embedded scripting in applications and bringing C# to environments where it wouldn't otherwise run.

Mono is used in a number of well-known applications, including the Second Life client and the Unity game development suite. Novell also offers its own Mono-based commercial development tools for building native iPhone
and Android applications with C#.

LLVM 2.8 Released
The LLVM team yesterday released LLVM 2.8, the low-level virtual machine infrastructure that includes a next-generation C/C++ compiler, optimiser, and run-time.

LLVM is actually a collection of projects which together form a means to do C, Objective-C and C++ compilation. Compilation itself is done with Clang, which has been able to compile both C and Objective-C for some time. Although C++ support was added in LLVM 2.7, the 2.8 release completes the C++ specification, which combined with libc++ provides a standard library for C++ applications. There's also a new LLDB debugger, which is a replacement for the erstwhile gdb debugger but uses the same parser and source code tools as the compiler does. Although it has been available for a while, LLDB sees its first release in LLVM 2.8.

Unlike GCC, which is a monolithic compiler released under the GPL, the LLVM family of tools are more modular – and thanks to a more permissive BSD license, can be embedded in commercial tools. As a result, applications like Apple's Xcode include Clang support which performs faster than the external gcc application – and not only that, but since the tool's AST can be introspected by the containing tool, gives the IDE much more power in understanding how the source code relates to the structure and compiled code.

In addition, the modular architecture allows for the Clang static analyzer to run over source code and identify potential bugs, as well as Klee, a symbolic virtual machine which can identify what sequence of events can occur within a program. One feature of Klee is that in the event of finding a bug, it can programmatically generate a test case to be able to exercise that condition to demonstrate that the fix has subsequently been made.

VMKit: a Substrate for Managed Runtime Environments
Managed Runtime Environments (MREs), such as the JVM and the CLI, form an attractive environment for program execution, by providing portability and safety, via the use of a bytecode language and automatic memory management, as well as good performance, via just-in-time (JIT) compilation. Nevertheless, developing a fully featured MRE, including e.g. a garbage collector and JIT compiler, is a herculean task. As a result, new languages cannot easily take advantage of the benefits of MREs, and it is difficult to experiment with extensions of existing MRE based languages.

This paper describes and evaluates VMKit, a first attempt to build a common substrate that eases the development of high-level MREs. We have successfully used VMKit to build two MREs: a Java Virtual Machine and a Common Language Runtime. We provide an extensive study of the lessons learned in developing this infrastructure, and assess the ease of implementing new MREs or MRE extensions and the resulting performance. In particular, it took one of the authors only one month to develop a Common Language Runtime using VMKit. VMKit furthermore has performance comparable to the well established open source MREs Cacao, Apache Harmony and Mono, and is 1.2 to 3 times slower than JikesRVM on most of the DaCapo benchmarks.

Concurrency Revolution From a Hardware Perspective
Brian Goetz and Cliff Click spoke at JavaOne conference last week about the concurrency revolution from a hardware perspective. They started off the discussion saying that the clock rate has been increasing exponentially until recently, but not so any longer. And for years, CPU designers focused on increasing sequential performance with techniques like higher clock frequency and Instruction Level Parallelism (ILP) but this approach is limited.

Going forward, the designers will focus on parallelism for increasing the throughput.

Brian gave an overview the main periods in CPU history which includes the CISC and RISC systems era and now multi-core machines. Cliff discussed the impact of data caching on the system performance. He said, as a general principle developers should think about data, not code. Data locality should be a main design concern for high-performance software. It's also important to follow the principle of share less, mutate less. The combination of sharing the mutable data is not desired because this will cause cache contention and requires synchronization.

Some of the point solutions to achieve concurrency in applications are:
  • Thread Pools and Worklists
  • Fork/Join
  • Map/Reduce
  • Actors
  • Software Transactional Memory (STM)
  • Graphics Processing Units

A Java Fork/Join Framework
This paper describes the design, implementation, and performance of a Java framework for supporting a style of parallel programming in which problems are solved by (recursively) splitting them into subtasks that are solved in parallel, waiting for them to complete, and then composing results. The general design is a variant of the work-stealing framework devised for Cilk. The main implementation techniques surround efficient construction and management of tasks queues and worker threads. The measured performance shows good parallel speedups for most programs, but also suggests possible improvements.

javac's -Xlint Options
The Java programming language compiler (javac) provided by Oracle (and formerly by Sun) has several non-standard options that are often useful. One of the most useful is the set of non-standard options that print out warnings encountered during compilation. That set of options is the subject of this post.
The javac page section on non-standard options lists and provides brief details on each of these options. The following is the relevant snippet from that page.

Aucun commentaire: