en to fr translation catalogue (238 entries)

note: type: Content of: <sect1><indexterm><primary>
en: Other Programming Tools
fr: Autres outils de programmation

note: type: Content of: <sect1><sect2><para>
en: This section is provided to show you some additional programming tools for which instructions have not yet been created in the book or for those that are not appropriate for the book. Note that these packages may not have been tested by the BLFS team, but their mention here is meant to be a convenient source of additional information.
fr: Cette section vise à vous montrer quelques outils de programmation supplémentaires pour lesquels aucune instruction n'a été créée dans le livre ou ceux non adéquats au livre. Remarquez qu'il se peut que ces paquets n'aient pas été testés par l'équipe BLFS, mais leur mention ici vise à former une source pratique d'informations supplémentaires.

note: type: Content of: <sect1><sect2><para>
en: User Notes: <ulink url="&blfs-wiki;/OtherProgrammingTools"/>
fr: Notes utilisateur&nbsp;: <ulink url="&blfs-wiki;/OtherProgrammingTools"/>

note: type: Content of: <sect1><sect2><title>
en: Programming Frameworks, Languages and Compilers
fr: Environnements, langages de programmation et compilateurs

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>A+</application> is a powerful and efficient programming language. It is freely available under the GNU General Public License. It embodies a rich set of functions and operators, a modern graphical user interface with many widgets and automatic synchronization of widgets and variables, asynchronous execution of functions associated with variables and events, dynamic loading of user compiled subroutines, and many other features. Execution is by a rather efficient interpreter. <application>A+</application> was created at Morgan Stanley. Primarily used in a computationally-intensive business environment, many critical applications written in <application>A+</application> have withstood the demands of real world developers over many years. Written in an interpreted language, <application>A+</application> applications tend to be portable.
fr: <application>A+</application> est un langage de programmation puissant et utile. Il est disponible librement sous la GNU General Public License. Il inclut un ensemble riche de fonctions et d'opérateurs, une interface graphique moderne avec la plupart des widgets et de la synchronisation automatique de widgets et des variables, l'exécution asynchrone de fonctions associées à des variables et des événements, le chargement dynamique des sous-routines compilées pour l'utilisateur, et bien d'autres fonctionnalités. L'exécution se fait par un interpréteur plutôt efficace. <application>A+</application> a été créé à Morgan Stanley. Utilisées d'abord dans un environnement d'entreprise spécialisée en informatique, beaucoup d'applications critiques écrites en <application>A+</application> ont résisté aux demandes des développeurs du monde réel pendant de nombreuses années. Écrites dans un langage interprété, les applications <application>A+</application> visent à être portables.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.aplusdev.org/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.aplusdev.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.aplusdev.org/Download/index.html"/>
fr: Emplacement de téléchargement&nbsp;: <ulink url="http://www.aplusdev.org/Download/index.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>ABC</application> is an interactive programming language and environment for personal computing, originally intended as a good replacement for BASIC. It was designed by first doing a task analysis of the programming task. <application>ABC</application> is easy to learn (an hour or so for someone who has already programmed), and yet easy to use. Originally intended as a language for beginners, it has evolved into a powerful tool for beginners and experts alike. Some features of the language include: a powerful collection of only five data types that easily combines strong typing, yet without declarations, no limitations (such as max int), apart from sheer exhaustion of memory refinements to support top-down programming, nesting by indentation and programs typically are one fourth or one fifth the size of the equivalent Pascal or C program.
fr: <application>ABC</application> est un langage de programmation et un environnement interactif pour l'informatique personnel, visant à l'origine à être un bon substitut à BASIC. Il était conçu au début pour effectuer une analyse de tâche de la tâche de programmation. <application>ABC</application> est facile à apprendre (une heure environ pour quelqu'un qui a déjà programmé), et encore plus facile à utiliser.  Conçu à l'origine comme un langage pour débutants, il a évolué vers un outil puissant pour débutants et aussi experts. Certaines fonctionnalités du langage comprennent&nbsp;: un ensemble puissant d'à peine cinq types de données qui combine facilement le typage fort, sans encore de déclarations, sans limites (telles que le max de int), sauf les raffinements du pur et simple épuisement de la mémoire pour supporter la programmation top-down, le nesting par indentation et les programmes pèsent en général le quart ou le cinquième d'un programme équivalent en Pascal ou en C.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://homepages.cwi.nl/~steven/abc/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://homepages.cwi.nl/~steven/abc/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://homepages.cwi.nl/~steven/abc/implementations.html"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://homepages.cwi.nl/~steven/abc/implementations.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>ALF</application> is a language which combines functional and logic programming techniques. The foundation of <application>ALF</application> is Horn clause logic with equality which consists of predicates and Horn clauses for logic programming, and functions and equations for functional programming. The <application>ALF</application> system is an efficient implementation of the combination of resolution, narrowing, rewriting and rejection.  Similarly to Prolog, <application>ALF</application> uses a backtracking strategy corresponding to a depth-first search in the derivation tree.
fr: <application>ALF</application> est un langage qui combine des techniques de programmation fonctionnelles et logiques. Le fondement de <application>ALF</application> est l'ensemble des clauses de Horn en logique avec égalité qui consiste en des prédicats et des propositions de Horn pour la programmation logique, et des fonctions et des équations pour la programmation fonctionnelle. Le système <application>ALF</application> est une implémentation efficace de la combinaison de la résolution, de la réduction, de la réécriture et du rejet. Comme Prolog, <application>ALF</application> utilise une stratégie de backtracking correspondant à une recherche immédiatement approfondie dans l'arborescence des dérivés.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.informatik.uni-kiel.de/~mh/systems/ALF.html"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.informatik.uni-kiel.de/~mh/systems/ALF.html"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.informatik.uni-kiel.de/~mh/systems/ALF/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.informatik.uni-kiel.de/~mh/systems/ALF/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>ASM</application> is a Java bytecode manipulation framework. It can be used to dynamically generate stub classes or other proxy classes, directly in binary form, or to dynamically modify classes at load time, i.e., just before they are loaded into the Java Virtual Machine. <application>ASM</application> offers similar functionalities as BCEL or SERP, but is much smaller (33KB instead of 350KB for BCEL and 150KB for SERP) and faster than these tools (the overhead of a load time class transformation is of the order of 60% with <application>ASM</application>, 700% or more with BCEL, and 1100% or more with SERP). Indeed <application>ASM</application> was designed to be used in a dynamic way (though it works statically as well) and was therefore designed and implemented to be as small and as fast as possible.
fr: <application>ASM</application> est un environnement de manipulation de bytecode Java. Il peut être utilisé pour générer de façon dynamique des morceaux de classe ou d'autres classes de proxy directement sous forme binaire, ou pour modifier de façon dynamique des classes au moment de leur chargement, à savoir juste avant qu'ils ne soient chargés dans une machine virtuelle Java. <application>ASM</application> offre des fonctionnalités semblables à BCEL ou à SERP, mais il est beaucoup plus petit (33Ko au lieu de 350Ko pour BCEL et 150Ko pour SERP) et rapide que ces outils (le décalage de la transformation de classe en temps de charge est de l'ordre de 60&nbsp;% par rapport à <application>ASM</application>, 700&nbsp;% ou plus par rapport à BCEL, et 1100&nbsp;% ou plus par rapport à SERP). En effet, <application>ASM</application> a été conçu pour être utilisé de façon dynamique (bien qu'il fonctionne de manière statique) et a donc été conçu et implémenté pour être aussi petit et rapide que possible.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://asm.objectweb.org/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://asm.objectweb.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://forge.objectweb.org/projects/asm/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://forge.objectweb.org/projects/asm/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>BCPL</application> is a simple typeless language that was designed in 1966 by Martin Richards and implemented for the first time at MIT in the Spring of 1967.
fr: <application>BCPL</application> est un langage simple non typé qui a été conçu en 1966 par Martin Richards et implémenté pour la première fois au MIT au printemps 1967.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.cl.cam.ac.uk/users/mr/BCPL.html"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.cl.cam.ac.uk/users/mr/BCPL.html"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.cl.cam.ac.uk/users/mr/BCPL/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.cl.cam.ac.uk/users/mr/BCPL/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>BETA</application> is developed within the Scandinavian School of object-orientation, where the first object-oriented language, Simula, was developed.  <application>BETA</application> is a modern language in the Simula tradition. The resulting language is smaller than Simula in spite of being considerably more expressive. <application>BETA</application> is a strongly typed language like Simula, Eiffel and C++, with most type checking being carried out at compile-time. It is well known that it is not possible to obtain all type checking at compile time without sacrificing the expressiveness of the language.  <application>BETA</application> has optimum balance between compile-time type checking and run-time type checking.
fr: <application>BETA</application> est développé dans l'École Scandinave d'orientation objet, où a été développé le premier langage orienté objet.  <application>BETA</application> est un langage moderne dans la tradition de Simula. Le langage qui en résulte est plus petit que Simula bien qu'il coûte beaucoup plus cher. <application>BETA</application> est un langage fortement typé, comme Simula Eiffel et C++, avec la plupart des contrôles de types pris en charge au moment de la compilation. Il est bien connu qu'il n'est pas possible d'obtenir la vérification de tous les types au moment de la compilation sans sacrifier le coût du langage. <application>BETA</application> a un bilan optimal entre le contrôle des types au moment de la compilation et au moment de l'exécution.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.daimi.au.dk/~beta/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.daimi.au.dk/~beta/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="ftp://ftp.daimi.au.dk/pub/beta/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="ftp://ftp.daimi.au.dk/pub/beta/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>&lt;bigwig&gt;</application> is a high-level programming language for developing interactive Web services. Programs are compiled into a conglomerate of lower-level technologies such as C code, HTTP, HTML, JavaScript, and SSL, all running on top of a runtime system based on an Apache Web server module. It is a descendant of the Mawl project but is a completely new design and implementation with vastly expanded ambitions. The <application>&lt;bigwig&gt;</application> language is really a collection of tiny domain-specific languages focusing on different aspects of interactive Web services. These contributing languages are held together by a C-like skeleton language.  Thus, <application>&lt;bigwig&gt;</application> has the look and feel of C-programs but with special data and control structures.
fr: <application>&lt;bigwig&gt;</application> est un langage de programmation de haut niveau pour développer des services Web interactifs. Les programmes sont compilés dans un conglomérat de technologies de bas niveau telles que le code C, HTTP, HTML, JavaScript, et SSL, tous s'exécutant en haut d'un système en cours d'exécution basé sur un module serveur Web Apache. C'est un descendant du projet Mawl mais le concept est entièrement nouveau et l'implémentation a développé de vastes ambitions. Le langage <application>&lt;bigwig&gt;</application> est véritablement un ensemble de petits langages ayant un domaine spécifique et se focalisant sur différents aspects des services Web interactifs. Ces langages de contribution sont maintenus ensemble par un langage squelettique de type C.  <application>&lt;bigwig&gt;</application> se présente comme un programme C, mais avec des données et des structures de contrôle spéciales.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.brics.dk/bigwig/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.brics.dk/bigwig/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.brics.dk/bigwig/download/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.brics.dk/bigwig/download/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Bigloo</application> is a Scheme implementation devoted to one goal: enabling Scheme based programming style where C(++) is usually required. <application>Bigloo</application> attempts to make Scheme practical by offering features usually presented by traditional programming languages but not offered by Scheme and functional programming. Bigloo compiles Scheme modules and delivers small and fast stand-alone binary executables. It enables full connections between Scheme and C programs, between Scheme and Java programs, and between Scheme and C# programs.
fr: <application>Bigloo</application> est une implémentation de Scheme vouée à un objectif&nbsp;: activer le style de programmation basé sur Scheme là où C(++) est en général requis. <application>Bigloo</application> s'efforce de rendre Scheme pratique en offrant des fonctionnalités habituellement présentées par les langages de programmation traditionnels mais non offertes par Scheme et la programmation fonctionnelle. Bigloo compile des modules Scheme et délivre des exécutables binaires autonomes petits et rapides. Cela donne une connexion complète entre Scheme et les programmes C, entre Scheme et les programmes Java et entre Scheme et les programmes C#.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www-sop.inria.fr/mimosa/fp/Bigloo/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www-sop.inria.fr/mimosa/fp/Bigloo/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="ftp://ftp-sop.inria.fr/mimosa/fp/Bigloo/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="ftp://ftp-sop.inria.fr/mimosa/fp/Bigloo/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>C--</application> is a portable assembly language that can be generated by a front end and implemented by any of several code generators. It serves as an interface between high-level compilers and retargetable, optimizing code generators. Authors of front ends and code generators can cooperate easily.
fr: <application>C--</application> est un langage assembleur portable qui peut être généré par une interface et implémenté par n'importe quel générateur de code. Il sert d'interface entre les compilateurs de haut niveau et les générateurs de code optimisant qu'on peut recibler. Les auteurs des interfaces et des générateurs de code peuvent facilement coopérer.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.cminusminus.org/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.cminusminus.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.cminusminus.org/code.html"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.cminusminus.org/code.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Caml</application> is a general-purpose programming language, designed with program safety and reliability in mind. It is very expressive, yet easy to learn and use.  <application>Caml</application> supports functional, imperative, and object-oriented programming styles. It has been developed and distributed by INRIA, France's national research institute for computer science, since 1985. The Objective Caml system is the main implementation of the <application>Caml</application> language. It features a powerful module system and a full-fledged object-oriented layer. It comes with a native-code compiler that supports numerous architectures, for high performance; a bytecode compiler, for increased portability; and an interactive loop, for experimentation and rapid development.
fr: <application>Caml</application> est un langage de programmation généraliste, conçu dans l'esprit de la sûreté du programme et de sa fiabilité. Il est très intuitif, facile à apprendre et à utiliser. <application>Caml</application> supporte les styles de programmation fonctionnelle, impérative et orientée objet. Il est développé et distribué par l'INRIA, l'Institut National de Recherche en Informatique français, depuis 1985. Le système Objective Caml est l'implémentation principale du langage <application>Caml</application>. Il offre un système de modules puissant et une couche à part entière orientée objet. Il est fourni avec un compilateur de code natif qui supporte de nombreuses architectures, pour de hautes performances&nbsp;; un compilateur bytecode, pour une portabilité accrue&nbsp;; et une boucle interactive, pour l'expérimentation et le développement rapide.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://caml.inria.fr/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://caml.inria.fr/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://caml.inria.fr/pub/distrib/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://caml.inria.fr/pub/distrib/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Ch</application> is an embeddable C/C++ interpreter for cross-platform scripting, shell programming, 2D/3D plotting, numerical computing, and embedded scripting.
fr: <application>Ch</application> est un interpréteur C/C++ embarquable pour scripter sur des plate-formes croisées&nbsp;: programmation shell, restitution 2D/3D, calcul numérique, faire du script embarqué.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.softintegration.com/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.softintegration.com/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.softintegration.com/products/chstandard/download/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.softintegration.com/products/chstandard/download/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Clean</application> is a general purpose, state-of-the-art, pure and lazy functional programming language designed for making real-world applications.  <application>Clean</application> is the only functional language in the world which offers uniqueness typing.  This type system makes it possible in a pure functional language to incorporate destructive updates of arbitrary data structures (including arrays) and to make direct interfaces to the outside imperative world.  The type system makes it possible to develop efficient applications.
fr: <application>Clean</application> est un langage généraliste de pointe, fonctionnel pur et fainéant afin de faire des applications pour le monde réel. <application>Clean</application> est le seul langage fonctionnel du monde qui offre du typage singularisé. Ce système de typage rend possible dans un langage purement fonctionnel d'incorporer des mises à jour destructrices de structures de données de votre choix (y compris les tableaux) et de mettre à disposition directe des interfaces avec le monde impératif extérieur. Le système de typage rend possible le développement d'applications efficaces.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://wiki.clean.cs.ru.nl/Clean"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://wiki.clean.cs.ru.nl/Clean"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://wiki.clean.cs.ru.nl/Download_Clean"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://wiki.clean.cs.ru.nl/Download_Clean"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Cyclone</application> is a programming language based on C that is safe, meaning that it rules out programs that have buffer overflows, dangling pointers, format string attacks, and so on.  High-level, type-safe languages, such as Java, Scheme, or ML also provide safety, but they don't give the same control over data representations and memory management that C does (witness the fact that the run-time systems for these languages are usually written in C.) Furthermore, porting legacy C code to these languages or interfacing with legacy C libraries is a difficult and error-prone process. The goal of <application>Cyclone</application> is to give programmers the same low-level control and performance of C without sacrificing safety, and to make it easy to port or interface with legacy C code.
fr: <application>Cyclone</application> est un langage de programmation basé sur le C qui est sécurisé, c'est-à-dire qu'il exclut les programmes ayant des débordements de mémoire, des pointeurs en suspens, des attaques de chaîne de format, et ainsi de suite. De haut niveau, les langages aux types sécurisés tels que Java, Scheme, ou ML offrent aussi cette sécurité, mais ils ne donnent pas le même contrôle des représentations des données et de la gestion de mémoire que le C (sans compter le fait que les systèmes d'exécution de ces langages sont en général écrits en C.)  Au surplus, le portage du code C de base vers ces langages ou l'interfaçage avec les bibliothèques C est un processus difficile et source d'erreurs.  Le but de <application>Cyclone</application> est de donner aux programmeurs le même contrôle de bas niveau et la performance du C sans y sacrifier la sécurité, et d'en faciliter le portage ou l'interfaçage avec le code C de base.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://cyclone.thelanguage.org/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://cyclone.thelanguage.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://cyclone.thelanguage.org/wiki/Download/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://cyclone.thelanguage.org/wiki/Download/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>DMDScript</application> is Digital Mars' implementation of the ECMA 262 scripting language. Netscape's implementation is called JavaScript, Microsoft's implementation is called JScript. <application>DMDScript</application> is much faster than other implementations, which you can verify with the included benchmark.
fr: <application>DMDScript</application> signifie implémentation de Digital Mars du langage de script ECMA 262. Sur l'implémentation de Netscape appelée JavaScript, l'implémentation de Microsoft est appelée JScript. <application>DMDScript</application> est beaucoup plus rapide que les autres implémentations, ce que vous pouvez vérifier avec les tests de performance inclus.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.digitalmars.com/dscript/index.html"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.digitalmars.com/dscript/index.html"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="ftp://ftp.digitalmars.com/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="ftp://ftp.digitalmars.com/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>DotGNU Portable.NET</application> goal is to build a suite of free software tools to build and execute .NET applications, including a C# compiler, assembler, disassembler, and runtime engine.  While the initial target platform was GNU/Linux, it is also known to run under Windows, Solaris, NetBSD, FreeBSD, and MacOS X. The runtime engine has been tested on the x86, PowerPC, ARM, Sparc, PARISC, s390, Alpha, and IA-64 processors.  <application>DotGNU Portable.NET</application> is part of the DotGNU project, built in accordance with the requirements of the GNU Project.  DotGNU Portable.NET is focused on compatibility with the ECMA specifications for CLI. There are other projects under the DotGNU meta-project to build other necessary pieces of infrastructure, and to explore non-CLI approaches to virtual machine implementation.
fr: Le but de <application>DotGNU Portable.NET</application> est de construire une suite de logiciels libres pour construire et exécuter des applications .NET, y compris un compilateur, un assembleur, un désassembleur et un moteur d'exécution C#. Si la plate-forme cible était au début GNU/Linux, il est aussi connu pour fonctionner sous Windows, Solaris, NetBSD, FreeBSD et MacOS X. Le moteur d'exécution a été testé sur les processeurs x86, PowerPC, ARM, Sparc, PARISC, s390, Alpha, et IA-64. <application>DotGNU Portable.NET</application> fait partie du projet DotGNU, construit selon les exigences du projet GNU. DotGNU Portable.NET se concentre sur la compatibilité avec les spécifications ECMA pour CLI.  Il y a d'autres projets sous le méta-projet DotGNU pour construire d'autres parties nécessaires de l'infrastructure et pour explorer des approches non CLI pour une implémentation sur machine virtuelle.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.gnu.org/software/dotgnu/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.gnu.org/software/dotgnu/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.gnu.org/software/dotgnu/pnet-packages.html"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.gnu.org/software/dotgnu/pnet-packages.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Dylan</application> is an advanced, object-oriented, dynamic language which supports rapid program development. When needed, programs can be optimized for more efficient execution by supplying more type information to the compiler. Nearly all entities in <application>Dylan</application> (including functions, classes, and basic data types such as integers) are first class objects.  Additionally, <application>Dylan</application> supports multiple inheritance, polymorphism, multiple dispatch, keyword arguments, object introspection, macros, and many other advanced features...  --Peter Hinely.
fr: <application>Dylan</application> est un langage avancé, orienté objet et dynamique qui supporte le développement de programmes rapides.  Lorsque cela est nécessaire, les programmes peuvent être optimisés pour une exécution plus efficace en offrant davantage d'informations de type au compilateur. Presque toutes les entités dans <application>Dylan</application> (y compris les fonctions, les classes et les types de données de base tels que les entiers) sont d'abord des classes objet.  En outre, <application>Dylan</application> supporte plusieurs héritages, le polymorphisme, le dispatch multiple, les arguments mots-clés, l'introspection objet, les macros et beaucoup d'autres fonctionnalités avancées... --Peter Hinely.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.opendylan.org/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.opendylan.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://opendylan.org/download/index.html"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://opendylan.org/download/index.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>E</application> is a secure distributed Java-based pure-object platform and p2p scripting language. It has two parts: ELib and the <application>E</application> Language. Elib provides the stuff that goes on between objects. As a pure-Java library, ELib provides for inter-process capability-secure distributed programming. Its cryptographic capability protocol enables mutually suspicious Java processes to cooperate safely, and its event-loop concurrency and promise pipelining enable high performance deadlock free distributed pure-object computing. The <application>E</application> Language can be used to express what happens within an object. It provides a convenient and familiar notation for the ELib computational model, so you can program in one model rather than two. Under the covers, this notation expands into Kernel-E, a minimalist lambda-language much like Scheme or Smalltalk. Objects written in the <application>E</application> language are only able to interact with other objects according to ELib's semantics, enabling object granularity intra-process security, including the ability to safely run untrusted mobile code (such as caplets).
fr: <application>E</application> est une plateforme sécurisée, distribuée, basée sur Java et en pur objet, et un langage de script pair à pair. Il est composé de deux parties&nbsp;: ELib et le langage <application>E</application>. Elib fournit ce qui se trouve entre les objets. En tant que bibliothèque Java pure, ELib permet la programmation inter-processus sécurisée et distribuée. Son protocole cryptographique de capacité permet à des processus Java qui ne se font pas confiance de coopérer en toute sécurité, et sa boucle d'événements concurrente ainsi que son pipelining de promesses permettent un calcul en pur-objet distribué et sans interblocage. Le langage <application>E</application> peut être utilisé pour exprimer ce qui arrive à l'intérieur d'un objet. Il fournit une notation pratique et familière pour le modèle de calcul de ELib, pour que vous puissiez programmer en un modèle plutôt que deux. Sous le capot, cette notation s'étend en Kernel-E, un lambda calcul minimaliste proche de Scheme ou Smalltalk. Les objets écrits en <application>E</application> ne sont capables d'interagir avec d'autres objets que suivant la sémantique d'ELib, ce qui permet d'avoir à l'intérieur du processus une sécurité à la granularité de l'objet, qui comprend la capacité à lancer de manière sécurisée du code mobile qui n'est pas de confiance (comme des caplets).

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.erights.org/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.erights.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.erights.org/download/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.erights.org/download/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>elastiC</application> is a portable high-level object-oriented interpreted language with a C like syntax. Its main characteristics are: open source, interpreted, has portable bytecode compilation, dynamic typing, automatic real very fast garbage collection, object oriented with meta-programming support (a la Smalltalk), functional programming support (Scheme-like closures with lexical scoping, and eval-like functionality), hierarchical namespaces, a rich set of useful built-in types (dynamic arrays, dictionaries, symbols, ...), extensible with C (you can add functions, types, classes, methods, packages, ...), embeddable in C.  <application>elastiC</application> has been strongly influenced by C, Smalltalk, Scheme and Python and tries to merge the best characteristics of all these languages, while still coherently maintaining its unique personality.
fr: <application>elastiC</application> est un langage interprété portable orienté objet de haut niveau ayant une syntaxe similaire au C. Ses caractéristiques principales sont&nbsp;: open source, interprété, peut être compilé vers du bytecode portable, un typage dynamique, un ramasse-miettes très rapide et vraiment automatique, une orientation objet avec un support pour la méta-programmation (à la Smalltalk), un support pour la programmation fonctionnelle, (closures à la Scheme avec une portée lexicale, et des fonctionnalités du type d'eval), des espaces de noms hiérarchisés, un ensemble riche de types intégrés utiles (tableaux dynamique, dictionnaires, symboles, ...), extensible avec du C (vous pouvez ajouter des fonctions, des types, des classes, des méthodes, des paquets, ...), il peut être embarqué dans du C.  <application>elastiC</application> a beaucoup été influencé par le C, Smalltalk, Scheme et Python et il essaie de rassembler les meilleures caractéristiques de tous ces langages tout en maintenant toujours sa personnalité unique de façon cohérente.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.elasticworld.org/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.elasticworld.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.elasticworld.org/download.html"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.elasticworld.org/download.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Erlang/OTP</application> is a development environment based on Erlang. Erlang is a programming language which has many features more commonly associated with an operating system than with a programming language: concurrent processes, scheduling, memory management, distribution, networking, etc. The initial open-source Erlang release contains the implementation of Erlang, as well as a large part of Ericsson's middleware for building distributed high-availability systems.  Erlang is characterized by the following features: robustness, soft real-time, hot code upgrades and incremental code loading.
fr: <application>Erlang/OTP</application> est un environnement de développement basé sur Erlang. Erlang est un langage de programmation ayant beaucoup de fonctionnalités associées plus souvent à un système d'exploitation qu'à un langage de programmation&nbsp;: processus en même simultanés, horodatage, gestion de mémoire, distribution, réseau, etc. La version open-source initiale d'Erlang contient l'implémentation d'Erlang ainsi qu'une grande partie du middleware d'Ericsson pour construire des systèmes distribués très disponibles. Erlang se caractérise par les fonctionnalités suivantes&nbsp;: robuste, temps réel logiciel, mises à jour à chaud du code et chargement incrémental du code.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.erlang.org/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.erlang.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.erlang.org/download.html"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.erlang.org/download.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Euphoria</application> is a simple, flexible, and easy-to-learn programming language. It lets you quickly and easily develop programs for Windows, DOS, Linux and FreeBSD. Euphoria was first released in 1993. Since then Rapid Deployment Software has been steadily improving it with the help of a growing number of enthusiastic users.  Although <application>Euphoria</application> provides subscript checking, uninitialized variable checking and numerous other run-time checks, it is extremely fast. People have used it to develop high-speed DOS games, Windows GUI programs, and X Window System programs. It is also very useful for CGI (Web-based)  programming.
fr: <application>Euphoria</application> est un langage de programmation simple, flexible et facile à apprendre. Il vous permet de développer facilement et rapidement des programmes pour Windows, DOS, Linux et FreeBSD. Euphoria a été publié pour la première fois en 1993. Depuis, Rapid Deployment Software l'améliore progressivement à l'aide d'un nombre croissant d'utilisateurs motivés. Bien que <application>Euphoria</application> fournisse le contrôle des sous-scripts, des variables non initialisées et de nombreux autres tests à l'exécution, il est extrêmement rapide. Les gens l'utilisent pour développer des jeux DOS très rapides, des programmes graphiques pour Windows et des programmes pour X Window. Il est aussi très utile pour la programmation CGI (basé sur le Web).

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.rapideuphoria.com/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.rapideuphoria.com/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.rapideuphoria.com/v20.htm"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.rapideuphoria.com/v20.htm"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Felix</application> is an advanced Algol like procedural programming language with a strong functional subsystem. It features ML style static typing, first class functions, pattern matching, garbage collection, polymorphism, and has built in support for high performance microthreading, regular expressions and context free parsing.  The system provides a scripting harness so the language can be used like other scripting languages such as Python and Perl, but underneath it generates native code to obtain high performance. A key feature of the system is that it uses the C/C++ object model, and provides an advanced binding sublanguage to support integration with C/C++ at both the source and object levels, both for embedding C/C++ data types and functions into <application>Felix</application>, and for embedding <application>Felix</application> into existing C++ architectures. The <application>Felix</application> compiler is written in Objective Caml, and generates ISO C++ which should compile on any platform.
fr: <application>Felix</application> est un langage de programmation procédural de type Algol avec un sous-système fonctionnel fort. Il a pour caractéristique le typage statique du style ML, les fonctions de première classe, la recherche de motif, un ramasse-miettes, le polymorphisme et il a un support intégré de microthreading haute performance, de l'analyse d'expressions régulières et de l'analyse sans contexte. Le système offre un ensemble de scripts pour pouvoir utiliser le langage comme d'autres langages de scripts tels que Python et Perl, mais sous le capot il génère du code natif pour obtenir une haute performance. Une fonctionnalité clé du système tient à ce qu'il utilise le modèle objet de C/C++ et qu'il offre un sous-langage de binding avancé pour supporter l'intégration avec C/C++, tant au niveau du source que de l'objet, aussi bien pour les types de données C/C++ embarquées que les fonctions de <application>Felix</application> et pour les <application>Felix</application> emballés dans les architectures C++ existantes. Le compilateur <application>Felix</application> est écrit en Objective Caml et il génère du C++ ISO qui devrait se compiler sur n'importe quelle plate-forme.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://felix.sourceforge.net/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://felix.sourceforge.net/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://felix-lang.org/$/usr/local/lib/felix/tarballs"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://felix-lang.org/$/usr/local/lib/felix/tarballs"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>ferite</application> is a scripting language and engine all in one manageable chunk. It is designed to be easily extended in terms of API, and to be used within other applications making them more configurable and useful to the end user. It has a syntax similar to a number of other languages but remains clean and its own language.
fr: <application>ferite</application> est un langage et un moteur de scripts compris dans un ensemble gérable. Il est conçu pour être facilement étendu en termes d'API et pour être utilisé dans d'autres applications qui les rendent plus configurables et utiles pour l'utilisateur final. Il a une syntaxe identique à un certain nombre d'autres langages mais il demeure propre et garde son propre langage.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.ferite.org/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.ferite.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.ferite.org/download.html"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.ferite.org/download.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Forth</application> is a stack-based, extensible language without type-checking. It is probably best known for its "reverse Polish" (postfix) arithmetic notation, familiar to users of Hewlett-Packard calculators. <application>Forth</application> is a real-time programming language originally developed to control telescopes. <application>Forth</application> has many unique features and applications: it can compile itself into a new compiler, reverse-polish coding, edit time error checking and compiling (similar to BASIC), extremely efficient thread based language, can be used to debug itself, extensible; thus can become what ever you need it to be.  The links below lead to the website of the Forth Interest Group (FIG), a world-wide, non-profit organization for education in and the promotion of the <application>Forth</application> computer language.  Another worthwhile website dedicated to the <application>Forth</application> community is <ulink url="http://wiki.forthfreak.net/"/>.
fr: <application>Forth</application> est un langage basé sur des piles et extensible sans vérification des types. Il est probablement plus connu pour sa notation mathématique en "polonais inversé (postfix), familier pour les utilisateurs des calculatrices Hewlett-Packard. <application>Forth</application> est un langage de programmation en temps réel développé à l'origine pour contrôler les télescopes. <application>Forth</application> a de nombreuses fonctionnalités et de nombreuses applications uniques&nbsp;: il peut se compiler dans un nouveau compilateur, coder en polonais inversé, éditer la vérification d'erreurs de temps et la compilation (comme BASIC), langage basé sur un thread extrêmement efficace, il peut être utilisé pour s'auto déboguer, extensible&nbsp;; il peut ainsi devenir ce dont vous aviez toujours besoin qu'il soit. Les liens ci-dessous mènent au site Internet du Forth Interest Group (FIG), une association mondiale à but non lucratif visant l'enseignement et la promotion du langage informatique <application>Forth</application>. Un autre site Internet mondial consacré Ã  la commaunauté <application>Forth</application> est <ulink url="http://wiki.forthfreak.net/"/>.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.forth.org/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.forth.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.forth.org/compilers.html"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.forth.org/compilers.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>GNU Smalltalk</application> is a free implementation of the Smalltalk-80 language which runs on most versions on Unix and, in general, everywhere you can find a POSIX-compliance library. An uncommon feature of it is that it is well-versed to scripting tasks and headless processing. See <ulink url=" http://www.gnu.org/software/smalltalk/manual/html_node/Overview.html "/> for a more detailed explanation of <application>GNU Smalltalk</application>.
fr: <application>GNU Smalltalk</application> est une implémentation libre du langage Smalltalk-80 qui fonctionnent sur la plupart des versions d'Unix et, en général, partout où vous pouvez trouver une bibliothèque conforme à  POSIX. Une fonctionnalité originale est qu'il est orienté vers des tâches de scripting des actes de headless. Voir <ulink url=" http://www.gnu.org/software/smalltalk/manual/html_node/Overview.html "/> pour une explication plus détaillée de <application>GNU Smalltalk</application>.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://smalltalk.gnu.org/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://smalltalk.gnu.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="&gnu-http;/smalltalk/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="&gnu-http;/smalltalk/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: Haskell is a computer programming language. In particular, it is a polymorphicly typed, lazy, purely functional language, quite different from most other programming languages. The language is named for Haskell Brooks Curry, whose work in mathematical logic serves as a foundation for functional languages. Haskell is based on lambda calculus. There are many implementations of Haskell, among them:
fr: Haskell est un langage de programmation informatique. En particulier, c'est un langage au typage polymorphique, fainéant, purement fonctionnel, très différent de la plupart des autres langages de programmation. Le langage a été nommé d'après Haskell Brooks Curry, dont le travail en logique mathématiques sert de fondement aux langages fonctionnels. Haskell se base sur le lambda calcul. Il y a de nombreuses implémentations de Haskell, parmi lesquelles&nbsp;:

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: GHC: <ulink url="http://www.haskell.org/ghc/"/>
fr: GHC&nbsp;: <ulink url="http://www.haskell.org/ghc/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Helium: <ulink url="http://www.cs.uu.nl/wiki/bin/view/Helium/WebHome"/>
fr: Helium&nbsp;: <ulink url="http://www.cs.uu.nl/wiki/bin/view/Helium/WebHome"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Hugs: <ulink url="http://www.haskell.org/hugs/"/>
fr: Hugs&nbsp;: <ulink url="http://www.haskell.org/hugs/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: nhc98: <ulink url="http://www.haskell.org/nhc98/"/>
fr: nhc98&nbsp;: <ulink url="http://www.haskell.org/nhc98/"/>

note: type: Content of: <sect1><sect2><sect3><title>
en: HLA (High Level Assembly)
fr: HLA (High Level Assembly, assemblage de haut niveau)

note: type: Content of: <sect1><sect2><sect3><para>
en: The <application>HLA</application> language was developed as a tool to help teach assembly language programming and machine organization to University students at the University of California, Riverside. The basic idea was to teach students assembly language programming by leveraging their knowledge of high level languages like C/C++ and Pascal/Delphi. At the same time, <application>HLA</application> was designed to allow advanced assembly language programmers write more readable and more powerful assembly language code.
fr: Le langage <application>HLA</application> a été développé en tant qu'outil pour aider à enseigner la programmation en langage d'assembleur et l'organisation machine aux étudiants de l'Université de Californie, Riverside. L'idée de base était d'enseigner aux étudiants la programmation en langage d'assembleur en s'appuyant sur leurs connaissances en langages de haut niveau comme le C/C++ et le Pascal/Delphi. En même temps, <application>HLA</application> a été conçu pour permettre aux programmeurs en assembleur avancés d'écrire un code en langage assembleur plus lisible et plus puissant.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.plantation-productions.com/Webster/HighLevelAsm/index.html"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.plantation-productions.com/Webster/HighLevelAsm/index.html"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.plantation-productions.com/Webster/HighLevelAsm/dnld.html"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.plantation-productions.com/Webster/HighLevelAsm/dnld.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Icon</application> is a high-level, general-purpose programming language with a large repertoire of features for processing data structures and character strings. It is an imperative, procedural language with a syntax reminiscent of C and Pascal, but with semantics at a much higher level.
fr: <application>Icon</application> est un langage de programmation de haut niveau généraliste ayant un large éventail de fonctionnalités pour traiter des structures de données et des chaînes de caractères. C'est un langage impératif, procédural avec une syntaxe rappelant le C et le Pascal mais avec des sémantiques à niveau beaucoup plus élevé.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.cs.arizona.edu/icon/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.cs.arizona.edu/icon/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="ftp://ftp.cs.arizona.edu/icon/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="ftp://ftp.cs.arizona.edu/icon/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Io</application> is a small, prototype-based programming language. The ideas in <application>Io</application> are mostly inspired by <application>Smalltalk</application> (all values are objects), <application>Self</application> (prototype-based), <application>NewtonScript</application> (differential inheritance), <application>Act1</application> (actors and futures for concurrency), <application>LISP</application> (code is a runtime inspectable/modifiable tree) and <application>Lua</application> (small, embeddable).
fr: <application>Io</application> est un petit langage de programmation basé sur un prototype. La plupart des idées de <application>Io</application> s'inspirent de <application>Smalltalk</application> (toutes les valeurs sont des objets), de <application>Self</application> (basée sur le prototype), <application>NewtonScript</application> (héritage différentiel), <application>Act1</application> (les acteurs et les prémices pour l'aspect simultané), <application>LISP</application> (on peut observer/modifier l'arborescence du code en cours d'exécution), et <application>Lua</application> (petit, embarquable).

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://iolanguage.org"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://iolanguage.org"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://iobin.suspended-chord.info/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://iobin.suspended-chord.info/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>J</application> is a modern, high-level, general-purpose, high-performance programming language. It is portable and runs on Windows, Unix, Mac, and PocketPC handhelds, both as a GUI and in a console. True 64-bit <application>J</application> systems are available for XP64 or Linux64, on AMD64 or Intel EM64T platforms.  <application>J</application> systems can be installed and distributed for free.
fr: <application>J</application> est un langage de programmation moderne, de haut niveau, généraliste, à haute performance. Il est portable et fonctionne sur des portables Windows, Unix, Mac, et PocketPC, autant en graphique qu'en console. De vrais systèmes <application>J</application> 64 bits sont disponibles sur XP64 ou Linux64, sur AMD64 ou des plate-formes Intel EM64T. Les systèmes <application>J</application> peuvent être installés et distribués librement.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.jsoftware.com/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.jsoftware.com/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.jsoftware.com/stable.htm"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.jsoftware.com/stable.htm"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Jamaica</application>, the JVM Macro Assembler, is an easy-to-learn and easy-to-use assembly language for JVM bytecode programming. It uses Java syntax to define a JVM class except for the method body that takes bytecode instructions, including <application>Jamaica</application>'s built-in macros. In <application>Jamaica</application>, bytecode instructions use mnemonics and symbolic names for all variables, parameters, data fields, constants, and labels.
fr: <application>Jamaica</application>, l'assembleur macro JVM, est un langage d'assembleur facile à utiliser et à apprendre pour la programmation en bytecodes JVM. Il utilise la syntaxe Java pour définir une classe JVM, sauf pour le corps de la méthode qui prend des instructions en bytecode, y compris des macros intégrées de <application>Jamaica</application>. Dans <application>Jamaica</application>, les instructions en bytecode utilisent des noms mnémotechniques et symboliques pour toutes les variables, les paramètres, les champs de données, les constantes et les étiquettes.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://judoscript.org/jamaica.html"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://judoscript.org/jamaica.html"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://judoscript.org/download.html"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://judoscript.org/download.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Joy</application> is a purely functional programming language. Whereas all other functional programming languages are based on the application of functions to arguments, <application>Joy</application> is based on the composition of functions. All such functions take a stack as an argument and produce a stack as a value. Consequently much of <application>Joy</application> looks like ordinary postfix notation.  However, in <application>Joy</application> a function can consume any number of parameters from the stack and leave any number of results on the stack.  The concatenation of appropriate programs denotes the composition of the functions which the programs denote.
fr: <application>Joy</application> est un langage de programmation purement fonctionnel. Alors que les autres langages fonctionnels se basent sur l'application de fonctions à des arguments, <application>Joy</application> se base sur la création de fonctions. De telles fonctions ainsi créées prennent en argument une pile et elles produisent comme valeur une pile. Par conséquent, une grande part du langage <application>Joy</application> ressemble à de la notation postfixe ordinaire.  Cependant, dans <application>Joy</application>, une fonction peut consommer n'importe quel nombre de paramètres à partir de la pile et laisser n'importe quel nombre de résultats sur la pile. La concaténation des programmes appropriés révèle la composition des fonctions que révèlent les programmes.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.latrobe.edu.au/humanities/research/research-projects/past-projects/joy-programming-language"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.latrobe.edu.au/humanities/research/research-projects/past-projects/joy-programming-language"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Judo</application> is a practical, functional scripting language. It is designed to cover the use cases of not only algorithmic/object-oriented/multi-threaded programming and Java scripting but also a number of major application domain tasks, such as scripting for JDBC, WSDL, ActiveX, OS, multiple file/data formats, etc. Despite its rich functionality, the base language is extremely simple, and domain support syntax is totally intuitive to domain experts, so that even though you have never programmed in <application>Judo</application>, you would have little trouble figuring out what the code does.
fr: <application>Judo</application> est un langage de scripts pratique et fonctionnel. Il est conçu pour traiter des cas d'utilisation d'une programmation non uniquement basée sur l'algorithme/orientée objet/multithreadée et le scripting Java, mais aussi pour de nombreuses tâches de domaine d'application majeures telles que le scripting pour JDBC, WSDL, ActiveX, OS, plusieurs formats de fichier/données, etc. Malgré ses possibilités riches, le langage de base est extrêmement simple et sa syntaxe de support de domaine est complètement intuitive pour les experts en domaine, si bien que même si vous n'avez jamais programmé en <application>Judo</application>, vous auriez peu de difficultés à comprendre ce que fait le code.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://judoscript.org/judo.html"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://judoscript.org/judo.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>JWIG</application> is a Java-based high-level programming language for development of interactive Web services. It contains an advanced session model, a flexible mechanism for dynamic construction of XML documents, in particular XHTML, and a powerful API for simplifying use of the HTTP protocol and many other aspects of Web service programming. To support program development, <application>JWIG</application> provides a unique suite of highly specialized program analysers that at compile time verify for a given program that no runtime errors can occur while building documents or receiving form input, and that all documents being shown are valid according to the document type definition for XHTML 1.0. The main goal of the <application>JWIG</application> project is to simplify development of complex Web services, compared to alternatives, such as, Servlets, JSP, ASP, and PHP. <application>JWIG</application> is a descendant of the <application>&lt;bigwig&gt;</application> research language.
fr: <application>JWIG</application> est un langage de programmation de haut niveau basé sur Java pour le développement de services Web interactifs.  Il contient un modèle avancé de session, un mécanisme flexible pour la construction dynamique de documents XML, en particulier XHTML, et une API puissante pour simplifier l'utilisation du protocole HTTP, et bien d'autres aspects de la programmation de services Web.  Pour supporter le développement d'un programme, <application>JWIG</application> offre une suite unique d'analyseurs de programmes hautement spécialisés qui vérifie au moment de la compilation que, dans un programme donné, aucune erreur ne se produira au moment de son exécution lors de la construction de documents ou de la réception d'un formulaire complété, et que tous les documents affichés sont valides selon la définition du type de document pour XHTML 1.0.  L'objectif principal du projet <application>JWIG</application> est de simplifier le développement de services Web complexes par rapport à des alternatifs tels que Servlets, JSP, ASP, et PHP. <application>JWIG</application> est un héritier du langage de recherche <application>&lt;bigwig&gt;</application>.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.brics.dk/JWIG/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.brics.dk/JWIG/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.brics.dk/JWIG/download.html"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.brics.dk/JWIG/download.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Lava</application> is a name unfortunately chosen for several unrelated software development languages/projects. So it doesn't appear as though BLFS has a preference for one over another, the project web sites are listed below, without descriptions of the capabilities or features for any of them.
fr: <application>Lava</application> est le nom malheureusement choisi pour plusieurs langages/projets de développement de logiciels divers. Bien que BLFS n'en préfère aucun par rapport à l'autre, les sites Internet des projets sont listés ci-dessous, sans description des possibilités ou des fonctionnalités de l'un d'entre eux.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://lavape.sourceforge.net/index.htm"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://lavape.sourceforge.net/index.htm"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://mathias.tripod.com/IavaHomepage.html"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://mathias.tripod.com/IavaHomepage.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Mercury</application> is a new logic/functional programming language, which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Its highly optimized execution algorithm delivers efficiency far in excess of existing logic programming systems, and close to conventional programming systems.  <application>Mercury</application> addresses the problems of large-scale program development, allowing modularity, separate compilation, and numerous optimization/time trade-offs.
fr: <application>Mercury</application> est un nouveau langage de programmation logique/fonctionnelle qui associe la clarté et l'expressivité de la programmation déclarative avec l'analyse statique avancée et des fonctionnalités de détection d'erreurs. Son algorithme d'exécution hautement optimisé offre une bien plus grande efficacité que les systèmes de programmation logique existants, et se proche des systèmes de programmation conventionnels.  <application>Mercury</application> traite les problèmes de développement de programmes à grande échelle en permettant la modularité, la compilation séparée et de nombreux compromis entre optimisation et temps.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://mercurylang.org/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://mercurylang.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://mercurylang.org/download.html"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://mercurylang.org/download.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Mono</application> provides the necessary software to develop and run .NET client and server applications on Linux, Solaris, Mac OS X, Windows, and Unix. Sponsored by Novell, the <application>Mono</application> open source project has an active and enthusiastic contributing community and is positioned to become the leading choice for development of Linux applications.
fr: <application>Mono</application> offre le logiciel nécessaire pour développer et exécuter des applications clients et serveurs .NET sur Linux, Solaris, Mac OS X, Windows, et Unix. Soutenu par Novell, le projet open source <application>Mono</application> dispose d'une communauté de contributeurs active et motivée et peut devenir le choix final pour le développement d'applications Linux.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.mono-project.com/Main_Page"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.mono-project.com/Main_Page"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://ftp.novell.com/pub/mono/archive/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://ftp.novell.com/pub/mono/archive/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>MPD</application> is a variant of the <application>SR</application> programming language.  <application>SR</application> has a Pascal-like syntax and uses guarded commands for control statements. <application>MPD</application> has a C-like syntax and C-like control statements. However, the main components of the two languages are the same: resources, globals, operations, procs, procedures, processes, and virtual machines.  Moreover, <application>MPD</application> supports the same variety of concurrent programming mechanisms as <application>SR</application>: co statements, semaphores, call/send/forward invocations, and receive and input statements.
fr: <application>MPD</application> est une variante du langage de programmation <application>SR</application>.  <application>SR</application> dispose d'une syntaxe ressemblant au Pascal et il utilise des commandes réservées pour l'établissement de contrôles.  <application>MPD</application> a une syntaxe et des établissements de contrôle similaires au C. Cependant, les composants principaux des deux langages sont les mêmes&nbsp;: ressources, globales, opérations, procs, procédures, processus et machines virtuelles. De plus, <application>MPD</application> supporte la même variété de mécanismes de programmation simultanés que <application>SR</application>&nbsp;: co établissements, sémaphores, invocations d'appel/envoi/transfert et établissements de réceptions et d'entrées.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.cs.arizona.edu/mpd/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.cs.arizona.edu/mpd/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.cs.arizona.edu/mpd/download/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.cs.arizona.edu/mpd/download/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Nemerle</application> is a high-level statically-typed programming language for the .NET platform. It offers functional, object-oriented and imperative features. It has a simple C#-like syntax and a powerful meta-programming system. Features that come from the functional land are variants, pattern matching, type inference and parameter polymorphism (aka generics). The meta-programming system allows great compiler extensibility, embedding domain specific languages, partial evaluation and aspect-oriented programming.
fr: <application>Nemerle</application> est un langage de programmation de haut niveau typé de façon statique pour la plate-forme .NET. Il offre des fonctionnalités fonctionnelles, orientées objet et impératives. Il dispose d'une syntaxe similaire au C et d'un puissant système de méta-programmation.  Des fonctionnalités issues de la sphère fonctionnelle sont des variantes, une correspondance de modèle, la déduction de types et le polymorphisme des paramètres (alias génériques). Le système de méta-programmation permet une extensibilité énorme du compilateur, des langages spécifiques à des matières dans l'embarqué, l'évaluation partielle et la programmation orientée objet.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://nemerle.org/About"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://nemerle.org/About"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://nemerle.org/Downloads"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://nemerle.org/Downloads"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: GNU <application>Octave</application> is a high-level language, primarily intended for numerical computations. It provides a convenient command line interface for solving linear and nonlinear problems numerically, and for performing other numerical experiments using a language that is mostly compatible with Matlab. It may also be used as a batch-oriented language. <application>Octave</application> has extensive tools for solving common numerical linear algebra problems, finding the roots of nonlinear equations, integrating ordinary functions, manipulating polynomials, and integrating ordinary differential and differential-algebraic equations. It is easily extensible and customizable via user-defined functions written in <application>Octave</application>'s own language, or using dynamically loaded modules written in C++, C, Fortran, or other languages.
fr: GNU <application>Octave</application> est un langage de haut niveau, conçu à la base pour des calculs numériques. Il fournit une interface pratique en ligne de commande pour résoudre des problèmes linéaires et non linéaires de façon numérique, et pour effectuer d'autres expérimentations numériques en utilisant un langage qui est presque complètement compatible avec Matlab. Il peut aussi être utilisé en tant que langage orienté batch.  <application>Octave</application> dispose d'outils très complets pour résoudre des problèmes numériques courants en algèbre linéaire, pour rechercher les racines des équations non linéaires, pour intégrer des fonctions ordinaires, pour manipuler des polynômes et pour intégrer des équations différentielles ordinaires et des équations algébriques différentielles. Il est facilement extensible et personnalisable à travers des fonctions définies par l'utilisateur écrites dans le propre langage <application>Octave</application>, ou en utilisant des modules chargés de façon dynamique et écrits en C++, C, Fortran, ou dans d'autres langages.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.gnu.org/software/octave/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.gnu.org/software/octave/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.gnu.org/software/octave/download.html"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.gnu.org/software/octave/download.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>OO2C</application> is an Oberon-2 development platform.  It consists of an optimizing compiler, a number of related tools, a set of standard library modules and a reference manual.  Oberon-2 is a general-purpose programming language in the tradition of Pascal and Modula-2. Its most important features are block structure, modularity, separate compilation, static typing with strong type checking (also across module boundaries) and type extension with type-bound procedures. Type extension makes Oberon-2 an object-oriented language.
fr: <application>OO2C</application> est une plate-forme de développement Oberon-2. Il consiste en un compilateur d'optimisation, dans un certain nombre d'outils liés, dans un ensemble de modules de bibliothèques standards et dans un manuel de référence. Oberon-2 est un langage de programmation généraliste dans la tradition de Pascal et de Modula-2. Ses fonctionnalités les plus importantes sont la structure en blocs, la modularité, la compilation séparée, le typage statique avec un contrôle rigoureux des types (même dans les limites du module) et l'extension de type avec des procédures spécifiques aux types. L'extension de type fait d'Oberon-2 un langage orienté objet.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://sourceforge.net/projects/ooc/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://sourceforge.net/projects/ooc/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="&sourceforge-dl;/ooc/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="&sourceforge-dl;/ooc/"/>

note: type: Content of: <sect1><sect2><sect3><title>
en: Ordered Graph Data Language (OGDL)
fr: Ordered Graph Data Language (OGDL, langage de données de graphe ordonné)

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>OGDL</application> is a structured textual format that represents information in the form of graphs, where the nodes are strings and the arcs or edges are spaces or indentation.
fr: <application>OGDL</application> est un format de texte structuré qui représente des informations sous la forme de graphes, où les n&oelig;uds sont des chaînes et les arcs ou les bords sont des espaces ou de l'indentation.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://ogdl.sourceforge.net/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://ogdl.sourceforge.net/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="&sourceforge-dl;/ogdl/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="&sourceforge-dl;/ogdl/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Pike</application> is a dynamic programming language with a syntax similar to Java and C. It is simple to learn, does not require long compilation passes and has powerful built-in data types allowing simple and really fast data manipulation. Pike is released under the GNU GPL, GNU LGPL and MPL.
fr: <application>Pike</application> est un langage de programmation dynamique ayant une syntaxe similaire au Java et au C. Il est simple à apprendre, il n'exige pas de longues passes de compilation et il a des types de données intégrés puissants permettant la manipulation simple et rapide de données.  Pike est publié sous la GNU GPL, GNU LGPL et MPL.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://pike.ida.liu.se/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://pike.ida.liu.se/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://pike.ida.liu.se/download/pub/pike"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://pike.ida.liu.se/download/pub/pike"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Pyrex</application> is a language specially designed for writing Python extension modules. It's designed to bridge the gap between the nice, high-level, easy-to-use world of <application>Python</application> and the messy, low-level world of C.  <application>Pyrex</application> lets you write code that mixes <application>Python</application> and C data types any way you want, and compiles it into a C extension for <application>Python</application>.
fr: <application>Pyrex</application> est un langage spécialement conçu pour écrire des modules d'extension Python. Il est conçu pour combler le fossé entre le monde sympathique, de haut niveau et facile à utiliser de <application>Python</application> et le monde chaotique de bas niveau du C.  <application>Pyrex</application> vous permet d'écrire du code qui mélange des types de données <application>Python</application> et C de la façon que vous voulez et de le compiler dans une extension C pour <application>Python</application>.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Q</application> is a functional programming language based on term rewriting. Thus, a <application>Q</application> program or <quote>script</quote> is simply a collection of equations which are used to evaluate expressions in a symbolic fashion. The equations establish algebraic identities and are interpreted as rewriting rules in order to reduce expressions to <quote>normal forms</quote>.
fr: <application>Q</application> est un langage de programmation fonctionnel basé sur la réécriture du terminal. Un programme <application>Q</application> ou un <quote>script</quote> est ainsi simplement un ensemble d'équations utilisées pour évaluer les expressions d'une manière symbolique. Les équations établissent des identifieurs algébriques et sont interprétées comme la réécriture de règles afin de réduire des expressions en des <quote>formes normales</quote>.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://q-lang.sourceforge.net/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://q-lang.sourceforge.net/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="&sourceforge-dl;/q-lang/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="&sourceforge-dl;/q-lang/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>R</application> is a language and environment for statistical computing and graphics. It is a GNU project similar to the <application>S</application> language and environment which was developed at Bell Laboratories (formerly AT&amp;T, now Lucent Technologies) by John Chambers and colleagues.  <application>R</application> can be considered as a different implementation of <application>S</application>.  There are some important differences, but much code written for <application>S</application> runs unaltered under <application>R</application>. <application>R</application> provides a wide variety of statistical (linear and nonlinear modelling, classical statistical tests, time-series analysis, classification, clustering, ...) and graphical techniques, and is highly extensible. The <application>S</application> language is often the vehicle of choice for research in statistical methodology, and <application>R</application> provides an Open Source route to participation in that activity.
fr: <application>R</application> est un langage et un environnement pour le calcul statistique et les graphiques. C'est un projet GNU similaire au langage et à l'environnement <application>S</application> qui a été développé dans les laboratoires Bell (anciennement AT&amp;T, maintenant Lucent Technologies) par John Chambers et ses collègues. <application>R</application> peut être considéré comme une implémentation différente du <application>S</application>. Il y a des différences importantes mais beaucoup de code écrit pour <application>S</application> fonctionne sans effort sous <application>R</application>. <application>R</application> fournit une grande variété de statistiques (modélisation linéaire et non linéaire, tests statistiques classiques, analyses de séries temporelles, classification, clustering, ...) et de techniques graphiques, et il est hautement extensible. Le langage <application>S</application> est souvent le choix privilégié pour la recherche en méthodologie statistique et <application>R</application> offre une voie open source pour participer à cette activité.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.r-project.org/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.r-project.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://cran.r-project.org/mirrors.html"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://cran.r-project.org/mirrors.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Regina</application> is a Rexx interpreter that has been ported to most Unix platforms (Linux, FreeBSD, Solaris, AIX, HP-UX, etc.) and also to OS/2, eCS, DOS, Win9x/Me/NT/2k/XP, Amiga, AROS, QNX4.x, QNX6.x BeOS, MacOS X, EPOC32, AtheOS, OpenVMS, SkyOS and OpenEdition.  Rexx is a programming language that was designed to be easy to use for inexperienced programmers yet powerful enough for experienced users. It is also a language ideally suited as a macro language for other applications.
fr: <application>Regina</application> est un interpréteur Rexx qui porté vers la plupart des plate-formes Unix (Linux, FreeBSD, Solaris, AIX, HP-UX, etc.) et vers OS/2, eCS, DOS, Win9x/Me/NT/2k/XP, Amiga, AROS, QNX4.x, QNX6.x BeOS, MacOS X, EPOC32, AtheOS, OpenVMS, SkyOS et OpenEdition.  Rexx est un langage de programmation conçu pour être facile à utiliser par des programmeurs inexpérimentés mais assez puissant pour des utilisateurs expérimentés. C'est aussi un langage qui convient parfaitement pour être un langage de macro pour d'autres applications.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://regina-rexx.sourceforge.net/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://regina-rexx.sourceforge.net/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="&sourceforge-dl;/regina-rexx"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="&sourceforge-dl;/regina-rexx"/>

note: type: Content of: <sect1><sect2><sect3><title>
en: Small Device C Compiler (SDCC)
fr: Small Device C Compiler (SDCC, compilateur C de petit périphérique)

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>SDCC</application> is a Freeware, retargetable, optimizing ANSI-C compiler that targets the Intel 8051, Maxim 80DS390 and the Zilog Z80 based MCUs. Work is in progress on supporting the Motorola 68HC08 as well as Microchip PIC16 and PIC18 series. The entire source code for the compiler is distributed under GPL.
fr: <application>SDCC</application> est un compilateur gratuit, qu'on peut recibler et qui optimise l'ANSI-C et qui cible Intel 8051, Maxim 80DS390 et les MCUs basés sur Zilog Z80. Le travail progresse autour du support de Motorola 68HC08 et des séries Microchip PIC16 et PIC18. Tout le code source pour le compilateur est distribué sous la GPL.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://sdcc.sourceforge.net/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://sdcc.sourceforge.net/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://sdcc.sourceforge.net/snap.php#Source"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://sdcc.sourceforge.net/snap.php#Source"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>SmartEiffel</application> claims to be <quote>the fastest and the slimmest multi-platform Eiffel compiler on Earth</quote>.  Eiffel is an object-oriented programming language which emphasizes the production of robust software. Its syntax is keyword-oriented in the ALGOL and Pascal tradition. Eiffel is strongly statically typed, with automatic memory management (typically implemented by garbage collection). Distinguishing characteristics of Eiffel include Design by contract (DbC), liberal use of inheritance including multiple inheritance, a type system handling both value and reference semantics, and generic classes. Eiffel has a unified type system&mdash;all types in Eiffel are classes, so it is possible to create subclasses of the basic classes such as INTEGER. Eiffel has operator overloading, including the ability to define new operators, but does not have method overloading.
fr: <application>SmartEiffel</application> se veut être <quote>le compilateur multi-plate-formes Eiffel le plus rapide et le plus léger de la terre</quote>. Eiffel est un langage de programmation orienté objet qui met en valeur la production de logiciels robustes. Sa syntaxe est orientée mots-clés dans la tradition d'ALGOL et du Pascal. Eiffel est typé de façon très statique, avec une gestion automatique de la mémoire (gérée en général par un ramasse-miettes). Les caractéristiques les plus remarquables d'Eiffel sont le Design by contract (DbC, la conception par contrat), l'utilisation libérale de l'héritage dont l'héritage multiple, son système de types qui gère la sémantique des valeurs et des références, et les classes génériques. Eiffel dispose d'un système de type unifié &mdash;&nbsp;tous les types d'Eiffel sont des classes, donc il est possible de créer des sous-classes de classes de base telles que INTEGER. Eiffel permet la surcharge d'opérateur, avec la possibilité de définir de nouveaux opérateurs, mais ne permet pas la surcharge de méthode.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://smarteiffel.loria.fr/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://smarteiffel.loria.fr/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="https://gforge.inria.fr/frs/?group_id=184"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="https://gforge.inria.fr/frs/?group_id=184"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Squeak</application> is an open, highly-portable Smalltalk implementation whose virtual machine is written entirely in Smalltalk, making it easy to debug, analyze, and change. To achieve practical performance, a translator produces an equivalent C program whose performance is comparable to commercial Smalltalks. Other noteworthy aspects of <application>Squeak</application> include: real-time sound and music synthesis written entirely in Smalltalk, extensions of BitBlt to handle color of any depth and anti-aliased image rotation and scaling, network access support that allows simple construction of servers and other useful facilities, it runs bit-identical on many platforms (Windows, Mac, Unix, and others), a compact object format that typically requires only a single word of overhead per object and a simple yet efficient incremental garbage collector for 32-bit direct pointers efficient bulk-mutation of objects.
fr: <application>Squeak</application> est une implémentation ouverte et très portable de Smalltalk, dont la machine virtuelle est écrite en Smalltalk, ce qui la rend facile à déboguer, à analyser et à modifier. Pour obtenir des performances pratiques, un traducteur produit un programme C équivalent dont la performance est comparable aux Smalltalks commerciaux. D'autres aspects intéressants de <application>Squeak</application> incluent&nbsp;: le son en temps réel et le synthétiseur de musique écrit complètement en Smalltalk, les extensions de BitBlt pour gérer la couleur de n'importe quelle profondeur, la rotation et le redimensionnement d'images sans crénelage, le support de l'accès réseau qui permet de construire facilement des serveurs et d'autres infrastructures utiles, l'exécution de binaires identiques sur beaucoup de plate-formes (Windows, Mac, Unix, et autres), la compacité de son format d'objet qui n'exige en général que deux octets de plus par objet et son ramasse-miettes simple mais efficace pour les pointeurs directs sur 32 bits et une mutation de masse efficace des objets.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.squeak.org/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.squeak.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.squeak.org/Download/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.squeak.org/Download/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>SR</application> is a language for writing concurrent programs. The main language constructs are resources and operations.  Resources encapsulate processes and variables they share; operations provide the primary mechanism for process interaction.  <application>SR</application> provides a novel integration of the mechanisms for invoking and servicing operations. Consequently, all of local and remote procedure call, rendezvous, message passing, dynamic process creation, multicast, and semaphores are supported.  <application>SR</application> also supports shared global variables and operations.
fr: <application>SR</application> est un langage pour écrire des programmes concurrents. Les constructions principales du langage sont les ressources et les opérations. Les ressources encapsulent des processus et des variables qu'elles partagent&nbsp;; les opérations fournissent le mécanisme primaire de l'interaction des processus.  <application>SR</application> offre une intégration originale des mécanismes pour les opérations d'appel et de mise en service. Par conséquent, les appels locaux et de procédures distantes, les rendez-vous, le passage de message, la création de processus dynamiques, le multicast, et les sémaphores sont tous supportés. <application>SR</application> supporte aussi des variables globales et des opérations partagées.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.cs.arizona.edu/sr/index.html"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.cs.arizona.edu/sr/index.html"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="ftp://ftp.cs.arizona.edu/sr/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="ftp://ftp.cs.arizona.edu/sr/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: Standard ML is a safe, modular, strict, functional, polymorphic programming language with compile-time type checking and type inference, garbage collection, exception handling, immutable data types and updatable references, abstract data types, and parametric modules. It has efficient implementations and a formal definition with a proof of soundness. There are many implementations of Standard ML, among them:
fr: ML Standard est un langage de programmation sécurisé, modulaire, strict, fonctionnel, polymorphe avec une vérification de type au moment de la compilation et l'inference de type, la récupération des déchets, la gestion des exceptions, les types de données immuables et des références qui peuvent être mises à jour, des types de données abstraits et des modules paramétriques. Il comporte des implémentations efficaces et une définition formelle avec une épreuve sans sons. Il existe de nombreuses implémentations du ML Standard, parmi lesquelles&nbsp;:

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: ML Kit: <ulink url="http://www.it-c.dk/research/mlkit/"/>
fr: Kit ML&nbsp;: <ulink url="http://www.it-c.dk/research/mlkit/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: MLton: <ulink url="http://mlton.org/"/>
fr: MLton&nbsp;: <ulink url="http://mlton.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Poly/ML: <ulink url="http://www.polyml.org/"/>
fr: Poly/ML&nbsp;: <ulink url="http://www.polyml.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Standard ML of New Jersey: <ulink url="http://www.smlnj.org/"/>
fr: ML Standard de New Jersey&nbsp;: <ulink url="http://www.smlnj.org/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>SBCL</application> is an open source (free software)  compiler and runtime system for ANSI Common Lisp. It provides an interactive environment including an integrated native compiler, a debugger, and many extensions. <application>SBCL</application> runs on a number of platforms.
fr: <application>SBCL</application> est un compilateur en un système d'exécution immédiate open source (logiciel libre) pour l'ANSI Common Lisp.  Il offre un environnement interactif comprenant un compilateur natif intégré, un débogueur et beaucoup d'extensions. <application>SBCL</application> fonctionne sur un grand nombre de plate-formes.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.sbcl.org/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.sbcl.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="&sourceforge-dl;/sbcl/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="&sourceforge-dl;/sbcl/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Tiny C Compiler</application> is a small C compiler that can be used to compile and execute C code everywhere, for example on rescue disks (about 100KB for x86 TCC executable, including C preprocessor, C compiler, assembler and linker).  <application>TCC</application> is fast. It generates optimized x86 code, has no byte code overhead and compiles, assembles and links several times faster than <application>GCC</application>.  <application>TCC</application> is versatile, any C dynamic library can be used directly. It is heading toward full ISOC99 compliance and can compile itself. The compiler is safe as it includes an optional memory and bound checker. Bound checked code can be mixed freely with standard code. <application>TCC</application> compiles and executes C source directly. No linking or assembly necessary. A full C preprocessor and GNU-like assembler is included. It is C script supported; just add <quote>#!/usr/local/bin/tcc -run</quote> on the first line of your C source, and execute it directly from the command line. With libtcc, you can use <application>TCC</application> as a backend for dynamic code generation.
fr: <application>Tiny C Compiler</application> est un petit compilateur C qui peut être utilisé pour compiler et exécuter du code C n'importe où, par exemple sur des disques de secours (environ 100Ko pour un exécutable TCC x86, y compris le préprocesseur C, le compilateur C, l'assembleur et l'éditeur de liens).  <application>TCC</application> est rapide. Il génère du code x86 optimisé, il n'a pas de coût supplémentaire dû à un bytecode et il compile, assemble et lie beaucoup plus vite que <application>GCC</application>.  <application>TCC</application> est souple, n'importe quelle bibliothèque C dynamique peut être directement utilisée. Il se rapproche des exigences complètes de ISOC99 et il peut se compiler. Le compilateur est sécurisé car il inclut un vérificateur de mémoire et de bornes facultatif. Le code dont les bornes sont vérifiées peut être librement mêlé avec du code standard.  <application>TCC</application> compile et exécute directement du code source C. Pas besoin d'édition de liens ou d'assemblage. Un préprocesseur C complet et un assembleur de type GNU est inclus. Le script C est supporté&nbsp;; ajoutez simplement <quote>#!/usr/local/bin/tcc -run</quote> sur la première ligne de votre source C, et exécutez-le directement depuis la ligne de commande.  Avec libtcc, vous pouvez utiliser <application>TCC</application> comme support pour la génération de code dynamique.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://bellard.org/tcc/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://bellard.org/tcc/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://download.savannah.gnu.org/releases-noredirect/tinycc/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://download.savannah.gnu.org/releases-noredirect/tinycc/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>TinyCOBOL</application> is a COBOL compiler being developed by members of the free software community. The mission is to produce a COBOL compiler based on the COBOL 85 standards.  <application>TinyCOBOL</application> is available for the Intel architecture (IA32) and compatible processors on the following platforms: BeOS, FreeBSD, Linux and MinGW on Windows.
fr: <application>TinyCOBOL</application> est un compilateur COBOL développé par les membres de la communauté du logiciel libre. Sa mission est de produire un compilateur COBOL basé sur les standards COBOL 85.  <application>TinyCOBOL</application> est disponible pour l'architecture Intel (IA32) et les processeurs compatibles sur les plate-formes suivantes&nbsp;: BeOS, FreeBSD, Linux et MinGW sur Windows.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://sourceforge.net/projects/tiny-cobol/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://sourceforge.net/projects/tiny-cobol/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="&sourceforge-dl;/tiny-cobol/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="&sourceforge-dl;/tiny-cobol/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Yorick</application> is an interpreted programming language, designed for postprocessing or steering large scientific simulation codes. Smaller scientific simulations or calculations, such as the flow past an airfoil or the motion of a drumhead, can be written as standalone yorick programs. The language features a compact syntax for many common array operations, so it processes large arrays of numbers very efficiently. Unlike most interpreters, which are several hundred times slower than compiled code for number crunching, <application>Yorick</application> can approach to within a factor of four or five of compiled speed for many common tasks. Superficially, <application>Yorick</application> code resembles C code, but <application>Yorick</application> variables are never explicitly declared and have a dynamic scoping similar to many Lisp dialects. The <quote>unofficial</quote> home page for <application>Yorick</application> can be found at <ulink url="http://www.maumae.net/yorick"/>.
fr: <application>Yorick</application> est un langage de programmation interprété conçu pour traiter et gérer de grands codes de simulation scientifique. Des simulations ou des calculs scientifiques plus petits, tels que le passé flottant d'une aile ou le déplacement d'une peau, peuvent être écrits sous forme de programmes yorick autonomes. Les fonctionnalités de langue, une syntaxe compacte pour de nombreuses opérations d'échelle habituelle, donc il calcule des nombres à grande échelle de façon très efficace. Contrairement à beaucoup d'interpréteurs, qui sont cent fois plus lents que le code compilé pour la récupération de nombres, <application>Yorick</application> effectue de nombreuses tâches courantes avec une vitesse réduite d'un facteur approchant quatre ou cinq. De façon superficielle, le code <application>Yorick</application> ressemble à du code C mais les variables <application>Yorick</application> ne sont jamais explicitement déclarées et elles ont un pointage dynamique similaire à de nombreux dialectes Lisp. Vous pouvez trouver la page d'accueil <quote>non officielle</quote> de <application>Yorick</application> sur <ulink url="http://www.maumae.net/yorick"/>.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://yorick.sourceforge.net/index.php"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://yorick.sourceforge.net/index.php"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://sourceforge.net/projects/yorick/files/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://sourceforge.net/projects/yorick/files/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>ZPL</application> is an array programming language designed from first principles for fast execution on both sequential and parallel computers. It provides a convenient high-level programming medium for supercomputers and large-scale clusters with efficiency comparable to hand-coded message passing. It is the perfect alternative to using a sequential language like C or Fortran and a message passing library like MPI.
fr: <application>ZPL</application> est un langage de programmation d'échelle conçu à partir des principes d'exécution rapide des ordinateurs séquentiels et parallèles. Il offre un média de programmation pratique de haut niveau pour les super-ordinateurs et les clusters à grande échelle d'une efficacité comparable au passage de messages codés à la main. C'est l'alternative parfaite à l'utilisation d'un langage séquentiel tel que le C ou Fortran et à une bibliothèque de passage de messages comme MPI.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.cs.washington.edu/research/zpl/home/index.html"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.cs.washington.edu/research/zpl/home/index.html"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.cs.washington.edu/research/zpl/download/download.html"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.cs.washington.edu/research/zpl/download/download.html"/>

note: type: Content of: <sect1><sect2><title>
en: Programming Libraries and Bindings
fr: Bibliothèques et bindings de programmation

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>BECL</application> is intended to give users a convenient possibility to analyze, create, and manipulate (binary) Java class files (those ending with <filename class='extension'>.class</filename>). Classes are represented by objects which contain all the symbolic information of the given class: methods, fields and byte code instructions, in particular. Such objects can be read from an existing file, be transformed by a program (e.g., a class loader at run-time) and dumped to a file again. An even more interesting application is the creation of classes from scratch at run-time. The Byte Code Engineering Library may be also useful if you want to learn about the Java Virtual Machine (JVM) and the format of Java <filename class='extension'>.class</filename> files.  <application>BCEL</application> is already being used successfully in several projects such as compilers, optimizers, obfuscators, code generators and analysis tools.
fr: <application>BECL</application> vise à donner aux utilisateurs la capacité pratique à analyser, créer et manipuler des fichiers de classe Java (binaires) (ces dernier se terminant par <filename class='extension'>.class</filename>). Les classes sont représentées par des objets qui contiennent toutes les informations symboliques de la classe donnée&nbsp;: en particulier les méthodes, les champs et les instructions en bytecode. De tels objets peuvent être lus à partir d'un fichier existant, ils peuvent être transformés par un programme (comme un chargeur de classes au moment de l'exécution) et renvoyés vers un fichier. Une application encore plus intéressante consiste en la création de classes à partir de rien au moment de l'exécution. La bibliothèque d'ingénierie de bytecode (Byte Code Engineering Library) peut aussi être utile si vous voulez en apprendre davantage sur la machine virtuelle Java (Java Virtual Machine, JVM)  et le format des fichiers Java <filename class='extension'>.class</filename>.  <application>BCEL</application> est déjà utilisé avec succès dans plusieurs projets tels que des compilateurs, des optimiseurs, des obfuscateurs de code, des générateurs et des analyseurs de code.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://jakarta.apache.org/bcel/index.html"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://jakarta.apache.org/bcel/index.html"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://archive.apache.org/dist/jakarta/bcel/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://archive.apache.org/dist/jakarta/bcel/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Choco</application> is a Java library for constraint satisfaction problems (CSP), constraint programming (CP) and explanation-based constraint solving (e-CP). It is built on a event-based propagation mechanism with backtrackable structures.
fr: <application>Choco</application> est une bibliothèque Java pour les problèmes de satisfaction de contraintes (CSP), la programmation par contrainte (CP) et la résolution de contraintes basée sur l'explication (e-CP). Il se base sur un mécanisme de propagation par événement avec des structures qui permettent la rétro-inspection.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://sourceforge.net/projects/choco/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://sourceforge.net/projects/choco/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://choco.sourceforge.net/download.html"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://choco.sourceforge.net/download.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>GOB</application> (<application>GOB2</application> anyway) is a preprocessor for making GObjects with inline C code so that generated files are not edited. Syntax is inspired by <application>Java</application> and <application>Yacc</application> or <application>Lex</application>. The implementation is intentionally kept simple, and no C actual code parsing is done.
fr: <application>GOB</application> (en tout cas, <application>GOB2</application>)  est un préprocesseur pour faire du GObjects avec du code C aligné afin que les fichiers générés ne soient pas édités. La syntaxe s'inspire de <application>Java</application> et de <application>Yacc</application> ou de <application>Lex</application>. L'implémentation est volontairement simple et aucun parsing de code C final n'est effectué.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.5z.com/jirka/gob.html"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.5z.com/jirka/gob.html"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://ftp.5z.com/pub/gob/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://ftp.5z.com/pub/gob/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>GTK+</application>/<application>GNOME</application> language bindings allow <application>GTK+</application> to be used from other programming languages, in the style of those languages.
fr: Les liaisons de langage <application>GTK+</application>/<application>GNOME</application> permettent à <application>GTK+</application> d'être utilisé à partir d'autres langages de programmation, dans le style de ces langages.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.gtk.org/language-bindings.php"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.gtk.org/language-bindings.php"/>

note: type: Content of: <sect1><sect2><sect3><sect4><para>
en: <application>Java-GNOME</application> is a set of Java bindings for the <application>GNOME</application> and <application>GTK+</application> libraries that allow <application>GNOME</application> and <application>GTK+</application> applications to be written in Java. The <application>Java-GNOME</application> API has been carefully designed to be easy to use, maintaining a good OO paradigm, yet still wrapping the entire functionality of the underlying libraries.  <application>Java-GNOME</application> can be used with the <application>Eclipse</application> development environment and Glade user interface designer to create applications with ease.
fr: <application>Java-GNOME</application> est un ensemble de bindings Java pour les bibliothèques <application>GNOME</application> et <application>GTK+</application> qui permettent aux applications <application>GNOME</application> et <application>GTK+</application> d'être écrites en Java. L'API <application>Java-GNOME</application> a été conçue avec soin pour être facile à utiliser, tout en maintenant un bon paradigme OO, et en enveloppant toutes les fonctionnalités des bibliothèques sous-jacentes.  <application>Java-GNOME</application> peut être utilisé avec l'environnement de développement <application>Eclipse</application> et le concepteur d'interfaces utilisateurs Glade pour créer facilement des applications.

note: type: Content of: <sect1><sect2><sect3><sect4><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://java-gnome.sourceforge.net/4.0/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://java-gnome.sourceforge.net/4.0/"/>

note: type: Content of: <sect1><sect2><sect3><sect4><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://java-gnome.sourceforge.net/4.0/get/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://java-gnome.sourceforge.net/4.0/get/"/>

note: type: Content of: <sect1><sect2><sect3><sect4><para>
en: <application>gtk2-perl</application> is the collective name for a set of Perl bindings for <application>GTK+</application> 2.x and various related libraries. These modules make it easy to write <application>GTK</application> and <application>GNOME</application> applications using a natural, Perlish, object-oriented syntax.
fr: <application>gtk2-perl</application> est le nom collectif d'un ensemble de bindings perl pour <application>GTK+</application> 2.x et diverses bibliothèques liées. Ces modules facilitent l'écriture d'applications <application>GTK</application> et <application>GNOME</application> en utilisant une syntaxe naturelle, de style perl et orientée objet.

note: type: Content of: <sect1><sect2><sect3><sect4><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://gtk2-perl.sourceforge.net/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://gtk2-perl.sourceforge.net/"/>

note: type: Content of: <sect1><sect2><sect3><sect4><itemizedlist><listitem><para>
en: Download Location: <ulink url="&sourceforge-dl;/gtk2-perl"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="&sourceforge-dl;/gtk2-perl"/>

note: type: Content of: <sect1><sect2><sect3><title>
en: KDE Language Bindings
fr: Bindings de langage KDE

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>KDE</application> and most <application>KDE</application> applications are implemented using the C++ programming language, however there are number of bindings to other languages are available. These include scripting languages like <application>Perl</application>, <application>Python</application> and <application>Ruby</application>, and systems programming languages such as Java and C#.
fr: <application>KDE</application> et la plupart des applications <application>KDE</application> sont implémentées en utilisant le langage de programmation C++, cependant de nombreux bindings vers d'autres langages sont disponibles. Ils incluent des langages de script comme <application>Perl</application>, <application>Python</application> et <application>Ruby</application> et des langages de programmation systèmes tels que Java et C#.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://techbase.kde.org/Development/Languages"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://techbase.kde.org/Development/Languages"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Numerical Python</application> adds a fast array facility to the <application>Python</application> language.
fr: <application>Numerical Python</application> ajoute un niveau d'infrastructure rapide au langage <application>Python</application>.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://numeric.scipy.org/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://numeric.scipy.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="&sourceforge-dl;/numpy/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="&sourceforge-dl;/numpy/"/>

note: type: Content of: <sect1><sect2><sect3><title>
en: Perl Scripts and Additional Modules
fr: Scripts Perl et Modules supplémentaires

note: type: Content of: <sect1><sect2><sect3><para>
en: There are many <application>Perl</application> scripts and additional modules located on the Comprehensive Perl Archive Network (CPAN) web site. Here you will find <quote>All Things Perl</quote>.
fr: Il existe de nombreux scripts <application>Perl</application> et des modules supplémentaires situés sur le site Internet du Comprehensive Perl Archive Network (CPAN, réseau complet d'archives perl). Vous y trouverez <quote>All Things Perl</quote> (tout sur Perl).

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://cpan.org/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://cpan.org/"/>

note: type: Content of: <sect1><sect2><title>
en: Integrated Development Environments
fr: Environnements de développement intégré

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>A-A-P</application> makes it easy to locate, download, build and install software. It also supports browsing source code, developing programs, managing different versions and distribution of software and documentation. This means that <application>A-A-P</application> is useful both for users and for developers.
fr: <application>A-A-P</application> facilite la localisation, le téléchargement, la construction et l'installation de logiciels. Il supporte aussi la navigation dans le code source, le développement de programmes, la gestion de versions et de distributions différentes d'un logiciel et la documentation. Cela signifie que <application> A-A-P</application> est autant utile pour les utilisateurs que pour les développeurs.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.a-a-p.org/index.html"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.a-a-p.org/index.html"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.a-a-p.org/download.html"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.a-a-p.org/download.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Anujuta</application> is a versatile Integrated Development Environment (IDE) for C and C++ on GNU/Linux. It has been written for <application>GTK</application>/GNOME and features a number of advanced programming facilities. These include project management, application wizards, an on-board interactive debugger, and a powerful source editor with source browsing and syntax highlighting.
fr: <application>Anujuta</application> est un environnement de développement intégré (Integrated Development Environment, IDE) souple pour C et C++ sur GNU/Linux. Il a été écrit pour <application>GTK</application>/GNOME et il comporte un grand nombre d'infrastructures de programmation avancées.  Cela inclut la gestion de projets, des assistants d'application, un débogueur interactif à la volée et un puissant éditeur de code source avec possibilité de naviguer dans le code source et de mise en relief de la syntaxe.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://projects.gnome.org/anjuta/index.shtml"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://projects.gnome.org/anjuta/index.shtml"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://projects.gnome.org/anjuta/downloads.html"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://projects.gnome.org/anjuta/downloads.html"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Eclipse</application> is an open source community whose projects are focused on providing an extensible development platform and application frameworks for building software.  <application>Eclipse</application> contains many projects, including an Integrated Development Environment (IDE) for Java.
fr: <application>Eclipse</application> est une communauté open source dont les projets se concentrent sur la fourniture d'une plate-forme de développement extensible et d'environnements d'applications pour la construction de logiciels.  <application>Eclipse</application> contient de nombreux projets, y compris un environnement de développement intégré (Integrated Development Environment, IDE) pour Java.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.eclipse.org/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.eclipse.org/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://www.eclipse.org/downloads/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://www.eclipse.org/downloads/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: The <application>Mozart</application> Programming System is an advanced development platform for intelligent, distributed applications.  <application>Mozart</application> is based on the Oz language, which supports declarative programming, object-oriented programming, constraint programming, and concurrency as part of a coherent whole.  For distribution, <application>Mozart</application> provides a true network transparent implementation with support for network awareness, openness, and fault tolerance. Security is upcoming. It is an ideal platform for both general-purpose distributed applications as well as for hard problems requiring sophisticated optimization and inferencing abilities.
fr: Le système de programmation <application>Mozart</application> est une plate-forme de développement avancée pour des applications intelligentes et distribuées.  <application>Mozart</application> se fonde sur le langage Oz qui supporte la programmation déclarative, la programmation orientée objet, la programmation contrainte et la diversité simultanée comme part d'un ensemble cohérent. Pour la distribution, <application>Mozart</application> offre une vraie implémentation transparente de réseau avec un support pour la conscience, l'ouverture et la tolérance d'erreurs de réseau. La sécurité arrive. C'est une plate-forme idéale pour des applications généralistes distribuées et des problèmes difficiles exigeant des possibilités d'optimisation et d'inférence sophistiquées.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://mozart.github.io/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://mozart.github.io/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="https://github.com/mozart/mozart2#downloads"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="https://github.com/mozart/mozart2#downloads"/>

note: type: Content of: <sect1><sect2><title>
en: Other Development Tools
fr: Autres outils de développement

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>cachecc1</application> is a <application>GCC</application> cache. It can be compared with the well known <application>ccache</application> package. It has some unique features including the use of an LD_PRELOADed shared object to catch invocations to <command>cc1</command>, <command>cc1plus</command> and <command>as</command>, it transparently supports all build methods, it can cache <application>GCC</application> bootstraps and it can be combined with <application>distcc</application> to transparently distribute compilations.
fr: <application>cachecc1</application> est un cache <application>GCC</application>. On peut le comparer au paquet bien connu <application>ccache</application>. Il contient certaines fonctionnalités uniques, incluant l'utilisation d'un objet partagé LD_PRELOADed pour récupérer les appels à <command>cc1</command>, <command>cc1plus</command> et <command>as</command>, il supporte de façon transparente toutes les méthodes de construction, il peut mettre en cache des bootstraps <application>GCC</application> et il peut être associé à <application>distcc</application> pour distribuer de façon transparente des compilations.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://cachecc1.sourceforge.net/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://cachecc1.sourceforge.net/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="&sourceforge-dl;/cachecc1"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="&sourceforge-dl;/cachecc1"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>ccache</application> is a compiler cache. It acts as a caching pre-processor to C/C++ compilers, using the <option>-E</option> compiler switch and a hash to detect when a compilation can be satisfied from cache. This often results in 5 to 10 times faster speeds in common compilations.
fr: <application>ccache</application> est un cache de compilateur. Il agit en préprocesseur de mise en cache dans les compilateurs C/C++ en utilisant le paramètre <option>-E</option> du compilateur et un tiret pour détecter lorsqu'une compilation peut être satisfaite à partir du cache. Il s'ensuit souvent une vitesse 5 à 10 fois supérieure à celle des compilations habituelles.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="https://ccache.dev"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="https://ccache.dev"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="https://github.com/ccache/ccache/releases/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="https://github.com/ccache/ccache/releases/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>GNU DDD</application> is a graphical front-end for command-line debuggers such as <application>GDB</application>, <application>DBX</application>, <application>WDB</application>, <application>Ladebug</application>, <application>JDB</application>, <application>XDB</application>, the <application>Perl</application> debugger, the <application>Bash</application> debugger, or the <application>Python</application> debugger. Besides <quote>usual</quote> front-end features such as viewing source texts, <application>DDD</application> has an interactive graphical data display, where data structures are displayed as graphs.
fr: <application>GNU DDD</application> est une interface graphique avec des débogueurs en ligne de commande tels que <application>GDB</application>, <application>DBX</application>, <application>WDB</application>, <application>Ladebug</application>, <application>JDB</application>, <application>XDB</application>, le débogueur <application>Perl</application>, le débogueur <application>Bash</application> ou le débogueur <application>Python</application>. Outre les fonctionnalités d'une interface <quote>ordinaire</quote> telles que la visualisation du texte source, <application>DDD</application> jouit d'un affichage de données en graphique interactif, avec lequel les structures de données sont affichées comme des graphes.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://www.gnu.org/software/ddd/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://www.gnu.org/software/ddd/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="&gnu-http;/ddd/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="&gnu-http;/ddd/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>distcc</application> is a program to distribute builds of C, C++, Objective C or Objective C++ code across several machines on a network. <application>distcc</application> should always generate the same results as a local build, is simple to install and use, and is usually much faster than a local compile.  <application>distcc</application> does not require all machines to share a filesystem, have synchronized clocks, or to have the same libraries or header files installed. They can even have different processors or operating systems, if cross-compilers are installed.
fr: <application>distcc</application> est un programme pour distribuer des constructions de code C, C++, C objet ou C++ objet à travers plusieurs machines d'un réseau. <application>distcc</application> devrait toujours générer les mêmes résultats qu'une construction locale, il est simple à  installer et à utiliser et il est normalement beaucoup plus rapide qu'un compilateur local.  <application>distcc</application> ne nécessite pas que toutes les machines partagent un système de fichiers, qu'elles aient des heures synchronisées ou qu'elles disposent des mêmes bibliothèques ou des mêmes fichiers d'en-tête installés. Elles peuvent même avoir des processeurs ou des systèmes d'exploitation différents si des compilateurs croisés sont installés.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="https://distcc.github.io/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="https://distcc.github.io/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="https://github.com/distcc/distcc/releases"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="https://github.com/distcc/distcc/releases"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>Exuberant Ctags</application> generates an index (or tag) file of language objects found in source files that allows these items to be quickly and easily located by a text editor or other utility. A tag signifies a language object for which an index entry is available (or, alternatively, the index entry created for that object). Tag generation is supported for the following languages: Assembler, AWK, ASP, BETA, Bourne/Korn/Zsh Shell, C, C++, COBOL, Eiffel, Fortran, Java, Lisp, Lua, Make, Pascal, Perl, PHP, Python, REXX, Ruby, S-Lang, Scheme, Tcl, Vim, and YACC. A list of editors and tools utilizing tag files may be found at <ulink url="http://ctags.sourceforge.net/tools.html"/>.
fr: <application>Exuberant Ctags</application> génère un fichier index (ou tag) des objets de langage qu'on trouve dans les fichiers sources, ce qui permet à ces éléments d'être rapidement et facilement localisés par un éditeur de texte ou un autre outil. Un tag signifie un objet de langage pour lequel une entrée index est disponible (ou, sinon, l'entrée index créée pour cet objet). La génération d'un tag est supportée pour les langages suivants&nbsp;: Assembleur, AWK, ASP, BETA, Bourne/Korn/Zsh Shell, C, C++, COBOL, Eiffel, Fortran, Java, Lisp, Lua, Make, Pascal, Perl, PHP, Python, REXX, Ruby, S-Lang, Scheme, Tcl, Vim et YACC. Vous pouvez trouver une liste des éditeurs et des outils qui utilisent des fichiers de tag sur <ulink url="http://ctags.sourceforge.net/tools.html"/>.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://ctags.sourceforge.net/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://ctags.sourceforge.net/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="&sourceforge-dl;/ctags/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="&sourceforge-dl;/ctags/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>OProfile</application> is a system-wide profiler for Linux systems, capable of profiling all running code at low overhead.  <application>OProfile</application> is released under the GNU GPL. It consists of a kernel driver and a daemon for collecting sample data, and several post-profiling tools for turning data into information.  <application>OProfile</application> leverages the hardware performance counters of the CPU to enable profiling of a wide variety of interesting statistics, which can also be used for basic time-spent profiling. All code is profiled: hardware and software interrupt handlers, kernel modules, the kernel, shared libraries, and applications.  <application>OProfile</application> is currently in alpha status; however it has proven stable over a large number of differing configurations. It is being used on machines ranging from laptops to 16-way NUMA-Q boxes.
fr: <application>OProfile</application> est un éditeur de profil global pour les systèmes Linux, capable de profiler tout le code exécuté pour un faible coût.  <application>OProfile</application> est publié sous la GNU GPL. Il consiste en un pilote noyau et un démon pour récupérer des échantillons de données et plusieurs outils de post-profilage pour convertir des données en informations. <application>OProfile</application> exploite la performance des calculateurs matériels d'un processeur pour permettre le profilage d'une grande variété de statistiques intéressantes, qui peuvent aussi être utilisées pour le profilage de base du temps d'exécution. Tout le code est profilé&nbsp;: les gestionnaires d'interruption matériels et logiciels, modules du noyau, le noyau, les bibliothèques partagées et les applications.  <application>OProfile</application> est actuellement dans l'état alpha&nbsp;; cependant il a prouvé sa stabilité sur un grand nombre de configurations différentes. Il est utilisé sur des machines allant du portable aux machines 16 way NUMA-Q.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="http://oprofile.sourceforge.net/news/"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="http://oprofile.sourceforge.net/news/"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="http://oprofile.sourceforge.net/download/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="http://oprofile.sourceforge.net/download/"/>

note: type: Content of: <sect1><sect2><sect3><para>
en: <application>strace</application> is a system call tracer, i.e., a debugging tool which prints out a trace of all the system calls made by another process or program.
fr: <application>strace</application> est un traqueur d'appels systèmes, c'est-à-dire un outil de débogage qui affiche une trace de tous les appels systèmes effectués par un autre processus ou un autre programme.

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Project Home Page: <ulink url="https://strace.io"/>
fr: Page d'accueil du projet&nbsp;: <ulink url="https://strace.io"/>

note: type: Content of: <sect1><sect2><sect3><itemizedlist><listitem><para>
en: Download Location: <ulink url="https://strace.io/files/"/>
fr: Emplacement du téléchargement&nbsp;: <ulink url="https://strace.io/files/"/>
