"…mais ce serait peut-être l'une des plus grandes opportunités manquées de notre époque si le logiciel libre ne libérait rien d'autre que du code…"

Archive for décembre 2007

Quelques articles de Linux-Fr: Ruby On Rails, Logiciel libre, Temps réel

Posted by patrick sur décembre 18, 2007

Quelques brèves qui m’intéressent:

  1. la sortie de Ruby On Rails 2. On rappelle qu’une conférence a lieu le mercredi 19 décembre à l’ENSIMAG à 19h30 (voir plus bas).
  2. le logiciel libre, le problème des DRM
  3. le temps réel sous GNU/Linux
  • Ruby/ Ruby On Rails

===============================================
o Développeur: Sortie de Ruby on Rails 2.0
—————————————————————————
Auteur: EppO ( http://www.darox.net ) @ 19:00
Thème: Ruby

Ruby on Rails ( http://fr.wikipedia.org/wiki/Ruby_on_Rails ), le
célèbre framework basé sur le langage Ruby, permettant le développement rapide d’applications web selon le modèle MVC (Modèle, Vue, Contrôleur (
http://fr.wikipedia.org/wiki/Mod%C3%A8le-Vue-Contr%C3%B4leur )) sort en version 2.0.

Le développement qui a duré une année a permis l’ajout de nombreuses fonctionnalités, la résolution de beaucoup de bugs, une orientation tournée vers le REST ( http://fr.wikipedia.org/wiki/REST ), et pas mal d’allégements au niveau du core (externalisation de fonctionnalités en greffons).

DHH, le créateur du framework Ruby on Rails, a commenté ces nouveautés lors de Paris on Rails ( http://paris.onrails.info/ ). Pour les absents, des slides et/ou des podcasts des présentations devraient être mis en ligne prochainement.

[en] – Ruby on Rails ( http://linuxfr.org/redirect/54864.html )
[fr] – Architecture REST ( http://linuxfr.org/redirect/54865.html )
[en] – Blog de Ruby on Rails ( http://linuxfr.org/redirect/54866.html )
[en] – Rails 2 Upgrade Notes ( http://linuxfr.org/redirect/54867.html )
[en] – Summary of Major Rails 2 Features ( http://linuxfr.org/redirect/54868.html )
[fr] – Ruby on Rails sur dmoz ( http://linuxfr.org/redirect/54869.html )

===========================================

Conférence: Ruby et Ruby on Rails Mercredi 19 décembre de 19:30 à 21:45, par Laurent Julliard, à l’ENSIMAG, campus de Saint Martin d’Hères, Amphi E

Résumé: La présentation couvrivra dans un premier temps le langage Ruby. Dans un second temps la conférence s’attardera sur Ruby on Rails, un framework de développement Web 2.0 qui a beaucoup fait parler de lui au cours des deux dernières années. ainsi que les diférents outils et bibliothèques qui l’entourent.

Communication: Merci de nous aider en relayant largement l’annonce de cette conférence. Vous pouvez également imprimer et diffuser l’affiche (PDF). Dans ce cas, vous pouvez vous inscrire sur la page wiki pour coordonner les efforts des « colleurs d’affiche ».

============================================

  • Logiciel Libre/DRM

=============================================
Infos Locales : Le consortium QualiPSo organise la première conférence internationale sur la qualité des Logiciels Libres

 

 

Posté par jcspilmont (display_envoyermessageperso(‘jcspilmont’);). Modéré le vendredi 14 décembre. isadmin (‘23461’)

 

Le consortium QualiPSo organise les 16 et 17 janvier 2008 sa première conférence internationale sur le thème: « Développer la confiance dans les Logiciels Libres ».
Organisée à Rome, la conférence QualiPSo 2008 rassemblera des autorités internationales et des experts de l’Open Source. Elle dévoilera les premiers résultats des recherches menées par le consortium et sera un lieu de débat et d’échange sur les moyens d’accroître et de garantir la confiance dans les Logiciels Libres.

Les défis de l’Open Source seront traités au travers de trois angles complémentaires: politique, économique et technologique :

  • Les stratégies et les modèles de business dans l’Open Source
  • Les questions légales et de propriété intellectuelle
  • La confiance dans les Logiciels Libres et leurs processus de développement
  • L’interopérabilité des Logiciels Libres
  • Les réseaux de compétence sur les Logiciels Libres
  • Les forges logicielles de nouvelle génération.

> Lire la dépêche (2 commentaires, moyenne: 2).

============================================

Livre: Le guide pratique d’usage des logiciels libres dans les administrations
—————————————————————————
Auteur: Nÿco ( https://linuxfr.org/~Nyco/ ) @ 07:47
Thème: Communaute

La DGME publie à destination des administrations « Le guide
pratique d’usage des logiciels libres dans les administrations ». Rédigé
par Thierry Aimé, le document de 18 pages prend la forme d’une FAQ (
http://fr.wikipedia.org/wiki/Foire_aux_questions ) et est publié sous
licence Creative commons « paternité – partage à l’identique » (CC by-sa).

Il répond à diverses questions – notamment juridiques – que les
administrations peuvent se poser lorsqu’il s’agit de mettre en place des
Logiciels Libres :

Le document commence par rappeler ce qu’est un logiciel,
comment fonctionne le mécanisme du droit d’auteur, ce qu’est une licence de
logiciel en général et une licence de logiciel libre en particulier.
Des aspects plus pratiques sont ensuite abordés, comme la façon de trouver
un Logiciel Libre, comment vérifier qu’il s’agit bien d’un Logiciel Libre
en fonction de sa licence, etc.
Par la suite, les problématiques spécifiques aux administrations sont
discutées : le passage de marché public pour une mutualisation sous licence
libre (le principe de payer le développement du logiciel qu’une fois pour
qu’il soit libre), la rédaction de cahier de charges pour demander
l’utilisation de composants libres ou de standards ouverts (
http://fr.wikipedia.org/wiki/Format_ouvert ), le procédé pour reverser un
développement, etc.

[fr] – Le guide pratique d’usage des logiciels libres dans les administrations ( http://linuxfr.org/redirect/54882.html )

|> http://linuxfr.org/2007/12/13/23452.html
=====================================================

o Humeur: Un DVD enDRMerdant, prélude aux ennuis numériques au pied du sapin
—————————————————————————
Auteur: Benoît Sibaud ( http://oumph.free.fr ) @ 11:49
Thème: Audiovisuel

Il y a quelques jours, on m’a offert un DVD de courts-métrages (…)
pour mon anniversaire. (…) Donc je mets ma galette de polycarbonate
recouvert d’une fine couche d’aluminium dans mon lecteur de DVD. (…) Et
là le lecteur multimédia Videolan se lance et… rien.
Ainsi commencent les mésaventures d’un utilisateur de « DVD embrouillé »,
l’occasion de rappeler comment lire un tel support emDRMerdé avec du
logiciel libre via libdvdcss, de rappeler que la loi DADVSI est inappliquée
et inapplicable, de montrer que les DRM sont une stupidité technique, de
regrouper quelques témoignages d’utilisateurs légitimes en colère contre
les industries du cinéma et de la musique…

Bref en cette période d’achats de Noël où un boutiquier du numérique veut
développer le flicage et le filtrage sur internet sans réellement supprimer les verrous numériques, où l’on évoque un projet de loi DADVSI 2 pour 2008 et de nouvelles dispositions en préparation sur la responsabilité des hébergeurs, un petit article d’humeur qui regroupe divers liens et informations pour mieux guider les « consommateurs » (parfois connus sous le nom de citoyens ou spectateurs).

[fr] – Texte « Un DVD enDRMerdant » ( http://linuxfr.org/redirect/54854.html )
[fr] – RMS : Le droit de lire ( http://linuxfr.org/redirect/54855.html )
[fr] – April : DADVSI m’était conté ( http://linuxfr.org/redirect/54856.html )
[fr] – StopDRM : On veut un procès : compte-rendu de l’opération des ( http://linuxfr.org/redirect/54857.html )
[fr] – DLFP : concours contre les DRM ( http://linuxfr.org/redirect/54858.html )
[fr] – DLFP : EUCD/DADVSI : des contrefacteurs partout ? ( http://linuxfr.org/redirect/54859.html )

===============================================

Internet : Quelles libertés défend laCommission Nationale Informatique et Libertés ?

Posté par Nicolas Limare (Jabber id, page perso, display_envoyermessageperso(‘nilamer’);). Modéré le lundi 17 décembre à 12:00. isadmin(‘23462’)

Justice

Alors que les annonces se succèdent dans l’actualité à propos de filtrage d’Internet et de surveillance des communications électroniques, il peut être légitime de s’interroger sur la place de la Commission Nationale Informatique et Libertés dans tout cela.

Crée en 1978 par la loi du 6 janvier 1978, cette instance a été crée après le scandale du premier grand projet de fichage informatique par l’État (SAFARI) en 1974. Financée par l’État, avec des commissaires issus en grande partie du gouvernement, son rôle déjà souvent limité à celui de consultation a été encore plus limité par la récente modification de la Loi Informatique et Liberté.

En effet, en 2004, Alex Türk, actuel président de la CNIL, a rendu cette dernière impuissante face aux fichiers concernant la sûreté d’État (Défense, Sécurité Publique) — ce pour quoi elle avait été initialement créée. Depuis cette légalisation de tous les fichiers de police jusque-là hors la loi, la CNIL a par ailleurs déclaré « compatible avec la liberté » des projets comme les fichiers de prescription des assurés médicaux (AXA en 2004, Groupama et SwissLife en 2005), le passeport biométrique, la biométrie faciale « à des fins de recherche » (février 2007), la pose de mouchards éléctroniques par les compagnie d’assurance dans les véhicules des assurés (septembre 2007).

En plus de ses « avis », la CNIL est censé nous permettre de faire respecter nos droits à la connaissance et à la rectification des données personnelles. Mais avec des délais de consultation allant jusqu’à 2 ans pour les 4,7 millions de fiches du fichier de police STIC et l’explosion générale du nombre de fichiers informatiques nominatifs, ce droit n’existe quasiment plus que sur le papier.

Afin de relancer un nouveau débat, plusieurs collectifs ont décidés de prononcer le matin du 14 décembre la dissolution de la CNIL et ont appelé toute personne souhaitant discuter informatique et liberté à venir au 8 rue Vivienne, à Paris (métro Bourse ou Pyramides).

> Lire la dépêche (12 commentaires, moyenne: 1,7).  

===============================================
o Infos Locales: Les logiciels libres dans le Vercors
—————————————————————————
Auteur: Frederic Ollivier @ 12:44
Thème: Lug

Le Parc Naturel Régional du Vercors organise dans la Salle Communale de
SAINT JULIEN EN QUINT, le 15 Décembre 2007 à 14H avec la participation de la Guilde des Utilisateurs d’Informatique Libre, une séance d’information
sur les Logiciels Libres ainsi que des travaux pratiques.

Participeront également à cette séance qui est gratuite la Commission du
Haut Débit de Saint Julien en Quint et l’Association E-mage. Après un
exposé sur l’intérêt de ces logiciels, il sera répondu aux questions de
l’assistance.

L’accent sera mis Sur les moyens d’ouvrir sous Linux les documents
existants sous d’autres logiciels ;
Sur l’utilisation de passerelles entre les systèmes PC, MAC, LINUX.
Des travaux pratiques auront lieu sur quelques ordinateurs. Il sera
également présenté une solution de virtualisation, virtualbox, pour faire fonctionner sous Linux des logiciels techniques conçus pour fonctionner sous Windows
.

[fr] – GUILDE ( http://linuxfr.org/redirect/54870.html )
[en] – Virtualbox ( http://linuxfr.org/redirect/54871.html )
[fr] – Saint Julien en Quint ( http://linuxfr.org/redirect/54872.html )
[fr] – Annonce sur l’AdL ( http://linuxfr.org/redirect/54877.html )

============================================

  • Le temps réel sous Linux

o Articles: La guerre du temps réel
—————————————————————————
Auteur: patrick_g ( http://patrickguignot.free.fr/ ) @ 10:33
Thème: Linux

Les deux grandes distributions commerciales, Novell et Red Hat, ont
récemment annoncé la sortie d’une version dédiée spécialement au temps réel
( http://en.wikipedia.org/wiki/Real-time_operating_system ) et la
compétition s’annonce âpre dans ce secteur stratégique. Novell a ouvert le
feu le 27 novembre avec SUSE Linux Enterprise Real Time 10 (
http://www.novell.com/news/press/novell-ships-suse-linux-enterprise-real-time-10 ) et Red Hat a immédiatement répliqué le 4 décembre avec Red Hat
Enterprise MRG ( http://www.redhat.com/about/news/prarchive/2007/mrg.html (Messaging, Realtime et Grid Technologies).
)

Cette volonté de ne pas laisser un concurrent en position de monopole sur
ce secteur, même pour une durée infime, s’explique aisément. En effet de
plus en plus les entreprises reposent sur l’automatisation poussée de leurs
processus afin de gagner en réactivité. On se rappelle, lors du sommet
Linux 2007 ( /2007/09/20/23087.html ), le témoignage du représentant du
Crédit Suisse qui indiquait qu’un noyau patché pour le temps réel aidait à
maintenir les profits lors d’une transaction financière.

La prédictibilité des temps de réponse est donc un enjeu crucial et les
distributeurs commerciaux de Linux sont en compétition pour couvrir ce
marché au point, comme nous allons le voir, de déclencher une véritable
guerre des communiqués.

[en] – LWN : La compétition autour du temps réel (http://linuxfr.org/redirect/54860.html )
[en] – Description de la solution Novell ( http://linuxfr.org/redirect/54861.html )
[en] – Description de la solution Red Hat ( http://linuxfr.org/redirect/54862.html
[en] – Les patchs RT du noyau ( http://linuxfr.org/redirect/54863.html )
)

|> http://linuxfr.org/2007/12/13/23447.html

Posted in 2007, GNU/Linux, Guilde, linux, logiciel libre, migration vers le libre, open source, ruby, Temps réel, Web Frameworks, web2.0 | Tagué: , , | Leave a Comment »

Quelques nouvelles de python: Django, Python 3000, Ironpython, Zope/Plone

Posted by patrick sur décembre 17, 2007

Quelques nouvelles du monde python

  • django
  • python 3.0
  • zope/plone
  • ironpython

Django:

http://www.holovaty.com/blog/archive/2007/12/12/1311(« It’s here! At long last, the print copy of the Django Book has shipped. I received my author copies late last week and am still poking at them to make sure that, yes, a tangible book with my name on the cover has actually been printed, on real paper, by a real publisher. Now that the Django Book is finally in the can, I’m mulling the idea of writing another book — this time, a book about online journalism. In the past two years, I’ve been to (way too) many journalism-related events and conferences trying to spread the good word about « journalism via computer programming, » and I’ve detected a strong, I daresay furious, demand, from journalists at all levels in the org chart, for information about this new form of journalism. Higher-ups want to know why I want to take a shot at writing a manual, a manifesto, a practical guidebook to this emerging discipline of database-driven Web journalism. It would be a combination of high-level strategy and low-level technique, probably split cleanly into two parts (one for the suits, one for the non-suits) they should employ programmers; middle managers want to know how to find them and how to treat them; and working journalists want to learn these skills and strategies. The problem is that I can’t point them anywhere for in-depth information. This book would attempt to solve that. . »)

Python 3.0

  • http://www.artima.com/weblogs/viewpost.jsp?thread=220341 (« This is just a quick post to let everyone know that Python 3.0a2 is released as of 10:30am PST (18:30 UTC) today (Friday December 7, 2007). I’m grateful to the many people who have contributed to this release, in particular new core developers Christian Heimes and Amaury Forgeot d’Arc.GHOP contestants who contributed documentation updates, and to Georg Brandl for collecting these and submitting them to Subversion. There are still many more tasks available! However, I do want to mention that based upon the feedback for 3.0a1, we’ve decided to make the ‘bytes’ type immutable, and create a separate mutable bytes type, ‘bytearray‘. These two types are mutually compatible, but in the majority of cases you’ll be using bytes, not bytearray. I should also note that we’ve run into an issue with the Windows installers — see the release page above. If anyone can help this, please write to python-dev at python.org. (The script that creates the installer is in the distribution as Tools/msi/msi.py.) And finally, a word of thanks to all the participants « )
  • http://simonwillison.net/2007/Dec/16/chapter/ (« Chapter 7: Form Processing. The chapter on newforms I contributed to “The Definitive Guide to Django” is now online, along with the rest of the published book. »)
  • http://www.lethain.com/entry/2007/dec/04/two-faced-django-part-1-building-project-exists-si/ (« This series of articles aims, in the clear step-by-step style of the Django tutorial, to take you through the process of building a Django application that exists as both a simple web application, and also as a Facebook application. The web and Facebook applications will store information in the same database, using the same models, and thus users of one interface will be able to interact with the other.« )
  • http://simonwillison.net/tags/python/ : un excellent recueil de nouvelles sur Django

Zope, plone
http://encolpe.wordpress.com/2007/12/02/archgenxml-et-le-futur-de-la-generation-de-code-sous-zopeplone/ (« ArchGenXML et le futur de la génération de code sous Zope/Plone. Cela faisait un bon moment que je n’avais pas écrit un billet ici… et pour cause: on temps libre est principalement occupé par le développement et les tests de la version 2.0 de ArchGenXML. Contrairement à la version 1.5 qui ciblait Plone 2.1avec une compatibilité Plone 2.5 cette version est construite autour du support de Plone 3.0 avec une compatibilité vers Plone 2.5…Les buts atteints de cette version sont le passage en egg de ce module, le support des profils Generic Setup , la génération des interfaces Zope3, la génération des tests unitaires et des tests fonctionnels en python et au format doctest. Des gros changement en perspective, et une incompatibilité avec la génération précédente. Nous restons bloqués en phase d’évaluation béta par manque testeurs. Nous cherchons en particulier des testeurs pour la partie génération de workflows…Du coté du futur de la génération de code, ArchGenXML génère déjà du code Zope 3 (pour son utilisaton dans Plone) et d’autres projets de CMS en python commencent à s’intéresser à cette possibilité (voir la branche Django)…L’autre nouveauté, plus contraignante celle-ci, est l’utilisation de nouveaux connecteurs dans les schémas UML pour symboliser les ‘adapter’. Les versions précédentes d’ArchGenXML se satisfaisaient d’éditeurs utilisant UML 1.4 et il faut à présent des éditeurs utilisant UML 2.0 au minimum pour cette nouvelle fonctionnalité. Exit donc les éditeurs tel que ArgoUML qui était le seul éditeur UML libre supportéPour l’instant nous allons continuer d’utiliser ArgoUML et Poseidon pour le développement des fonctionnalités d’ArchGenXML. En un mois j’ai testé umbrello, gaphor, Apollo pour eclipse et Papyrus. Papyrus est vraiment très intéressant et est développé au CEA. Mais cela reste une extension d’eclipse donc il faut faire du Java pour générer du Python… c’est un peu dommage.« )

Ironpython

http://www.voidspace.org.uk/python/weblog/arch_d7_2007_12_08.shtml#e899 (« the last few days I’ve been off work trying to get a chapter on Windows Presentation Foundation finished. I haven’t got as much of the writing as I would have liked done, but I have finished the research and completed two of the three examples. WPF is great for creating funky user interfaces, and comes with some great controls. Despite the emphasis on XAML it is also easy to use from code…More importantly, two more chapters of IronPython in Action are available in the Manning Early Access Program. I’m pretty proud of these chapters. Chapter 7 is on testing with IronPython (including functionally testing a GUI application) and chapter 8 is about deeper aspects of Python and interacting with the .NET framework. The information in section 8.4 is vital to any non-trivial interaction with .NET so I’m glad it has gone liveWPF FlowDocuments are cool by the way, very high level document viewing controls for very little effort – but another new markup to learn (a subset of XAML) to use them« )

http://www.voidspace.org.uk/python/weblog/arch_d7_2007_12_08.shtml#e898 (…My talk is Python in your Browser with IronPython & Silverlight, the second one on the list!

Silverlight is a new browser plugin from Microsoft. It is intended for media streaming, games and rich internet applications. It is cross-platform and cross-browser and comes with a rich programmers API.

Through the Dynamic Language Runtime, Silverlight is fully programmable with IronPython – meaning that at last client side web applications can be written fully in Python. This talk will explore some of the things that you can do with IronPython in the browser.

This includes making web apps run faster, writing ‘rich’ applications (or games), and embedding a Python interpreter into web pages for tutorials and documentation.

It is a good year for IronPython talks (and so it should be). As well as my talk there are:

  • IronPython: The Road Ahead (48 – Jim Hugunin)
  • End-user computing without tears using Resolver, an IronPython spreadsheet (65 – Giles Thomas – the Resolver boss!)
  • Using .NET Libraries in CPython (103 – Mr. Feihong Hsu – a talk on Python.NET which definitely deserves more attention and is related to IronPython)

There is also a talk by another Resolver developer (not on IronPython though):

  • Getting started with test-driven development (5 – Jonathan Hartley)

It should be a great conference. Smile« )

http://www.resolverhacks.net/ ( » Resolver is a powerful tool for collecting, handling and analysing ‘business data’. It inhabits the space somewhere between a traditional spreadsheet and a Rapid Application Development tool. With Resolver you can use the familiar spreadsheet interface to create applications, build powerful spreadsheets pulling in data from databases and financial data-streams, or implement business logic to be integrated into other IT systems. Its power and flexibility comes from the fact that it is fully programmable with Python code, using the .NET framework. This means that you can use just about any .NET or Python library within your spreadsheets. You can also easily develop libraries of functions and classes to be shared between your spreadsheets. Spreadsheets can be exported as code, enabling you to re-use business logic with other Python or .NET applications.Resolver has a few other novel features, like shared worksheets which can be editted simultaneously by multiple users on different machines. We’re sure that new and innovative uses for Resolver will develop, and hopefully this website will help uncover some of them! Resolver can import and export data from Excel, and there are interesting tricks for communicating with or even driving Excel. You can also reference cells inside an Excel spreadsheet from a Resolver spreadsheet.For a longer overview of the features of Resolver, read Resolver: What and Why?. »)

http://www.voidspace.org.uk/python/weblog/arch_d7_2007_12_08.shtml#e897 (« The version released was 1.0 beta 4. This includes quite a few major changes since I last updated you about progress with Resolver. One of the major changes was that we made the API for working with spreadsheet objects simpler from user code. This was a lot of work, but I think it was worth it. The very worst side effect was that it broke most of my examples on the Resolver Hacks website. Today I have finally got around to updating it and putting new screenshots in (Resolver got prettier):

There are around thirty pages of articles and examples to get you going with Resolver. Some of the most useful ones are:

http://www.ironpython.info/index.php/Main_Page (« This wiki contains recipes and example code for IronPython. IronPython is a Microsoft port of the Python Programming Language to the .NET framework.

Python is a dynamic language, used for a wide variety of purposes, with an emphasis on clean and expressive code. It allows the maximum flexibility for the developer, whilst maintaining readability of code.« )

http://www.manning.com/foord/ («  IronPython in Action offers a comprehensive, hands-on introduction to Microsoft’s exciting new approach for programming the .NET framework. It approaches IronPython as a first class .NET language, fully integrated with the .NET environment, Visual Studio, and even the open-source Mono implementation. You’ll learn how IronPython can be embedded as a ready-made scripting language into C# and VB.NET programs, used for writing full applications or for web development with ASP. Even better, you’ll see how IronPython works in Silverlight for client-side web programming. IronPython opens up exciting new possibilities. Because it’s a dynamic language, it permits programming paradigms not easily available in VB and C#. In this book, authors Michael Foord and Christian Muirhead explore the world of functional programming, live introspection, dynamic typing and ‘duck typing’, metaprogramming, and more. IronPython in Action explores these topics with examples, making use of the Python interactive console to explore the .NET framework with live objects. The expert authors provide a complete introduction for programmers to both the Python language and the power of the .NET framework. The book also shows how to extend IronPython with C#, extending C# and VB.NET applications with Python, using IronPython with .NET 3.0 and Powershell, IronPython as a Windows scripting tool, and much more.« )

http://ironpython-urls.blogspot.com/2007/12/mono-boo-python-gnome-ironpython.html (« Mono, Boo, Python, Gnome & IronPython. Miguel de Icaza has a blog entry responding to an article on ‘Mono Usage in the Enterprise’:

It has some interesting comments on the role of Python in the Gnome project and IronPython and Boo on Mono: Python is indeed making great strides as a desktop development platform and am not sure that we are in the business of competing with it. If people like writing Python code, they should just keep writing python code. Myself, I like the IronPython variation of Python more. IronPython just happens to be JITed Python and in most tests it is faster than CPython. For the past year or so, we have also been in love with Boo, another .NET language. Boo has support for strong typing, so for certain scenarios you will get even better performing code (basically, when you can determine the type of a variable ahead of time, instead of having the variable be entierly late bound).« )


Produits, bibliothèques Python

http://wiki.secondlife.com/wiki/Eventlet (« Eventlet is a networking library written in Python. It achieves high scalability by using non-blocking io while at the same time retaining high programmer usability by using coroutines to make the non-blocking io operations appear blocking at the source code level.

Eventlet runs on Python version 2.3 or greater, with the following dependenceis:

  • greenlet
  • (if running python versions < 2.4) a deque object in a collections module. One option is to copy this deque into a file called collections.py.


Eventlet began life as Donovan Preston was talking to Bob Ippolito about coroutine-based non-blocking networking frameworks in Python. Most non-blocking frameworks require you to run the « main loop » in order to perform all network operations, but Donovan wondered if a library written using a trampolining style could get away with transparently running the main loop any time i/o was required, stopping the main loop once no more i/o was scheduled. Bob spent a few days during PyCon 2005 writing a proof-of-concept. He named it eventlet, after the coroutine implementation it used, greenlet. Donovan began using eventlet as a light-weight network library for his spare-time project Pavel, and also began writing some unittests.

When Donovan started at Linden Lab in May of 2006, he added eventlet as an svn external in the indra/lib/python directory, to be a dependency of the yet-to-be-named backbone project (at the time, it was named restserv). However, including eventlet as an svn external meant that any time the externally hosted project had hosting issues, Linden developers were not able to perform svn updates. Thus, the eventlet source was imported into the linden source tree at the same location, and became a fork. Bob Ippolito has ceased working on eventlet and has stated his desire for Linden to take it’s fork forward to the open source world as « the » eventlet.« )

http://www.artima.com/weblogs/viewpost.jsp?thread=217546 (« The Python Quick Reference has been the most excellent resource for many years, because it gives you an overview of the entire language and usually allows you to quickly find the solution you’re looking for. If it doesn’t, it has links directly into the Python documentation. Just so Richard Gruet and the others who work on the PQR know, you have lots of fans out there. Thanks for all your work…Before you fire up your comments, I continue to root for Ruby. I think it’s great that Sun is directly supporting it as the scripting language for the JVM (as far as I know none of the other languages are actually getting financial support). I am also attracted to the more dynamic features of the language like open classes and the like. As far as dynamic languages on the JVM, both Ruby and the upcoming new version of Jython seem to me to be the most attractive of the offerings.But to make Ruby easier, I suggest that Rubyists study from and plagiarize the PQR, and also learn from the « batteries included » approach in the Python standard libraries. Both of these are things that keep me going back to Python« )

Posted in 2007, DotNet, Ironpython, python, RAD, RIA, Web applications | Tagué: , | Leave a Comment »

Connexion entre composants Java et DotNet: Ikvm, boo, java, .NET, ironpython

Posted by patrick sur décembre 15, 2007

Source: http://ironpython-urls.blogspot.com/2007/11/boo-java-net-and-ironpython.html

————————————————-<————————————

Thursday, November 15, 2007

Boo, Java, .NET and IronPython

A blogger called Tomo wondered about which .NET language to choose Boo (a mighty fine language) or IronPython. He came down in favour of Boo, and an interesting discussion ensued in the comments:

The very next thing he tried was taking the Java class library for SWT (the user interface library) and compiled them into a .NET dll with IKVM. He then used them from Boo and IronPython, which worked!

This is an interesting coincidence, as a few days ago Rodrigo announced on the Boo blog about boojay – a compiler that emits Java bytecode from Boo:

————————————————-8<———————————————

Source: http://blogs.codehaus.org/people/bamboo/archives/001623_introducing_boojay.html
(« A boo application using the SWT java GUI library. Thanks to IKVM that’s not only possible but very simple as well. So what’s the news? Well, Friday morning I was chatting with Klaus and he said to me « if you get boo to emit java bytecodes I’ll do all my stuff in boo ». How’s that for a challenge? 🙂 Thanks again to IKVM, ObjectWeb ASM and the extensible boo pipeline architecture boojay was born after a weekend of relaxed hacking « )

http://boo-extensions.googlecode.com/svn/trunk/boojay/ (« boojay is an attempt at getting the boo compiler to emit java bytecode. Architecture
Thanks to the amazing IKVM project it is possible to use the great ObjectWeb ASM library from boo running on mono/ms.net to emit native java bytecodes that can be executed by any compliant java virtual machine
« )

http://koans.tomo-online.com/2007/11/15/langage-frenzy/ (« Although I should be doing something else, Boo, IronPython and .NET kept occupying my mind. So I made a small coding experiment. First, I downloaded IKVM. Then – SWT. I compiled SWT jar to a dll. No problems here. Then I wrote a SWT hello world in IronPython. To be honest – I took a Java one from SWT website and rewrote line by line. I was surprised that my hello world ran without a glich! Next, I copied a HelloWorldSWT.py into HelloWorldSWT.boo and changed the import statement. Compiled (”By golly! No problems? No warnings?”) and run. And no problems again?? It started to look suspicious… Java run on .NET, calls from Java to native library, two different languages… and everything without a single warning? So I decided to take it to foreign territory… Ubuntu! I fired up a VMWare image with Ubuntu 6.10 (the linux vm I have handy), downloaded Linux SWT, compiled it to dll, copied HelloWorldSWT.exe from Windows along with some ikvm dlls and… no problems again! I’m really, really surprised how smooth the experiment was. Thumbs up! « )

http://en.wikipedia.org/wiki/IKVM (« IKVM.NET is an implementation of Java for Mono and the Microsoft .NET Framework. IKVM is free software, distributed under a permissive free software licence. IKVM includes the following components: for

  • A Java Virtual Machine implemented in .NET
  • A .NET implementation of the Java class libraries
  • Tools that enable Java and .NET interoperability

With IKVM you can run compiled Java code (bytecode) directly on Microsoft .NET or Mono. The bytecode is converted on the fly to CIL and executed. Jeroen Frijters is the main contributor to IKVM.NET. He is Technical Director of Sumatra Software, based in The Netherlands. As of June 2007, the machine supports Java 1.6 with the exception of AWT and Swing. IKVM uses OpenJDK as its class library. »)

http://www.ikvm.net/ (« ..The following projects are related to IKVM.NET in some way:

http://www.eclipse.org/swt/ (« SWT is an open source widget toolkit for Java designed to provide efficient, portable access to the user-interface facilities of the operating systems on which it is implemented.« )

http://www.gnu.org/software/classpath/classpath.html (« GNU Classpath, Essential Libraries for Java, is a GNU project to create free core class libraries for use with virtual machines and compilers for the java programming language. Classpath is still a work in progress. The first public release will be version 1.0. There have been no public releases; however, pre-release source code is available via GNU’s anonymous CVS server , and snapshots of the Classpath tree have been released and are available from ftp://ftp.gnu.org/gnu/classpath/« )

http://en.wikipedia.org/wiki/GNU_Classpath (« GNU Classpath is a project aiming to create a free software implementation of the standard class libraryJava programming language. Despite the massive size of the library to be created, the majority of the task is already done, including Swing, CORBA, and other major parts. The Classpath developers have implemented almost all of the classes from J2SE 1.4 and 5.0. Classpath can thus be used to run popular Java-based software such as Azureus and Eclipse. It is a part of the Free Software Foundation‘s GNU project and was launched so that computer users could use Java programs without giving up the freedoms which the free software movement works to secure. GNU Classpath was originally developed in parallel with libgcj due to license incompatibilities, but later merged...Since version 0.95, Java 1.5 additions like generics have been fully integrated into the main branch. The branch allows GCJ to use Eclipse compiler, ecj, to compile Java 1.5 source code to bytecode, which is then changed into native code by GCJ itself« )

http://en.wikipedia.org/wiki/Boo_programming_language (« Boo is an object oriented, statically typed programming language developed starting in 2003, which seeks to make use of the Common Language Infrastructure support for Unicode, internationalization and web style applications, while using a Python-inspired syntax and a special focus on language and compiler extensibility. Some features of note include type inference, generators, multimethods, optional duck typing, macros, true closures, currying, and first class functions. Boo is open sourcelicensed under an MIT/BSD style license.Boo can be used with Microsoft .NET or Mono. »)

https://pvergain.wordpress.com/2007/08/17/grasshopper-faire-tourner-des-applications-aspnet-sur-des-serveurs-j2ee/
(« Grasshopper 2.0 enables you to produce .NET Web and server applications that run on Linux & other Java-enabled platforms using ASP.NET 2.0 controls, role-based security, and C# generics. Check out our developer blogs, interop forums, code samples, and how-to articles to learn how« )

– http://blog.mainsoft.com/blog/net-java-interop-8-links-to-get-you-started/(« 

Posted in 2007, ASP.NET, Développement logiciel, DotNet, FSF, IDE-GUI, Ironpython, J2EE, java, JEE, python | Tagué: , , , | Leave a Comment »

Les nouveautés dans ASP.NET Extensions: ASP.NET MVC et ASP.NET AJAX

Posted by patrick sur décembre 15, 2007

Comme le précise ce billet http://dosimple.ch/articles/MVC-ASP.NET/ écrit le 2 mai 2006 et celui-ci écrit le 13 mars 2007, le framework ASP.NET n’incite pas particulièrement à la séparation stricte de type Modèle, Vue, Contrôleur. On a vu que Monorail, projet open source, implémente le modèle MVC. Microsoft emboite le pas avec un grand retard en introduisant ASP.NET MVC: voir le billet suivant: http://weblogs.asp.net/scottgu/archive/2007/10/14/asp-net-mvc-framework.aspx (« One of the things that many people have asked for over the years with ASP.NET is built-in support for developing web applications using a model-view-controller (MVC) based architecture. Last weekend at the Alt.NET conference in Austin I gave the first public demonstration of a new ASP.NET MVC framework that my team has been working on. You can watch a video of my presentation about it on Scott Hanselman’s blog here.

What is a Model View Controller (MVC) Framework?

MVC is a framework methodology that divides an application’s implementation into three component roles: models, views, and controllers.

  • « Models » in a MVC based application are the components of the application that are responsible for maintaining state. Often this state is persisted inside a database (for example: we might have a Product class that is used to represent order data from the Products table inside SQL).

  • « Views » in a MVC based application are the components responsible for displaying the application’s user interface. Typically this UI is created off of the model data (for example: we might create an Product « Edit » view that surfaces textboxes, dropdowns and checkboxes based on the current state of a Product object).

  • « Controllers » in a MVC based application are the components responsible for handling end user interaction, manipulating the model, and ultimately choosing a view to render to display UI. In a MVC application the view is only about displaying information – it is the controller that handles and responds to user input and interaction.

One of the benefits of using a MVC methodology is that it helps enforce a clean separation of concerns between the models, views and controllers within an application. Maintaining a clean separation of concerns makes the testing of applications much easier, since the contract between different application components are more clearly defined and articulated.

The MVC pattern can also help enable red/green test driven development (TDD) – where you implement automated unit tests, which define and verify the requirements of new code, first before you actually write the code itself.

A few quick details about the ASP.NET MVC Framework

I’ll be doing some in-depth tutorial posts about the new ASP.NET MVC framework in a few weeks once the bits are available for download (in the meantime the best way to learn more is to watch the video of my Alt.net presentation).

A few quick details to share in the meantime about the ASP.NET MVC framework:

  • It enables clean separation of concerns, testability, and TDD by default. All core contracts within the MVC framework are interface based and easily mockable (it includes interface based IHttpRequest/IHttpResponse intrinsics). You can unit test the application without having to run the Controllers within an ASP.NET process (making unit testing fast). You can use any unit testing framework you want to-do this testing (including NUnit, MBUnit, MS Test, etc).

  • It is highly extensible and pluggable. Everything in the MVC framework is designed so that it can be easily replaced/customized (for example: you can optionally plug-in your own view engine, routing policy, parameter serialization, etc). It also supports using existing dependency injection and IOC container models (Windsor, Spring.Net, NHibernate, etc).

  • It includes a very powerful URL mapping component that enables you to build applications with clean URLs. URLs do not need to have extensions within them, and are designed to easily support SEO and REST-friendly naming patterns. For example, I could easily map the /products/edit/4 URL to the « Edit » action of the ProductsController class in my project above, or map the /Blogs/scottgu/10-10-2007/SomeTopic/ URL to a « DisplayPost » action of a BlogEngineController class.

  • The MVC framework supports using the existing ASP.NET .ASPX, .ASCX, and .Master markup files as « view templates » (meaning you can easily use existing ASP.NET features like nested master pages, <%= %> snippets, declarative server controls, templates, data-binding, localization, etc). It does not, however, use the existing post-back model for interactions back to the server. Instead, you’ll route all end-user interactions to a Controller class instead – which helps ensure clean separation of concerns and testability (it also means no viewstate or page lifecycle with MVC based views).

  • The ASP.NET MVC framework fully supports existing ASP.NET features like forms/windows authentication, URL authorization, membership/roles, output and data caching, session/profile state management, health monitoring, configuration system, the provider architecture, etc. »)

A voir:

  • https://pvergain.wordpress.com/2007/03/13/critique-de-larchitecture-aspnet/ (« Le problème avec ASP. Net est qu’il n’y a qu’un objet qui traite les demandes http, c’est l’objet PAGE. C’est lui qui a le contrôle de tout, et donc il mélange le code dit de «contrôle», et le code qui pilote la «visualisation» des éléments en html. Et bien souvent, on mélange aussi le code qui pilote le «Modèle» c’est à dire l’obtention des données directement depuis la base de données avec Ado.Net (c’est ce qu’on obtient lorsqu’on fait du WYSIWYG dans Visual Studio en choisissant les Sql Data Source et les glissant-déposant sur l’ihm). Cet anti-modèle (ou anti–pattern) a été souvent pointé du doigt par les architectes et développeurs, car en plus de faire produire du code spaghetti (bien que orienté objet), il rend impossible les tests systématisés (automatisés).« )
  • http://dosimple.ch/articles/MVC-ASP.NET/ (« Dans le framework ASP.NET la vue est un fichier HTML agrémenté de balises ASP. Le contrôleur et le modèle sont en général mélangés dans un objet qui dérive de la classe System.Web.UI.Page. »)
  • http://www.castleproject.org/monorail/index.html (« MonoRail is a MVC Web Framework inspired by Action Pack. MonoRail differs from the standard WebForms way of development as it enforces separation of concerns; controllers just handle application flow, models represent the data, and the view is just concerned about presentation logic. Consequently, you write less code and end up with a more maintainable application. Although the project name is MonoRail, we do not have any affiliation with the Mono project. MonoRail runs on Microsoft .Net 1.1, 2.0 and Mono.« )
  • http://en.wikipedia.org/wiki/ASP.NET_MVC_Framework (« ASP.NET MVC Framework is a Model-view-controller framework which Microsoft is adding to ASP.NET. It allows an application to be built as a composition of three roles: Model, View and Controller. A Model represents the state of a particular aspect in the application. Frequently, a model maps to a database table, with the entries in the table representing the state of the table. A Controller handles interactions and updates the model to reflect a change in state of the application. A View ASP.NET MVC Framework couples the models, views and controllers using interface-based contracts, thereby allowing each component to be easily tested independently. The view engine in the MVC framework uses regular .aspx pages to design the layout of the UI pages onto which the data is composed; however any interactions are routed to the controllers rather than using the postback mechanism. Views can be mapped to REST-friendly URLs. ASP.NET MVC Framework has been launched as a Community Technology Preview on December 10, 2007 extracts necessary information from a model and renders a UI to display that.. »)
  • http://www.hanselman.com/blog/ScottGuMVCPresentationAndScottHaScreencastFromALTNETConference.aspx ( » I attended the ALT.NET Conference last weekend in Austin, TX. I personally find the name « Alt » as in « Alternative » too polarizing and prefer terms like « Pragmatic.NET » or « Agile.NET. » At the conference I suggested, partially in jest, that we call it « NIH.NET » as in « Not Invented Here.NET. » 😉 Ultimately this is a group that believes in:
    • Continuous Learning
    • Being Open to Open Source Solutions
    • Challenging the Status Quo
    • Good Software Practices
    • DRY (Don’t Repeat Yourself)
    • Common Sense when possible.

    ScottGu gave an hour long presentation on the upcoming MVC Framework and I took some guerilla video. ScottGu’s presentation is here in Silverlight and it’s about 60 minutes long. Considering it’s so long, the video squished nicely. This was the first time the MVC Framework was shown publicly. Note that this was a Prototype, not the Production code and both ScottGu and I make that point a number of times to drive home that it’s early. Some of the code was written on a plane, just to give you an idea. After The Gu did his piece on the MVC Framework, I showed some prototype hacking that I’d done over the previous few days along with some work Phil Haack did. My presentation is here as Silverlight and it’s about 30 minutes long. I showed the Model View Controller with Controllers in IronPython and an IronPython view using a WebFormViewEngine. Then I talked about the possibilities of alternate ViewEngines and showed Phil Haack’s prototype RubyViewEngine. »)

  • http://weblogs.asp.net/scottgu/archive/2007/11/13/asp-net-mvc-framework-part-1.aspx ( » ASP.NET MVC Framework (Part 1) I’m going to use a simple e-commerce store application to help illustrate how the ASP.NET MVC Framework works. For today’s post I’ll be implementing a product listing/browsing scenario in it. Specifically, we are going to build a store-front that enables end-users to browse a list of product categories when they visit the /Products/Categories URL on the site>>Since it adds a testing project, does this require Team System? No – the good news is that Test Projects with VS 2008 are now supported with the VS 2008 Professional edition – and no longer require team system. You will also be able to use the VS Express and Standard edition products as well, and then use NUnit, MBUnit or some other testing framework with them (we’ll ship project templates for these as well…>> 2. Is it also possible to have this URL mapped: /Products/Beverages/3 instead of /Products/Beverages?page=3 or does it _need_ the parameter name? Yes – this is totally supported. Just set a route rule for /Products/Beverages with the format /Products/<Category>/<Page> – they’ll then get passed in as arguments to the action method:public List(string category, int? page) {}>>Also, some ideas and general remarks: 1. I’d love to see more helper methods for use in the views, I like how Ruby on Rails has many shortcuts for creating forms and formfields etc. Yes – we’ll have a rich library of helper methods for the views. They’ll include helpers to create all the standard forms, formfields and more.

>>2. Migrations! Not a part of MVC but from my experience with Ruby on Rails I would love to see support for this somewhere, anywhere! It would fit perfectly with the more agile way of developing that is possible with ASP.NET MVC. Rob Conery is building .NET Migrations support as part of the SubSonic project, and recently joined Microsoft. You’ll be able to use this with ASP.NET MVC

>>I’m also very keen to get my hands on the CTP. Scott, you mention, using Inversion of Control containers with the MVC framework. I’d be very interested in seeing a blog post on this subject. Also, will there be a sample application (with tests and IoC) available alonside the CTP? We have a IControllerFactory extensiblity point that owns creating Controller instances. You can use this with a IOC container to customize any Controller instance prior to it being called by the MVC framework. We’ll be posting samples of how to use this with ObjectBuilder and Windsor with the first CTP I believe

>> Very cool! One thing I’d like to see guidance on is developing MVC apps with multiple UIs. You say here that it’s best to put your models and controllers in the web app, but say we want a Winforms, WPF, Silverlight, and Web UI all doing similar things. Or a Mobile Web UI and Desktop Web UI… Would these still each need their own Models and Controllers, or does it make sense to have one library that they all share? If so, how is that supported? I’m still new to MVC, so if I’m missing something conceptually here, tell me! That is a good question, and one we’ll need to provide more guidance on in the future. In general it is often hard to share the same controller across both client and web UI, since the way you do data access and the stateful/stateless boundaries end up being very different. It is possible – but some guidance here would ceretainly be useful. My team should hopefully be coming out with this in the future

>>I really appreciate this material. Do you support the MVC pattern over the MVP pattern? Or are there just better scenarios for using each? The above approach I showed uses a MVC based pattern – where the Controller and the View tend to be more separate and more loosly coupled. In a MVP pattern you typically drive the UI via interfaces. This works well with a controls model, and makes a lot of sense with both WinForms and WebForms where you are using a postback model. Both MVC and MVP are perfectly fine approaches to use. We are coming out with the MVC approach for ASP.NET partly because we’ve seen more demand for it recently for web scenarios…

>> When can we expect a similar chapter with SubSonic as the DAL and scaffolding provider? (see http://oakleafblog.blogspot.com/2007/11subsonic-will-be-toolset-for-microsofts.html I’ll be covering scaffolding in a future blog post. LINQ to SQL scaffolding is built-in with ASP.NET MVC and doesn’t require SubSonic. SubSonic will also obviously be adding new ASP.NET MVC features as well.

>> My applications in .NET works with « 3 layers » pattern (business logic and data access in your own dll). How can i use this wonderfull MVC with my Models (data access) and Controllers (B.Logic)?? Because if i’m not reuse this, i’ve repeat code in every layer; then this MVC is not DRY (don’t repeat yourself) and the community don’t accept. There is no need to put your business and data logic in the same assembly as your controllers. You can split them up across multiple class library projects if you prefer

>> Does this mean that with MVC, we no longer use LinqDatasource in the View section? While the LinqDataSource control will technically work in MVC Views, if you are using a MVC model you wouldn’t want to place it there. Instead you want to perform all of your data and application logic in the Controller layer – and then pass the needed data to the view.

>> Perhaps I missed it somehow, but can you explain on which version of asp.net will this ctp run? The MVC framework builds on top of .NET 3.5

>> Scott, this is amazing timing! The URL mapping features inherit in an MVC application are PERFECT for the upgrade to ASP.NET 3.5 I’m making to my spelldamage.com site. Hosting question, will hosts simply need to support the ASP.NET 3.5 framework to allow us to run ASP.NET MVC applications? Your hoster will need to support .NET 3.5 for the MVC support.

>> Is’nt the MVC framework, in fact the Controller, implementation of the Front Controller pattern? Yes – the ASP.NET MVC framework uses a front-controller pattern. »)

  • http://weblogs.asp.net/scottgu/archive/2007/12/03/asp-net-mvc-framework-part-2-url-routing.aspx (« Last month I blogged the first in a series of posts I’m going to write that cover the new ASP.NET MVC Framework we are working on. The first post in this series built a simple e-commerce product listing/browsing scenario. It covered the high-level concepts behind MVC, and demonstrated how to create a new ASP.NET MVC project from scratch to implement and test this e-commerce product listing functionality. In today’s blog post I’m going to drill deeper into the routing architecture of the ASP.NET MVC Framework, and discuss some of the cool ways you can use it for more advanced scenarios in your application… What does the ASP.NET MVC URL Routing System do? The ASP.NET MVC framework includes a flexible URL routing system that enables you to define URL mapping rules within your applications. The routing system has two main purposes:
    • Map incoming URLs to the application and route them so that the right Controller and Action method executes to process them
    • Construct outgoing URLs that can be used to call back to Controllers/Actions (for example: form posts, <a href= » »> links, and AJAX calls)

Having the ability to use URL mapping rules to handle both incoming and outgoing URL scenarios adds a lot of flexibility to application code. It means that if we want to later change the URL structure of our application (for example: rename /Products to /Catalog), we could do so by modifying one set of mapping rules at the application level – and not require changing any code within our Controllers or View templates.

>> BTW, can you explain in short about the Active Record Type support in our MVC.

.NET 3.5 has LINQ to SQL built-in – which is a great ORM. LINQ to Entities will also be built-into .NET 3.5 in the future (it also ships with the MVC setup). The MVC framework doesn’t require LINQ to SQL or LINQ to Entities as the data model – it also works with NHibernate, LLBLGen, SubSonic, DataSets, DataReaders, and/or any other data model with .NET. We will, though, provide out of the box scaffolding support for LINQ to SQL and LINQ to Entities that delivers nice integration with the MVC support.

>> Question : What is this MockHttpContext in the UnitTest class? I mean, i can guess what it is .. but is it new in .NET 3.5 or the MVC framework? The MockHttpContext is an example mock object. It isn’t currently built-in with the MVC framework (with the first preview you’d need to create this yourself). I’m hoping that before the MVC framework ships, though, that there are a built-in set of mock objects and test helpers that you can use out of the box (without having to mock them yourself). Note that all core contracts and types with the MVC framework are mockable (non-sealed and interfaces). So you can also use any existing Mock framework to test it (RhinoMocks, TypeMock, etc).

>> 1) Is it possible to use routes with a file extension if I don’t want to enable wildcard script mappings? For example, /Products/List/Beverages.rails or /Products/Detail/34.rails ? Yes – this is fully supported. We recommend changing your route rule to /[controller].mvc/[action]/[id]. When you install the ASP.NET MVC Framework we automatically register this .mvc extension – although you are free to use any other one you want.

>> Hypothetically, do you think it would be possible to customise the route creation process so that route data could be gathered from attributes on actions? We don’t currently support this built-in, but hypothetically you could load all the controllers at app-startup and use reflection on them to calculate the route rules. This would enable the scenario you are after.

>> Is it possible to use IronRuby as the coding language to target the MVC framework?? Yes – we’ll support both IronRuby and IronPython with the ASP.NET MVC Framework.

>> I am liking this more and more. I can see how the routing configuration code in global.asax.cs could become quite large. In my application, I can see dozens, maybe hundreds of unique routing rules. Is there any way this configuration can be put in a file somewhere? That file would be read on Application start. Seems like that would make deployment of routing changes easier, too. We don’t currently have a pre-built file format for reading in mapping rules. But it should be relatively easy to build (you could even use LINQ to XML to read in and construct the rules).

>> Just out of curiosity where in the HttpApplication cycle are the routing rules evaluated and are they exposed in any way to the rest of the HttpApplication cycle? My current security system grants permissions at what would become the controller-action level so if the route determination is made early enough I’d really like to drive my authorization off of it.
The routing rules are resolved after the OnPostMapRequestRequestHandler event. This means that it will happen *after* your authorization rules evaluate. The good news is that this means you should be able to re-use your existing security system as-is.

>> Will there be any way to use an XML document to create the routing rules outside of the Global.asax code? Yep – this scenario will be supported.

>> I noticed that in Django, you have to repeat yourself kind of often when you have a deep nested hierarchy of pages. Your search & search-results pages seem to be continuing that trend. I’m sure I could come up with some hierarchical data structure which can be serialized into Route objects, but is the ASP.NET team planning anything along those lines that would come stock?

With our first preview the Route type is not extensible (you can’t subclass it) – which means you sometimes need to register multiple routes for a series of things. For the next preview we are looking at enabling Route to be sub-classed – in which case you could easily encapsulate multiple URL mappings into a single registration.

>> Have you thought about being able to define a regular expression for url matching and using backreferences or named captures as the tokenized url? I think this would allow for much more flexibility while keeping the list of routing rules down to a minimum.

Yes – this is something we are looking at. The challange with regular expressions is that only a subset of people really understand them (and importantly – understand how to optimize them). But I agree that having this as an option would be super flexible.

>> I must say that i am still worried about having to leave all the knowledge that we ave until now with webforms and start a new technology and still think that we would need some kind of a bridge to close the gap between today solution of webforms and tomorrow solution of MVC. Although the way you structure application flow will be different, I think you’ll be pleasantly surprised by the amount of knowledge overlap that exists. Authentication, Authorization, Caching, Configuration, Compilation, Session State, Profile Management, Health Monitoring, Administration, Deployment, and many, many other things are exactly the same. MVC views are also .aspx pages (that use .ascx user controls and .master files). So the concept re-use is quite heavy there as well. »)

  • http://weblogs.asp.net/scottgu/archive/2007/12/06/asp-net-mvc-framework-part-3-passing-viewdata-from-controllers-to-views.aspx (« The last few weeks I have been working on a series of blog posts that cover the new ASP.NET MVC Framework we are working on. The ASP.NET MVC Framework is an optional approach you can use to structure your ASP.NET web applications to have a clear separation of concerns, and make it easier to unit test your code and support a TDD workflow. The first post in this series built a simple e-commerce product listing/browsing site. It covered the high-level concepts behind MVC, and demonstrated how to create a new ASP.NET MVC project from scratch to implement and test this e-commerce product listing functionality. The second post in this series drilled deep into the URL routing architecture of the ASP.NET MVC framework, and discussed both how it worked as well as how you can handle more advanced URL routing scenarios with it. In today’s blog post I’m going to discuss how Controllers interact with Views, and specifically cover ways you can pass data from a Controller to a View in order to render a response back to a client. In Part 1 of this series, we created an e-commerce site that implemented basic product listing/browsing support. We implemented this site using the ASP.NET MVC Framework, which led us to naturally structure the code into distinct controller, model and view components. When a browser sends a HTTP request to our web site, the ASP.NET MVC Framework will use its URL routing engine to map the incoming request to an action method on a controller class to process it. Controllers in a MVC based application are responsible for processing incoming requests, handling user input and interactions, and executing application logic based on them (retrieving and updating model data stored in a database, etc). When it comes time to render an HTML response back to the client, controllers typically work with « view » components – which are implemented as separate classes/templates from the controllers, and are intended to be focused entirely on encapsulating presentation logic. Views should not contain any application logic or database retrieval code, instead all application/data logic should only be handled by the controller class. The motivation behind this partitioning is to help enforce a clear separation of your application/data logic from your UI generation code. This makes it easier to unit test your application/data logic in isolation from your UI rendering logic.Views should only render their output using the view-specific data passed to it by the Controller class. In the ASP.NET MVC Framework we call this view-specific data « ViewData ». The rest of this blog post is going to cover some of the different approaches you can use to pass this « ViewData » from the Controller to the View to render.

>> One question Scott: Let say i’m jumpng on MS MVC bandwagon, do i have to abandon asp.net Page Life cycle godddies, should i set up my mind to different approach. When you use the ASP.NET MVC approach you’ll want to have all post in your site go to your Controller. This helps ensure that the application can be easily tested and preserves the separation of concerns. This is different from using ASP.NET server controls which postback to themselves (which is very powerful too – but means that it can sometimes be slightly harder to test). What doesn’t change is that all of other ASP.NET pieces (forms authentication, role management, session state, caching, profiles, configuration, compilation, httprequest/response, health monitoring, etc, etc) works with both web forms based pages and MVC based pages. MVC UI are also built with .aspx, .master, and .ascx files – so there is a high level of skill re-use there as well.

>> Some asp.net controls require <form runat=server>. If we use a asp:dropdownlist for example, we have to place in the asp:form. And this means viewstate comes back! Is there any way to get rid of hidden form fields? Or you suggest that we do must use classic HTML controls ? I’ll cover this more in my next blog in this series. We have helpers that can automate generating things like dropdownlists, etc. Think of them as controls for MVC. These don’t use viewstate and give you a little more control over the output of your HTML.

>> It would be nice if you can just compare a bit our MVC with ROR. Within ROR, we can create tables, Columns and Rows with Ruby, without using a single line of SQL, and all its done through ActiveRecord. In short all CRUD advantages.

>> SubSonic is almost in this line. Can you explain more in this line or how SubSonic can be used to take ActiveRecord Type advantages.

RoR is made up of several components.

« Action Controller » is the name of the MVC framework that Rails uses. That is the closest analogy to the ASP.NET MVC Framework – and at a high-level the ASP.NET MVC framework uses many of the same core concepts (URLs map to controller actions). The ASP.NET MVC Framework has a few additional features (like the ability to map incoming parameters directly to action method parameters). It is also more explicit about calling RenderView within the request.

« Active View » is the name of the View engine that Rails uses. This is analagous to the .aspx/.master/.ascx infrastructure ASP.NET has. Our view engine is IMO a little richer, and supports several additional features (declarative controls/components, templating, multiple regions for nested master pages, WYSIWYG designer, strongly typed ViewData access, pluggable storage provider, declarative localization, etc).

« Active Record » is the name of the ORM (object relational mapper) that RoR uses. This is analagous to an ORM in the .NET world – whether it is LINQ to SQL, LINQ to Entities, LLBLGen, SubSonic, NHibernate, ActiveRecord (the .NET version), etc. All of these ORMs have ways to map rows and columns in a database to objects that a developer then manipulates and works against (and can save changes back). The LINQ to SQL ORM is built-in to .NET 3.5 today, and LINQ to Entities will be built-in with .NET 3.5 SP1.

I think from your follow-up question above you are referring specifically to the « migrations » feature in RoR – which allows you to define table schemas using code, and version the schemas forward/backward. There isn’t a built-in version of this in the core .NET Framework today – although the SubSonic project has recently released a version that allows you to-do this using .NET. You can find out more about it here: www.subsonicproject.com.

>> Superb, …but I still longing for the IOC integration (Spring.NET, Windsor, StructureMap)…maybe in the next post ? I am planning on posting about IOC and dependency injection in the future (the ASP.NET MVC framework fully supports it and can be used with Spring.NET, Windsor, StructureMap, etc). I have a few other more basic MVC tutorials I need to get out of the way first – but testing and dependency injection are on the list for the future.

>> Nice series, eagerly waiting to see AJAX approach in the new ASP.NET MVC Framework, so when shall we expext that.
We will have ASP.NET AJAX support with the ASP.NET MVC Framework. I’ll talk more about this in a future tutorial series post.

>> This is coming together nicely. I was just hoping you might explain why there are 3 different ways to pass the ViewData? Does each method offer something that the others don’t? If not, surely it would be best to choose one method and force all developers to follow the same practice? Conceptually there are two ways to pass viewdata – either as a dictionary, or as a strongly typed object. In general I recommend using the strongly typed dictionary approach – since this gives you better compilation checking, intellisense, and refactoring support. There are, however, some times when having a more latebound dictionary approach ends up being flexible for more dynamic scenarios« )

  • http://blog.wekeroad.com/2007/10/26/microsoft-subsonic-and-me/ (« Rather than try and come up with some lame metaphors and trite pop-culture references, I’ve decided to use some advice from English 101 Professor:

    “Whatever the hell you’re trying to say, just say it”

    So I will: I’m going to work for Microsoft. I just signed the offer letter. I’ll be working with the ASP.NET guys on the new MVC platform as well as some other groovy things like Silverlight. I get to work “across the hall” from one of my very good friends – Phil Haack. I think it’s worth pointing out that SubSonic hasn’t been “bought”. Some might smell a conspiracy here, but I’ll leave that to the X-Files and Cap’n Crunch crowd to drum up all the evil reasons why the mothership has “beamed me up”. SubSonic will remain under the same MPL 1.1 license it always has, and will remain as completely Open Source as it always has – nothing will change at all. I’m just getting paid, essentially, to work on it 🙂...This is crucial to me. I decided to be direct with him and make sure we both understood these important points:

    “I want to be sure I have complete creative control over SubSonic, and that you don’t censor my blog… is that cool?”

    Shawn’s response is why I took the job:

    “Well Duh…” (he added some more things that were a bit more eloquent than “duh” – but I don’t think I was listening).

    I can make jokes about the UAC on my blog? And make up fictional Matrix converstations with ScottGu? Sign me up! I start on November 12th, right after DevConnections in Vegas (come on by if you’re out that way at the DNN Open Force« )

  • http://www.subsonicproject.com/ (« A Super High-fidelity Batman Utility Belt. SubSonic works up your DAL for you, throws in some much-needed utility functions, and generally speeds along your dev cycle. Why SubSonic ? Because you need to spend more time with your friends, family, dog, bird, cat… whatever. You work too much. Coding doesn’t need to be complicated and time-consuming. »)
  • http://en.wikipedia.org/wiki/Test-driven_development (« Test-Driven Development (TDD) is a software development technique consisting of short iterations where new test cases covering the desired improvement or new functionality are written first, then the production code necessary to pass the tests is implemented, and finally the software is refactored to accommodate changes. The availability of tests before actual development ensures rapid feedback after any change. Practitioners emphasize that test-driven development is a method of designing software, not merely a method of testing. Test-Driven Development began to receive publicity in the early twenty-first century as an aspect of Extreme Programming, but more recently is creating more general interest in its own right. Along with other techniques, the concept can also be applied to the improvement and removal of software defects from legacy code that was not developed in this way . »)
  • ss
  • http://weblogs.asp.net/scottgu/archive/2007/12/09/asp-net-mvc-framework-part-4-handling-form-edit-and-post-scenarios.aspx
  • (« ASP.NET MVC Framework (Part 4): Handling Form Edit and Post Scenarios   The last few weeks I have been working on a series of blog posts that cover the new ASP.NET MVC Framework we are working on.  The ASP.NET MVC Framework is an optional approach you can use to structure your ASP.NET web applications to have a clear separation of concerns, and make it easier to unit test your code and support a TDD workflow. The first post in this series built a simple e-commerce product listing/browsing site.  It covered the high-level concepts behind MVC, and demonstrated how to create a new ASP.NET MVC project from scratch to implement and test this e-commerce product listing functionality.  The second post drilled deep into the URL routing architecture of the ASP.NET MVC framework, and discussed both how it worked as well asthird post discussed how Controllers interact with Views, and specifically covered ways you can pass view data from a Controller to a View in order to render a response back to a client.  In today’s blog post I’m going to discuss approaches you can use to handle form input and post scenarios using the MVC framework, as well as talk about some of the HTML Helper extension methods you can use with it to make data editing scenarios easierClick here to download the source code for the completed application we are going to build below to explain these concepts… Our Data Model. We are going to use the SQL Server Northwind Sample Database to store our data.  We’ll then use the LINQ to SQL object relational mapper (ORM) built-into .NET 3.5 to model the Product, Category, and Supplier objects that represent rows in our database tables. We’ll begin by right-clicking on our /Models sub-folder in our ASP.NET MVC project, and select « Add New Item » -> « LINQ to SQL Classes » to bring up the LINQ to SQL ORM designer and model our data objects…To learn more about LINQ and LINQ to SQL, please check out my LINQ to SQL series here The HtmlHelper object (as well as the AjaxHelper object – which we’ll talk about in a later tutorial) have been specifically designed to be easily extended using « Extension Methods » – which is a new language feature of VB and C# in the VS 2008 release.  What this means is that anyone can create their own custom helper methods for these how you can handle more advanced URL routing scenarios with it.  The objects and share them for you to use. We’ll have dozens of built-in HTML and AJAX helper methods in future previews of the ASP.NET MVC Framework.  In the first preview release only the « ActionLink » method is built-into System.Web.Extensions (the assembly where the core ASP.NET MVC framework is currently implemented).  We do, though, also have a separate « MVCToolkit » download that you can add to your project to obtain dozens more helper methods that you can use with the first preview release.
  • >> This is nice. But do you handle subcomponents? subviews? Is view reuse possible inside other view? This is very important for even for modest sized applications? How would you handle posts correcly inside of subviews 😉 ?The first public MVC preview doesn’t have the concept of SubControllers yet (where you can attach them for regions of a larger view).  That is something we have planned for to tackle soon though.

    >> However, liviu raises good questions about Sub-Controllers, Composite Views and AJAX scenarios. How Will the MVC framework address the complex wiring of different parts of a page to different controllers for async updates?? My brain hurts thinking about it, yet I have implement these portal pages all the time cos our customers demand it. The first ASP.NET MVC Preview allows you to call RenderView (for example: RenderView(« Edit »)) and have it apply to either a .aspx viewpage or a .ascx viewusercontrol.  This ends up being really useful for scenarios where you are doing AJAX callbacks and want to refresh a portion of a page.  These callbacks could either be to the same Controller that rendered the origional page, or to another Controller in the project. We don’t have all the AJAX helper methods yet for this – but you could roll them yourself today.  We’ll obviously be releasing an update that does include them in the future.

  • >> Can you provide an example of how we might use a server side control to generate the drop down list or a textbox (a la WebForms) along with the pro’s and con’s of each approach? Personally, I do not like the old ASP <%= … %> syntax; but if there is a good reason to use it then I am willing to change that opinion. The main reason I showed the <% %> syntax in this post was that we don’t have the server-side MVC control equivalents available yet for this dropdown and text scenario.  That is on our roadmap to-do though – at which point you don’t need to necessarily use the <% %> syntax. In general what we’ve found is that some developers hate the <% %> syntax, while others prefer it (and feel that controls get in the way).  We want to make both sets of developers happy, and will have options for both. 🙂
  • >> Great work on the MVC model, it is a clean and intuitive model that appears to scale well. My only recommendation is that your actions (verbs) appear after the ids (nouns), e.g. [Controller]/[Id]/[Action]/  That would keep the architecture noun focused, opposed to verb focused. With this approach you can easily build an administrative interface on a public read-only site by adding verbs such as /edit/ or /delete/ at the end of your URL. A simple security rule can be added to the Controller that says ignore all Verbs after a noun, such as category or product, if user is not part of an administrative group. Thanks for the suggestion Josh.  You can do this today by creating your own custom route registration.  In the next preview I believe Route will be extensible so that you could also create a single resource route that supports these semantics.>> I was wondering if we could get an idea of the official « roadmap » for asp.net mvc?  Specifically, I’d like to know what features the team plans to release on what dates … ultimately, when this thing will RTM.  As I’ll be evaluating mvc and monorail for an upcoming app, this kind of information would really be helpful in determining which direction to go. We don’t have a formally published roadmap just yet – we will hopefully publish one early next year though.« )
  • http://en.wikipedia.org/wiki/ASP.NET_AJAX (« ASP.NET AJAX, formerly code-named Atlas, is a set of extensions to ASP.NET developed by Microsoft for implementing Ajax functionality. Including both client-side and server-side components, ASP.NET AJAX allows the developer to create web applications in ASP.NET 2.0 (and to a limited extent in other environments) which can update data on the web page without a complete reload of the page. The key technology which enables this functionality is the XMLHttpRequest object, along with Javascript and DHTML. ASP.NET AJAX was released as a standalone extension to ASP.NET in January 2007 after a lengthy period of beta-testing. It was subsequently included with version 3.5 of the .NET Framework, which was released alongside Visual Studio 2008 in November 2007.« )

Posted in 2007, Acces aux données, active record, AJAX, Architecture logicielle, ASP.NET, Développement logiciel, design pattern, DotNet, IDE-GUI, Ironpython, javascript, open source, ORM, RIA, ruby, tests, Web Frameworks | Tagué: , , , , , , , | Leave a Comment »

Les dernières nouvelles du monde DotNet : ADO.NET Data services, LINQ, Mono 1.2.6, Visual studio 2008, silverlight2.0

Posted by patrick sur décembre 13, 2007

En vrac:

ADO.NET Data Services (Astoria Project)

  • http://astoria.mslivelabs.com/ (« The new wave of web applications are built on technologies such as AJAX and Microsoft Silverlight that enable developers to build better, richer user experiences. These technologies bring a shift in how applications are organized, including a stronger separation of presentation from data. ADO.NET Data Services (also known as Project code name “Astoria”) consists of a combination of patterns and libraries that enables any data store to be exposed as a flexible data service, naturally integrating with the Web, that can be consumed by Web clients within a corporate network or across the Internet. ADO.NET Data Services uses URIs to point to pieces of data and simple, well-known formats to represent that data, such as JSON and ATOM/APP. This results in data being exposed to Web clients as a REST-style resource collection, addressable with URIs that agents can interact with using standard HTTP verbs such as GET, POST, or DELETE. » Je rajoute un bémol à la dernière phrase qui est inexacte: DELETE n’est pas un verbe HTTP. Pour rappel voir le billet que j’avais écrit à propos de Django: The method of an HTML form is limited to GET and POST. PUT and DELETE are not allowed. This isn’t some failure of browser vendors to properly implement the specification either. The HTML specification only allows GET and POST as form actions. XHTML and even XForms 1.0 don’t change this. This means it’s impossible to build a fully RESTful client application inside a web browser. Consequently everyone tunnels everything through POST, and simply ignores PUT and DELETE)

LINQ

  • http://tirania.org/blog/archive/2007/Oct-24.html (« OpenSource LINQ providers: The Db_Linq is an open source project to create a LINQ provider for other databases. The project is lead by George Moudry and so far has providers for PostgreSQL, Oracle and Mysql. George keeps a blog http://code2code.net/wordpress/ where you can track the development of DbLinq. Thanks to Bryan for pointing me out to this fantastic piece of code. Mono users on Linux will now be able to use LINQ with open source databases from C# (in addition to our in-memory and XML providers). Update: A nice blog entry talks about Parallel LINQ. A version of LINQ that can be used to parallelize operations across multiple CPUs:

    IEnumerable data = …;

    // Regular code:
    var q = data.Where(x => p(x)).
    Orderby(x => k(x)).Select(x => f(x));
    foreach (var e in q) a(e);

    // Parallelized version, add the « AsParallel » method:
    var q = data.AsParallel().Where(x => p(x)).
    Orderby(x => k(x)).Select(x => f(x))

    See more details about the above in the Running Queries On Multi-Core Processors article.« )

  • http://spellcoder.com/blogs/bashmohandes/archive/2007/10/14/8530.aspx (« I’ve been hearing about PLINQ (Parallel Linq) since the first days of announcing LINQ, the idea of making use of the new functional style programming provided in DotNet 3.5 in order to give better performance on Multi Core machines, the idea sounds cool since first day, and it now comes true in a new name Parallel FX or PFX. The programming model provided is quite simple and utilizes the same LINQ model, the new assembly is called System.Concurrency.dll which is the library that contains the new interface called IParallelEnumerable<T>, also it adds an extension methods for all collections and arrays that implement old IEnumerable, the extension method is called AsParrallel<T> which converts any collection to a Parallel enabled collection of type IParallelEnumerable<T> »)
  • http://en.wikipedia.org/wiki/Language_Integrated_Query (« Language Integrated Query (LINQ, pronounced « link ») is a Microsoft .NET Framework component that adds native data querying capabilities to .NET languages using a syntax reminiscent of SQL. Many of the concepts that LINQ has introduced were originally trialled in Microsoft’s research project. LINQ has been released as a part of of .NET Framework 3.5 on November 19, 2007. »)

Visual Studio 2008

Mono

  • http://www.mono-project.com/news/archive/2007/Dec-12.html (« We have just released Mono 1.2.6. Some of the highlights for this release include:
    • Native Windows.Forms driver for MacOS X allows Winforms-based applications to run without an X server.
    • Support for the ASP.NET AJAX APIs and controls.
    • Support for FastCGI deployments: ASP.NET can now be deployed on a multitude of servers that implement the FastCGI protocol (lighttpd for example) in addition to Apache.
    • Windows.Forms now supports the WebControl on Windows and Linux using Mozilla.
    • Runtime will now consume much less memory for 2.0-based applications due to various optimizations in generics support as well as including many new performance improvements and an updated verifier and an implementation of CoreCLR security.
    • C# compiler is quickly approaching full 3.0 support, most of the basics work right now (except support for System.Query.Expression AST generation).
    • Mono 1.2.6 can now be used as an SDK for creating Silverlight 1.1 applications on all platforms. This allows developers to create applications that target Silverlight without requiring a Windows installation.« )

silverlight

ironpython

  •  http://ironpython-urls.blogspot.com/2007/12/ironpython-studio-now-available.html ( » IronPython Studio is a free full IDE (Integrated Development Environment) for the Python programming language. It is based on the existing IronPython example that is included in the VS SDK. IronPython Studio is based on the Visual Studio 2008 Shell runtime (royalty free) and can be installed without requiring any version of Visual Studio. It is hosted on codeplex. Installer, source and screencast are available from the download page. The sources require Visual Studio 2008 (Team Edition apparently) and the SDK. NOTE: Some users (myself included) had trouble getting this working. The magic steps are:
    • Download and install the Visual Studio X redistributable from: Visual Studio Extensibility
    • After you run the Install for the MS VS 2008 Shell Isolated Mode Redistributable, you must then go to the folder (« C:\VS 2008 Shell Redist\Isolated Mode« ) and click on: « vsshellisolated_enu.exe » to actually install the redistributable runtime.
    • Install IronPython Studio. Thanks to Tom Clark for the instructions. »)

Posted in Acces aux données, AJAX, Développement logiciel, multi-core, python, REST, RIA | Tagué: , , , , , , , , , , | Leave a Comment »

Publication du livre blanc de l’April sur les modèles économiques du logiciel libre

Posted by patrick sur décembre 12, 2007

L’April publie ce jour (mardi 11 décembre 2007) un livre blanc des modèles économiques du Logiciel Libre, réalisé par des entreprises membres de l’association.

Représentatifs de tout l’écosystème, éditeurs, consultants, SSLL, sociétés de service, industriels et utilisateurs s’y sont réunis pour recenser et expliquer les modèles économiques du Logiciel Libre. Ils expliquent pourquoi ces modèles, où édition et service se mêlent dans des modèles hybrides, répondent mieux aux attentes des entreprises. Enfin ils esquissent les évolutions possibles de ces modèles.

Ce livre blanc est diffusé selon les termes de la Licence GNU Free Documentation License. Merci à tous les auteurs, contributeurs et relecteurs de ce livre blanc. La page principale :

http://www.april.org/articles/livres-blancs/modeles-economiques-logiciel-libre/ Livre blanc au format PDF : http://www.april.org/articles/livres-blancs/modeles-economiques-logiciel-libre/200712-modeles-economiques.pdf Livre blanc au format ODT : http://www.april.org/articles/livres-blancs/modeles-economiques-logiciel-libre/200712-modeles-economiques.odt

«La version originale de ce document a été rédigée par l’April (association de promotion et défense du logiciel libre) et est disponible sur <http://www.april.org&gt; ».

Quelques extraits du libre blanc:

« Le Logiciel Libre n’est pas une nouvelle technologie. C’est un mode de production et de distribution du logiciel, c’est-à-dire un ensemble de pratiques concernant le management des projets, la gestion du code source, les canaux de mise à disposition des produits, les conditions légales d’utilisation, l’assistance technique, et même le marketing et les forces de vente.

Ce mode de production n’est pas en soi une innovation. La notion de Logiciel Libre a été formalisée dès les années 1980, et les pratiques correspondantes sont sans doute encore plus anciennes. On peut même dire que le Logiciel Libre est né dès que la notion de « produit logiciel » indépendante du matériel a été perçue par les développeurs et les utilisateurs. Son apparition a silencieusement précédé celle de l’édition commerciale de logiciels non libres telle que nous la connaissons aujourd’hui. L’innovation réside dans l’ampleur et les usages du phénomène Logiciel Libre qui se manifeste sur plusieurs plans :

  • La plate-forme de conception et de réalisation du logiciel libre a toujours été le « réseau ». Naguère réservé à des initiés, il est devenu avec la généralisation de l’Internet l’infrastructure d’un « village global » propice aux modes de développement collaboratifs et décentralisés. La visibilité des projets libres en a été immédiatement amplifiée ;

  • Le Logiciel Libre n’est plus aujourd’hui confiné au marché de l’infrastructure. Initialement « système et réseau », les logiciels libres s’invitent dans tous les segments de l’édition logicielle, y compris les applicatifs « métier » (progiciels de gestion intégrés, gestion de la relation client, business intelligence) et la bureautique. Ils touchent ainsi les utilisateurs et les décideurs ;

  • Un écosystème complet est à présent en place et, de la production à la mise en œuvre chez l’utilisateur, chacun peut y trouver ce qui correspond à son métier et à ses objectifs. Le Logiciel Libre n’est plus seulement une matière première pour informaticiens et, sur un modèle où l’accès aux sources est ouvert par définition, on y trouve des produits finis et des intégrateurs qui s’engagent sur des résultats.

L’objet de ce Livre Blanc est de présenter une synthèse des pratiques, des enjeux et des opportunités du Logiciel Libre, dont la réussite indiscutable soulève encore des interrogations économiques. Tout porte à croire qu’aujourd’hui l’environnement est favorable et l’essentiel des savoir-faire est en place.

Notre Livre Blanc s’adresse aux décideurs des entreprises des secteurs public et privé, aux dirigeants politiques qui souhaitent mieux comprendre l’économie et les enjeux qui résident derrière le Logiciel Libre, aux investisseurs qui s’intéressent aux acteurs du Libre, aux journalistes en quête perpétuelle d’informations et d’exemples pour illustrer les secteurs les plus dynamiques de l’innovation logicielle.

Ce livre est plus largement destiné à toutes les personnes qui s’intéressent aux nouvelles technologies de l’information ainsi qu’à l’émergence des logiciels libres dans le monde entier.

Le modèle de création du Logiciel Libre s’appuie sur un fort investissement humain et sur le partage de valeurs au sein d’un même projet. Les projets comportent des utilisateurs et des développeurs aux savoir-faire complémentaires organisés en communautés interagissant autour de systèmes de production de code, de documentation et de mises à jour. Ces organisations regroupent des utilisateurs du monde entier et des équipes pluridisciplinaires, comprenant aussi bien des industriels à travers la publication de recherches et d’outils expérimentaux que des éditeurs ou sociétés de services qui consacrent une part significative de leur chiffre d’affaires en R&D ou encore des contributeurs individuels.

Ce modèle de création communautaire favorise la démocratisation et la diffusion de l’innovation en constituant un patrimoine universel de connaissances, de méthodes et d’outils logiciels accessibles à tous.

Le Logiciel Libre couvre tous les types de logiciels : outils système (système d’exploitation, pilotes de matériel), programmation (C, Java, Ada, Python…), logiciels d’infrastructure (serveurs web, serveurs de messagerie, bases de données), logiciels de sécurité (sécurité réseau, système et applicative), « middleware » ou intergiciels (Jonas, JBoss, Glassfish…), environnement de travail (KDE, Gnome…), outils bureautiques (OpenOffice.org, Firefox…), clients riches métier (TinyERP, Eclipse, netbeans…).

Pour trouver des catalogues approfondis énumérant l’offre disponible en logiciels libres, il est possible de consulter sur Internet des sites tels que Framasoft (http://www.framasoft.net), l’annuaire FSF/UNESCO (http://directory.fsf.org/), Sourceforge (http://www.sourceforge.org), etc.

La protection juridique est garantie par des licences logicielles qui forment un socle assurant une bonne stabilité des réalisations, la simplification des processus juridiques et contractuels ainsi qu’une protection des œuvres créées. Le Logiciel Libre apporte un cadre juridique accepté par tous et assure une pérennité de l’investissement commun.

Le secteur professionnel dont l’activité est basée sur le Logiciel Libre ne cesse de s’agrandir : éditeurs, sociétés de services généralistes ou spécialisées, fournisseurs de services en ligne, commerçants en ligne, grands comptes, laboratoires de recherche, instituts de formation, industriels et constructeurs informatiques. Le Logiciel Libre permet également aux acteurs qui n’y contribuent pas directement de participer à son essor, en diffusant largement son usage. On peut par exemple noter le succès croissant des applications Firefox et OpenOffice.org aussi bien en entreprise que chez les particuliers ou dans les services publics.

….

Les logiciels libres permettent à l’industrie informatique de sortir de la relation classique « client/fournisseur » pour ouvrir d’autres possibilités de collaboration entre acteurs, en particulier autour du principe de communauté de développement, au service de la productivité et de l’innovation. Cette transparence contribue à élever le niveau général en réétalonnant le marché vers le haut.

Au niveau des commodités, l’excellence technique et l’innovation technologique dans le Logiciel Libre ont conduit à concevoir les systèmes les plus fiables (GNU/Linux, BSD, OpenSSH) vers lesquels converge le monde Unix, ainsi que les principales couches middleware (Python, Java, JBoss, ObjectWeb). Les projets complexes sont aujourd’hui basés sur du Libre : les produits à fort besoin de rendement et de fiabilité (virtualisation, terminaux ADSL, portails et moteurs Internet, VOIP, etc.), la téléphonie et l’embarqué massivement développés sur des noyaux libres, ou le monde de l’ASP.

Fin 2000, IBM annonce 1 milliard de dollars d’investissement « autour de Linux » et sonne le ralliement des grands comptes. L’ensemble des éditeurs et constructeurs informatiques rejoignent le mouvement et investiront au fur et à mesure sur la plate-forme GNU/Linux : elle émerge en tant que valeur du marché de l’informatique.

De grandes administrations sont aujourd’hui clientes du Logiciel Libre aux États-Unis, en Europe, dans les pays émergents, et pour la France, les principaux ministères (Intérieur, Minefi, Agriculture, Éducation nationale notamment), le secteur public (gendarmerie, CEA, CNRS) ainsi qu’un nombre important de grandes entreprises. Récemment, le Groupe PSA a annoncé basculer 20 000 postes de travail vers des postes utilisant le système GNU/Linux.

En 2006, le marché français du Logiciel Libre pèserait près de 500 millions d’euros de chiffre d’affaires, essentiellement en services. Il devrait, d’ici 2010, être multiplié par 10 selon les principales études disponibles sur le marché (IDC, PAC). De 1,4% du marché des services informatiques en France en 2006, le Libre pourrait atteindre 5% de part de marché en 2010.

Le Logiciel Libre a redonné à l’ingénierie une nouvelle vigueur en mettant à disposition tout un ensemble de technologies fortement paramétrables et de composants réutilisables, personnalisables, qui sont autant de commodités en libre accès sur l’Internet. Ceci amène une montée inéluctable de la valeur ajoutée associée au service. Une tendance soutenue par l’amélioration des outils (gestion de projets, pilotage…).

Le partage de valeurs et de pratiques communes permet de définir les entreprises du Libre :

  • la veille technologique couplée avec une interaction avec les communautés du Libre,

  • le respect du modèle de développement Open Source et des standards de professionnalisme et d’éthique du Logiciel Libre,

  • la compréhension, l’utilisation et la diffusion des licences libres.

D’un marché confidentiel et émergent, le Libre est en train de pénétrer toutes les couches du système d’information et entre dans une phase de maturité, de structuration et de consolidation.

D’un modèle « tout en un » (SSLL), capable de proposer l’intégralité de la chaîne de valeurs sur des projets de faible envergure, ou de distributeur de commodités systèmes de type GNU/Linux accessibles en téléchargement, les acteurs du Libre doivent s’adapter à une demande plus globale, à des tailles de projets plus importantes ainsi qu’à la professionnalisation du marché.

Le partage et l’Open Source ont joué un rôle décisif dans la fondation de Sun et forment le cœur de sa stratégie actuelle. Sun a fourni plus de lignes de code en Open Source que n’importe quelle autre organisation. Le président et CEO de Sun, Jonathan Schwartz, a lancé à son entreprise le défi de diffuser le code source de tous les logiciels qu’elle produit. Avec les dizaines de communautés Open Source parrainées par Sun, telles que OpenSPARC, OpenSolaris, GlassFish et désormais la technologie Java Open Source, Sun est sur le point d’atteindre son objectif. Sun est aussi l’un des contributeurs majeurs à des projets tels que X.org, GNOME, Apache, Mozilla.

Itaapy est spécialisée dans les nouvelles technologies de l’information : dématérialisation de procédures, gestion électronique de documents, planification de ressources, e-Gouvernement, e-Learning.

Itaapy intervient en services sur l’ensemble des domaines logiciels en conseil technique et fonctionnel, en assistance à maîtrise d’ouvrage, en développement et en formation.

L’environnement technologique d’Itaapy est le Logiciel Libre en général, et le langage Python en particulier dont l’entreprise est un expert du marché en France.

Alter Way : intégrateur Open Source hybride, services et édition

Alter Way fédère des sociétés emblématiques et spécialisées qui ensemble couvrent les principaux besoins du système d’information : gestion de contenu, groupware et bases de données, infogérance système et réseau et hébergement…

Ses dirigeants fondateurs, Philippe Montargès et Véronique Torner, veulent apporter aux grands comptes, administrations, collectivités locales et PME/PMI, une réponse industrielle globale assurée par un interlocuteur unique pour la mise en œuvre de solutions Open Source.

Ils construisent un groupe qui fait valoir sa compétence distinctive du Libre ainsi qu’une capacité d’accompagnement et une pérennité comparables à celles des intégrateurs traditionnels.

Libre-entreprise : réseau d’entreprises sur un modèle coopératif

Libre-entreprise, créé en 2002, est historiquement le premier réseau de sociétés de services en Logiciel Libre. Les sociétés du groupe Libre-entreprise sont implantées sur toute la France et en Belgique. Elles mettent en œuvre dans leur mode de fonctionnement les principes qui prévalent dans la communauté du Logiciel Libre : mutualisation des compétences, transparence, démocratie (1 homme = 1 voix). L’organisation en réseau permet à toutes les sociétés membres de proposer une offre commerciale étendue et de disposer d’un ensemble de ressources spécialisées et diversifiées. Chaque entreprise du réseau fonctionne comme une unité de gestion indépendante. Ces principes sont rassemblés dans une charte http://libre-entreprise.org/index.php/Charte

 

Logilab : éditeur, intégrateur et centre de formation

La particularité de Logilab est de s’être donné un cadre assez strict en faisant le choix de techniques, d’outils et de domaines d’applications. Dans ce cadre défini par Linux, Debian, C, Fortran, Python, les méthodes agiles, l’informatique scientifique et la gestion de connaissance, Logilab a des activités très diversifiées. Elle intervient auprès de PME comme de grands comptes, publics comme privés, industrie comme recherche, pour du conseil, de la formation, du développement, etc. C’est avant tout l’expertise technique dans les domaines concernés et la maîtrise des outils sélectionnés qui sont recherchées par ses clients, ce qui la différencie du modèle de la SSLL qui favorise la polyvalence et offrira ses compétences pour la plupart des langages et des outils du marché.

Logilab a par ailleurs une organisation interne qui reprend certains traits des communautés Libres : l’autonomie et la responsabilité personnelle, le débat permanent, la distribution géographique, la coordination par la messagerie instantanée, l’utilisation de systèmes de gestion de source pour partager logiciels et documents. Ces caractéristiques sont souvent remarquées, car peu répandues au sein des organisations qui font usage de Logiciel Libre.

Le paradigme de la rareté des biens facilite le fonctionnement de l’économie traditionnelle. L’arrivée de l’Internet au contraire et de la diffusion de masse bouscule les modes de commercialisation préexistants tout en générant de nouvelles possibilités de développement économique. Les récents débats autour du téléchargement des œuvres musicales sur Internet et le vote houleux de la loi DADVSI en sont bien sûr une autre illustration. La question du modèle de rémunération de la production des biens informationnels, notamment des logiciels informatiques, est dans ce contexte un enjeu majeur. Faut-il s’opposer aux évolutions offertes par l’Internet en finançant des barrières à la diffusion ?

Le Logiciel Libre suit la voie de la diffusion sans limitation, en proposant ainsi de nouveaux modèles économiques pour l’économie de l’immatériel.

  …

Pour de nombreuses sociétés de petite taille (particulièrement les éditeurs), les avantages du Logiciel Libre en terme de rapidité de mise en œuvre contrebalancent l’absence de rémunération à la copie. Le faible coût de diffusion du logiciel (téléchargement libre) permet à une petite structure innovante d’obtenir une reconnaissance internationale de son expertise. AdaCore et Mandriva sont des exemples de sociétés qui utilisent l’effet de coût marginal nul de la duplication et l’effet de levier de la diffusion via Internet de solutions logicielles. Un modèle économique couramment associé à ce type de développement est la vente de prestations de support dans le monde entier.

  …

Un point fort du Logiciel Libre est de fournir des applications dont la pérennité, les évolutions et les coûts ne dépendent pas d’un éditeur unique, ce qui peut devenir problématique lorsque le poids de l’éditeur est tel que ses clients ne peuvent plus influencer sa stratégie. Du point de vue économique, les coûts en jeu incitent les utilisateurs à comparer la valeur ajoutée des solutions, à se méfier des « boîtes noires » et à mettre leurs fournisseurs dans une situation de concurrence. Présenter une offre ayant des garanties de transparence et d’indépendance devient un avantage concurrentiel. C’est par exemple le choix de Sun Microsystems avec Java et Open Solaris.

La numérisation pose aussi le problème de la conservation et de la réutilisation des informations de l’entreprise sur le long terme. L’utilisation de formats ouverts, désormais clairement définis notamment dans la loi française, pour stocker l’information s’impose progressivement. En permettant une indépendance vis-à-vis de l’applicatif pour accéder aux informations, les formats standards améliorent la pérennité des données, et ouvrent la porte aux logiciels libres.

En synthèse, la croissance des échanges et du volume d’information géré par les entreprises entraîne une demande de transparence des outils et de mise en concurrence des fournisseurs. Cela se traduit par une demande d’ouverture des applications (code ouvert, méthodes standardisées) et une demande de standards interopérables (pérennité des données et facilité de communication). Cette demande bénéficie directement aux offres basées sur du Logiciel Libre.

  ….

Le Logiciel Libre permet une forte maîtrise de son système d’information. Notamment, les décisions sur les évolutions des composants logiciels peuvent se prendre avec une plus grande liberté qu’en environnement propriétaire. Pour les structures dont le système d’information est un enjeu majeur en terme d’indépendance, le Logiciel Libre est un atout. Certains acteurs économiques utilisent le Logiciel Libre car l’indépendance qu’il permet vis-à-vis des fournisseurs permet d’obtenir un niveau élevé de secret industriel (Google maintient ses concurrents loin de ses infrastructures informatiques et salarie de nombreux contributeurs à des projets majeurs).

Les leaders des télécommunications, du matériel informatique et des éditeurs de systèmes d’exploitation contribuent activement sur les logiciels qui leur permettent d’échapper au risque de domination d’un éditeur unique. Tous ces acteurs participent directement ou indirectement aux projets libres majeurs via des fondations (Mozilla, Apache) ou en salariant des développeurs (OpenOffice.org, Python, Samba).

  …

L’Europe a fait le constat de la place prépondérante des États-Unis dans la technologie (Internet, logiciels, matériels informatiques) et des investissements majeurs d’autres régions (l’Asie a investi massivement dans la recherche et les logiciels libres : 85 milliards de dollars sur 10 ans). Face aux enjeux du numérique en terme de croissance et d’indépendance, l’Union européenne a défini un axe stratégique fort sur l’économie de la connaissance (stratégie de Lisbonne1).

1Le Conseil européen de Lisbonne a fixé un objectif stratégique visant à faire de l’Union européenne « l’économie de la connaissance la plus compétitive et la plus dynamique du monde d’ici à 2010, capable d’une croissance économique durable accompagnée d’une amélioration quantitative et qualitative de l’emploi et d’une plus grande cohésion sociale ». (http://ue.eu.int/ueDocs/cms_Data/docs/pressData/fr/ec/00100-r1.f0.htm)

Le Logiciel Libre et les standards ouverts (dont Open Document Format) permettent dès maintenant à l’Union européenne de résoudre la grave question de l’interopérabilité des systèmes et des contenus parmi 27 pays et 23 langues officielles. L’Europe doit maintenant saisir l’opportunité d’un investissement dans la recherche en s’appuyant sur les logiciels libres pour diffuser et accélérer l’innovation, tout en restant autonome sur ses choix technologiques sans dépendance financière.

  …

Enfin, l’ensemble des PME (dont un grand nombre de start-up) peuvent puiser dans cet immense réservoir de savoirs, de connaissances et d’outils, sans avoir à financer un investissement lourd, et disposer des ressources nécessaires aux innovations, synonymes de création de valeur économique et d’emplois.

  …

Face au succès du Logiciel Libre, la stratégie de défense des éditeurs partisans des solutions propriétaires se concentre actuellement sur les brevets logiciels. Ces acteurs veulent occulter le fait que la reproduction quasi gratuite des logiciels différencie fondamentalement cette activité de la production industrielle classique où les forces de la nature sont mises en œuvre.

D’autre part, ils ne partagent pas la position sur la non-brevetabilité des idées, en refusant l’inférence menant de l’idée à l’algorithme puis au logiciel.

Une arrivée en Europe des brevets logiciels aurait pour conséquence que seuls les grands acteurs du logiciel propriétaire auraient la capacité juridique de traiter tous les problèmes d’imbrication liés aux brevets portant sur les multiples composants d’un nouveau logiciel.

Même si la durée d’un brevet logiciel est limitée dans le temps, le fait de maîtriser la chaîne de création de nouveaux brevets pour de nouveaux logiciels assure une hégémonie perpétuelle des acteurs installés. Il sera alors très difficile, voire impossible, à de nouveaux entrants de développer et de commercialiser de nouveaux logiciels hors des écosystèmes fermés du club existant. Cette situation bloquerait l’innovation des PME européennes au profit d’une rente de situation perpétuelle pour des sociétés qui deviendraient les possédantes de l’économie de l’information. L’enjeu est du même ordre que celui qui a amené aux législations antitrust dans le cadre du capitalisme industriel.

  ….

En Europe, les brevets logiciels sont théoriquement interdits par le droit, cependant l’Office européen des brevets en a déjà accordé des dizaines de milliers, en interprétant librement la loi en sa faveur. Dans ce contexte d’incertitude juridique, la meilleure défense à adopter pour les acteurs du Logiciel Libre est de s’unir pour peser politiquement sur des initiatives législatives mettant clairement fin aux pratiques contestables de l’Office européen des brevets. C’est notamment ce qui a permis, en 2005, de faire échec à une directive européenne qui devait consacrer la légalisation des brevets logiciels.

  …

Avant d’aborder les licences en tant que telles, il apparaît utile de présenter une définition du terme « Logiciel Libre ». Ce terme est la traduction du terme américain « Free Software » proposé par la Free Software Foundation (FSF), le principal organisme à avoir stabilisé et défini ce concept. Cette définition se veut indépendante d’une licence particulière.

Un Logiciel Libre est un logiciel qui peut être utilisé, copié, étudié, modifié et redistribué sans restriction majeure autre que la mise à disposition du code source.

La définition de la FSF repose sur 4 libertés fondamentales, les voici reprises du site de la FSF1 :

  • La liberté d’exécuter le programme, pour tous les usages (liberté 0).

  • La liberté d’étudier le fonctionnement du programme et de l’adapter à vos besoins (liberté 1). Pour ceci, l’accès au code source est une condition requise.

  • La liberté de redistribuer des copies, donc d’aider votre voisin (liberté 2).

  • La liberté d’améliorer le programme et de publier vos améliorations pour en faire profiter toute la communauté (liberté 3). Pour ceci, l’accès au code source est une condition requise.

La définition du Logiciel Libre est indifférente à la question de la gratuité ou au mode de diffusion du logiciel2. Il est parfaitement possible de vendre un logiciel et de ne donner le code source qu’à l’acquéreur. Toutefois, il est impossible de restreindre les droits de l’acquéreur, notamment sa possibilité de diffuser ensuite largement le logiciel s’il le souhaite.

Par référence à la définition du Logiciel Libre, on appelle « logiciel propriétaire » ou « privateur »  tout logiciel ne correspondant pas à cette définition, quelle que soit la raison (restriction sur le droit d’usage, code source non disponible…). Le terme de « logiciel commercial » est à éviter car imprécis : un grand nombre de logiciels libres sont édités dans un contexte commercial (par exemple, le serveur d’application JBoss).

Termes proches : le terme « Open Source » provient de l’Open Source Initiative, qui promeut le Logiciel Libre sous l’angle de l’efficacité technique. L’OSI propose une définition de l’Open Source sur son site3 et maintient une liste de licences compatibles. En pratique, les définitions FSF et OSI sont très proches. L’acronyme FOSS (Free Open Source Software) est de plus en plus utilisé, voire même FLOSS (Free Libre Open Source Software) dans le contexte européen.

1Définition de Logiciel Libre sur le site de la FSF (en français) : http://www.gnu.org/philosophy/free-sw.fr.html

2FAQ de la GPL sur les logiciels payants : http://www.gnu.org/licenses/gpl-faq.fr.html#DoesTheGPLAllowMoney

3Définition de l’Open Source sur le site de l’OSI : http://www.opensource.org/docs/definition.php

 

Parmi les différents types de licence Logiciel Libre, certaines permettent la modification et la redistribution du logiciel sans contrainte, et autorisent notamment des dérivés « propriétaires », par exemple sans mise à disposition des codes sources.

D’autres ont comme caractéristique d’exiger qu’un logiciel dérivé conserve le statut de Logiciel Libre de l’original. Cette caractéristique est connue sous le terme de « copyleft ». Il s’agit du principal point de débat, voire d’incompréhension, sur la question des licences.

Le but poursuivi par le système de « copyleft » est de construire un ensemble de logiciels libres qui ne puisse que croître, puisqu’on ne peut qu’y ajouter du logiciel, le principe du « copyleft » interdisant à un logiciel et à ses dérivés de quitter ce « pot commun ».

La typologie classique des licences Logiciel Libre comprend deux ensembles principaux, licences avec ou sans « copyleft », et un cas spécial : le domaine public. Cette classification est complétée par des éléments sur la compatibilité des licences libres entre elles et la valeur contractuelle des licences.

  • Domaine public : peu de logiciels sont placés dans le domaine public. La plupart du temps, il s’agit de courts exemples ou de démonstrations de fonctionnalités. En pratique, si un auteur se contente d’écrire dans l’introduction du logiciel « diffusion dans le domaine public », il est néanmoins couvert par le droit d’auteur.

  • Licences sans « copyleft », dites « type BSD » : la caractéristique de ces licences est de ne pas obliger à conserver la même licence pour une œuvre dérivée. Le code des logiciels utilisant ces licences peut donc être intégré dans du logiciel propriétaire ou du Logiciel Libre1 ou celle de PostgresSQL2, mais aussi la licence X11 de l’interface graphique X11, la licence Apache3 de l’Apache Software Foundation (serveur web Apache, Tomcat), la licence française CeCILL-B4. Certaines de ces licences ont des particularités issues de leur longue histoire qui peuvent rendre leur usage difficile pour un nouveau projet. Cependant, les projets actuels ont adopté des licences BSD dites « modifiées » (par rapport à la licence BSD originale) simplifiant leur intégration. avec « copyleft ». Il existe plusieurs licences très proches dans cette famille, les licences BSD proprement dites, par exemple la licence du projet Free BSD

  • Licences avec « copyleft » : ces licences exigent qu’un logiciel dérivé conserve son statut de Logiciel Libre, notamment par la fourniture du code source de la version modifiée. En pratique, cela signifie qu’il n’est pas possible de diffuser un logiciel propriétaire incorporant du code utilisant une telle licence. La principale licence de ce type est la GNU General Public License5 (GNU GPL) de la FSF. Elle est utilisée par le noyau Linux et l’ensemble des projets GNU, dont l’environnement Gnome, le compilateur GCC et les principaux utilitaires d’une distribution dite GNU/Linux, et depuis quelques mois l’implémentation Java de Sun Microsystems. D’autres licences de ce type sont la Lesser General Public License (LGPL) de la FSF, qui offre la possibilité de lier dynamiquement le programme à une application propriétaire. Cette licence est typiquement utilisée pour des bibliothèques, dont la bibliothèque C du projet GNU. La LGPL est notamment utilisée par le projet OpenOffice.org, la plupart des développements du consortium ObjectWeb, et le projet JBoss. La licence CeCILL v26 est une licence francophone compatible avec la GPL, proposée par le CEA, le CNRS et l’INRIA. Enfin, des licences particulières comme la Common Public Licence (origine IBM) ou la Eclipse Public License7 (projet Eclipse) ont un fonctionnement de type « copyleft ».

1The Free BSD copyright : http://www.freebsd.org/copyright/freebsd-license.html

2PostgreSQL copyright : http://www.postgresql.org/docs/faqs.FAQ.html#item1.3

3Apache License version 2.0 : http://www.apache.org/licenses/LICENSE-2.0.html

4CeCILL licence française de Logiciel Libre : http://www.cecill.info/licences.fr.html

5GNU General Public License : http://www.gnu.org/copyleft/gpl.html

6Licence CeCILL [Ce(A)C(nrs)I(NRIA)L(ogiciel)L(ibre)] : http://www.cecill.info/licences.fr.html

7Eclipse Public License : http://www.eclipse.org/legal/epl-v10.html

 

Il faut noter qu’il est tout à fait possible d’incorporer des logiciels libres dans un développement interne sans se préoccuper de la licence ou du statut « copyleft » des différents composants si aucune diffusion n’est envisagée. Néanmoins, il est souhaitable de connaître le statut des différents composants au cas où la question de la diffusion se poserait un jour (cas de la réutilisation par une société filiale, par exemple).

Deux précisions utiles sur la licence GPL :

  • La liberté d’exécuter le logiciel est un droit consenti par les ayants droit du logiciel (au sens du droit d’auteur) qui ne nécessite pas l’acceptation d’un contrat de la part

  • de l’utilisateur. Voir à ce sujet la FAQ de la GPL1 ou même une explication du juriste de la FSF2.

  • L’obligation de fournir le code source ne s’applique que vis-à-vis des tiers auxquels le logiciel est diffusé. Par exemple, il n’est pas nécessaire de communiquer explicitement les modifications vers les auteurs initiaux ou des tiers non destinataires du logiciel3 modifié.

1FAQ de la GPL (en français) au sujet de l’acceptation de la licence : http://www.gnu.org/licenses/gpl-faq.fr.html#ClickThrough

2Article de Eben Moglen au sujet de la GPL, page 2 : « The license does not require anyone to accept it in order to acquire, install, use, inspect, or even experimentally modify GPL’d software. », http://moglen.law.columbia.edu/publications/lu-12.pdf

3FAQ de la GPL au sujet de la redistribution : http://www.gnu.org/licenses/gpl-faq.fr.html#GPLRequireSourcePostedPublic

 

Dans un domaine proche, il existe des licences orientées « contenu multimédia » ou « documentation », on peut ainsi citer la GNU FDL1 et les licences Creative Commons. Ces licences ne sont pas étudiées plus avant dans ce document, car il est improbable de trouver des logiciels utilisant ces licences qui ne sont pas adaptées à du code source. Par exemple, un code sous Creative Commons peut facilement être incompatible avec la définition du Logiciel Libre (restrictions sur les partie modifiables, restrictions quant à la diffusion commerciale, etc).

1GNU FDL : GNU Free Documentation License, licence relevant du droit d’auteur produite par la Free Software Foundation utilisée pour les écrits (documentations, textes…)

 

La nouvelle licence EUPL, approuvée en janvier 2007 par le programme Interoperable Delivery of European eGovernment Services to public Administrations, Business and Citizens de la Commission européenne (IDABC), vise à doter l’UE d’un outil efficace pour ses projets. Or, d’une part le besoin d’avoir un équivalent local de la GPL semble présent dans de nombreux pays (dont la France), et d’autre part la Commission européenne dispose d’une forte capacité d’incitation à travers les projets de recherche européens. On peut donc imaginer un bel avenir pour cette licence d’ici à quelques années.

En parallèle, l’initiative française CeCILL semble connaître un succès réel pour les projets issus de l’INRIA, du CNRS ou des administrations centrales. On constate, en observant les statistiques de la forge de l’ADULLACT1 (projets orientés collectivités territoriales), que la licence GPL la devance encore : environ 105 GPL, 5 LGPL, 25 CeCILL, 25 BSD. Sur la forge Admisource23 privilégie aujourd’hui la licence LGPL pour la plupart de ses développements, dont le serveur d’application Jonas. (orientée administrations centrales), on observe 7 projets en licence CeCILL pour 8 projets en GPL. De son côté, le consortium ObjectWeb

1Association des développeurs et des utilisateurs de logiciels libres pour l’administration et les collectivités territoriales (ADULLACT) : http://www.adullact.org

2Admisource : http://admisource.gouv.fr

3Licences des projets ObjectWeb : http://solutions.ow2.org

 

La licence GPL version 2 datant de 1991, les évolutions des lois et des techniques ont amené la FSF à mettre à jour la licence GPL : depuis juin 2007, la version courante de la licence GPL est la GPL version 3. La GPLv2 reste néanmoins toujours valide. La réécriture de la GPL ne change pas ses principes fondamentaux, les mises à jour concernent les aspects suivants :

  • Clarification et internationalisation : la nouvelle rédaction de la licence vise à faciliter une interprétation identique dans tous les systèmes juridiques à travers une définition précise des termes employés. Les concepts techniques comme la diffusion de logiciel ont été adaptés à l’état de l’art actuel.

  • Protection spécifique contre le phénomène dit de « tivoïsation », c’est-à-dire la mise en place d’un verrou matériel rendant impossible la modification d’un logiciel GPL (par exemple dans un système embarqué). Ce type de blocage n’est plus permis dans le cadre d’un produit destiné au grand public. Le verrouillage reste possible au sein d’une organisation ou entre professionnels, ce qui revient à dire en pratique que le destinataire doit accepter le verrouillage du logiciel par un procédé matériel pour que la licence soit respectée.

  • Protection explicite vis-à-vis des brevets logiciels : diffuser ou contribuer à un logiciel GPL implique dorénavant de concéder une licence sur d’éventuels brevets couvrant le code contribué. En pratique, cela revient à interdire de diffuser un code dont l’utilisation serait bridée par un brevet. Cette protection s’accompagne de clauses antidiscriminations qui visent à réduire la portée d’accords privilégiant une classe d’utilisateurs par rapport aux autres (par exemple les clients d’un fournisseur particulier).

  • Dans certaines législations, il n’est pas légal de modifier un dispositif de contrôle d’usage (DRM). La GPLv3 mentionne donc explicitement que l’auteur du logiciel couvert par la licence renonce à ce que son logiciel soit considéré comme un DRM.

  • Modularité et compatibilité : la GPLv3 comporte un système modulaire permettant des extensions pour certains éléments : permissions additionnelles et extensions contractuelles, clauses de garantie et de responsabilité, stipulations sur les marques… Ce système permet à la licence GPLv3 d’être maintenant compatible avec la licence Apache.

Il est encore trop tôt pour évaluer toutes les conséquences du passage de la GPLv2 à la GPLv3 sur l’écosystème du Logiciel Libre, mais l’opinion dominante parmi les acteurs du domaine est :

  • L’ensemble des projets GNU, dont des briques de base comme la bibliothèque C, migrera très vite vers la GPLv3.

  • Le noyau Linux restera longtemps en GPLv2 (il ne contient pas la clause facilitant le passage à une version ultérieure de la version GPL). Toutefois, les conséquences sont limitées, Linux étant techniquement indépendant du reste de l’écosystème GPL.

  • La plupart des autres projets GPLv2 passeront progressivement en GPLv3, notamment en raison de leurs dépendances en cascade d’autres composants GPL.

  • Les grands acteurs du marché en charge de projets importants utilisant la GPL (Sun Microsystems, Red Hat…) pourraient suivre rapidement.

  • Certains acteurs du marché ayant utilisé par le passé des failles de la GPLv2 (Tivo, Novell) devront revoir une partie de leurs accords commerciaux ou rester cantonnés en GPLv2.

  …

Des logiciels comme le système GNU/Linux, le navigateur Firefox ou la suite bureautique Open Office sont des exemples connus de logiciels libres de plus en plus populaires, installés couramment en entreprise ou chez les particuliers. Par ailleurs, le bon fonctionnement d’Internet repose sur des logiciels libres depuis son origine, tout comme celui de salles de marchés (BNP Paribas) ou d’avions (Rafale, A380). On trouve du Logiciel Libre dans des périphériques électroniques domestiques comme la Freebox, la Neufbox, la Livebox… mais aussi dans des guichets automatiques ou des assistants personnels (PDA).

  …

Le Logiciel Libre est un bien non marchand et ceux qui le développent contribuent à la diffusion au plus grand nombre de la connaissance scientifique, d’un savoir-faire technique et de technologies permettant l’accès au savoir. Le projet GNU projet phare du Logiciel Libre a d’ailleurs été classé Trésor du Monde par l’UNESCO.

  • La somme des logiciels libres de qualité raisonnable représente un investissement minimum de 12 milliards d’euros. Ceci représente au minimum 131 000 personnes/an, ou une contribution annuelle de 800 millions d’euros, dont la moitié provenant de développeurs basés en Europe. En terme de service, la part du Libre pourrait représenter 32% du marché des services dans l’informatique en 2010. (« The impact of Free/Libre/Open Source Software on innovation and competitiveness of the European Union », janvier 2007, disponible sur le site de la Commission européenne)1

  • En 2004, 80% des entreprises du CAC 40 et 56% des administrations et des collectivités territoriales françaises utilisaient des logiciels libres (PAC, 2004). 67% des entreprises utilisaient des logiciels libres, 16% envisageaient de le faire en 2005, et seulement 17% n’avaient aucune utilisation prévue à court terme. (InformationWeek, novembre 2004)

  • En 2005, près de 90% des entreprises envisageaient de basculer leurs serveurs Windows vers Linux dans l’année à venir. (InformationWeek, Research Brief Linux Outlook, février 2005), 70% des serveurs web dans le monde étaient des serveurs libres (Netcraft, novembre 2005 portant sur 74 572 794 sites web).

  • En France, pour 2006, l’administration française aura consacré 9% de son budget informatique à des développements ou des plates-formes libres, charges de personnel incluses, contre 6% en 2005. Soit 900 millions d’euros et 15% de l’ensemble du marché des services IT de l’administration française avec plus de 12% par an de croissance prévue durant les deux prochaines années (Markess International, avril 2006).

  • Ratio immigration/émigration des développeurs de Logiciel Libre : la France bonne dernière bien que parmi les pays où les ingénieurs étudiants participent le plus à des projets Logiciel Libre1.

1http://ec.europa.eu/enterprise/ict/policy/doc/2006-11-20-flossimpact.pdf

 »

Posted in logiciel libre, migration vers le libre, python | Tagué: , , , , , , , , | Leave a Comment »

Développement système du noyau et des pilotes GNU/Linux

Posted by patrick sur décembre 11, 2007

Pour le développement système sous GNU/Linux la référence pour moi reste le livre de Pierre Ficheux « Linux Embarqué ». Il a écrit un certain nombre d’articles dans GNU/Linux magazine concernant le développement système sous GNU/Linux. Attention cependant: certains articles sont relativement anciens et méritent d’être largement réactualisés. Ils peuvent néanmoins servir de base pour une introduction et sont intéressants à titre historique.

  • Création d’un serveur PPP sous LINUX (« Septembre 1998. Cet article décrit la mise en place d’un serveur PPP sous LINUX. Ce serveur pourra être accessible depuis n’importe quel système équipé d’un modem et d’un logiciel d’accès à un réseau distant supportant le protocole PPP. Ceci permettra par exemple de créer simplement un BBS (Bulletin Board System) accessible depuis un navigateur standard. Ce type d’accès est très interessant pour donner la possibilité à des utilisateur éloignés d’accèder à un Intranet d’entreprise« )
  • Présentation du protocole UUCP(« Cet article présente l’utilisation et la configuration du protocole UUCP (Unix to Unix CoPy) sur LINUX. UUCP permet de manière très efficace de transférer des fichiers, du courrier électronique ou bien des news.« )
  • Ports séries sous LINUX (« Le but de cet article est la compréhension du fonctionnement des ports séries sous LINUX. L’article abordera également la configuration des ports séries depuis le shell sh ainsi qu’en langage C.« )
  • Multi-threading sous LINUX (« article d’avril 1999 à mettre à jour bien sûr: Cet article est une introduction à la programmation multi-threads sous LINUX. Les exemples de programmation utilisent la bibliothèque LinuxThreads disponible en standard sur la majorité des distributions LINUX…« )
  • Un systeme de transmission vidéo sur TCP/IP(« décembre 1998. Cet article décrit un système de transmission vidéo sur TCP/IP développé sous LINUX à partir d’un boiter de compression vidéo autonome appelé ViewCOM et développé par la société COM One à Bordeaux« )
  • Pilotes de périphériques sous LINUX (« mars 2000 : Cet article est une initiation à l’écriture de pilotes de périphériques (device drivers) sous LINUX. Les concepts généraux présentés dans l’article sont illustrés d’un petit exemple de pilote en mode caractère (char driver). La lecture de l’article demande quelques connaissances en langage C.« )
  • Programmation audio sous LINUX (« janvier 2000: Cet article est une introduction à la réalisation d’applications audios sous LINUX. Nous présenterons successivement la configuration du noyau LINUX pour le support audio, l’utilisation des fichiers spéciaux (devices) utilisés par le noyau et une introduction à la programmation en C de l’API audio de LINUX. Dans une dernière partie, nous présenterons un petit exemple d’application réalisant du streaming audio« )
  • Construction d’un système LINUX embarqué (« septembre 2000 : Le but de cet article est de présenter les différentes étapes de la réalisation d’un système LINUX embarqué (embeddable LINUX). L’article détaille les différents éléments majeurs du système ainsi que les étape de la réduction de l’occupation mémoire et disque. Nous aborderons également quelques techniques pratiques propres à la réalisation de systèmes embarqués. L’article s’appuie sur une réalisation personnelle de l’auteur. Il ne s’agit pas de la présentation de la revue d’un système embarqué de plus mais plutot d’une démarche pédagogique« )
  • Pilotes de périphériques PCI (« juin 2002: Cet article est un introduction à la gestion du bus PCI sous LINUX ainsi qu’à l’écriture de pilotes dédiés aux cartes PCI. C’est également une suite et une mise à jour de l’article Introduction à l’écriture de pilotes de périphériques LINUX paru en mai 2000 dans ce même journal. Même si certains concepts généraux liés aux pilotes et aux modules du noyau sont rappelés dans cet article, sa compréhension nécessite quelques connaissances préalables ou bien la lecture de documents cités dans la bibliographie en fin d’article« )
  • Temps réel sous LINUX (mai 2003, « Cet article a pour but de réaliser un tour d’horizon des solutions temps réel dans l’environnement LINUX. Après une définition du concept de système temps réel, les auteurs
    s’attacheront à décrire les solutions logicielles disponibles ainsi que quelques exemples de résultats obtenus…
    « )
  • Embarquez Linux! (ou Linux everywhere) (septembre 2004, « Le but de cet article est de décrire quelques techniques utilisables pour embarquer une distribution Linux réduite sur divers supports de faible capacité (CompactFlash, Disk On Module ou DoM, clé USB, Disk On Chip ou DoC). Après avoir présenté les différents supports étudiés, nous détaillerons
    une structure de système permettant de garantir une sécurité maximale de l’installation tout en minimisant l’empreinte mémoire
    . »)
  • Programmation de l’API Video4Linux (mars 2005, « Cet article décrit l’interface de programmation Video for Linux (plus communément appelée V4L) destinée à l’utilisation de périphériques de capture vidéo comme les cartes d’acquisition ou les caméras. Outre l’utilisation des pilotes existants, l’article décrit également les bases de l’écriture d’un
    pilote de périphériques V4L (caméra virtuelle) dans le cas des noyaux 2.4 et 2.6.
    ..Le problème du pilotage des périphériques vidéos est assez complexe car il existe une multitude de possibilités tant au niveau du type de périphérique (caméra, carte d’acquisition), des caractéristiques
    de ces périphériques (couleur ou noir et blanc, taille d’image, résolution) de l’architecture matérielle (type de circuit d’acquisition utilisé) ou des modes de connexion (bus PCI, USB, parallèle). Pour simplifier les choses, les développeurs du noyau Linux ont défini une interface appelée Video for Linux (Video4Linux ou V4L
    ). »)
  • Compilation croisée sous Linux et Windows (mars 2005, « Cet article décrit la mis en place d’une chaîne de compilation croisée utilisable dans l’environnement Linux x86 ou bien Windows 2000 et XP. Au cours de ce document nous décrirons des tests réels sur une cible Linux ARM mais les concepts décrits restent valable pour une autre architecture type
    PowerPC ou MIPS.
    ..Dans la série d’articles consacrés aux aspects industriels et embarqués de Linux publiés précédemment, nous avons toujours utilisé un environnement Linux x86. Même si cet environnement est très répandu, il est loin d’être le seul utilisé dans ce type d’application. En effet, d’autres processeurs comme l’ARM ou le PowerPC sont parfois mieux adaptés que l’architecture x86.
    Cependant, la plupart des développeurs utiliseront un PC x86 (Linux ou Windows) comme poste de travail et il est donc nécessaire de mettre en place un chaîne de développement croisée permettant de développer du code non-x86 sur un PC. Dans cet article, nous allons décrire plusieurs solutions open sources disponibles utilisables sur Linux x86. Ne expliquerons également comment mettre en oeuvre certains de ces outils sur plate-forme Windows en utilisant l’environnement d’émulation
    CYGWIN. A titre d’exemple, nous mettrons en place et testerons une chaîne de développement pour cible Linux ARM.
    « )
  • Quelles solutions pour Linux embarqué (décembre 2005, « Le but de cet article est de replacer Linux dans le contexte des systèmes industriels et embarqués. Le précédent article « Introduction aux systèmes embarqués » a permis de définir la terminologie et le champ d’application de cette technologie. De notre côté, nous nous attacherons à expliquer
    brièvement quels sont les avantages de Linux dans cet environnement ainsi que les composants logiciels disponibles (compilateurs, débogueurs, extensions temps-réel, etc.) Nous effectuerons également un tour d’horizon des autres solutions disponibles tout en positionnant
    Linux parmi cette liste et ce en s’aidant de quelques données statistiques. Les références à différents articles, site web ou ouvrages traitant plus précisément des sujets cités sont données en bibliographie.
    La qualification de logiciels libre nécessite de satisfaire à un certain nombre de critères. La liste complète est disponible auprès du site http://www.opensource.org mais nous pouvons retenir trois critères fondamentaux pour le logiciel embarqué:
    • La disponibilité du code source
    • La possibilité de réaliser des travaux dérivés
    • La redistribution sans royalties
    La disponibilité du code source est un critère fondamental car contrairement au logiciel classique (comme le logiciel bureautique), la durée de vie d’un logiciel embarqué est particulièrement longue
    car elle est liée à la durée de vie de l’équipement matériel qui l’héberge. Des contraintes économiques et légales font que certain
    s biens de consommation doivent être maintenus au moins 10 ans. Cette durée est parfois beaucoup plus longue dans le cas de matériel militaire ou
    scientifique. De ce fait il sera nécessaire de faire évoluer ce logiciel sur un matériel considéré comme obsolète et ce indépendamment des aléas économiques comme par exemple la disparition d’un éditeur de logiciel. Certaines licences associés aux logiciels libres (comme la GPL ou la LGPL) imposent la disponibilité du code source « ad vitam aeternam » et ce dernier ne pourra donc être séquestré même pour de sombres raisons légales ou financières.
    La réalisation de travaux dérivés est un avantage compétitif certain. Il paraît absurde de nos jours de développer une bibliothèque de traitement JPEG ou XML. Ce n’était pas forcément le cas il y a encore quelques années, ou bon nombre de petites entreprises , par ignorance ou par obstination, se lançaient dans de coûteux développements sans considérer l’existant déjà disponible à l’époque au travers du logiciel libre (je parle malheureusement en connaissance de cause !). Le problème des

    licences est à considérer avec soin dans le cas du travail dérivé mais cela n’a rien d’insurmontable et des règles simples découlant du bon sens suffisent largement au respect de licences comme la GPL ou la LGPL. La redistribution sans royalties est un atout économique évident dans le cas de la diffusion en masse d’un équipement. Avec le critère de disponibilité du code source (lui-même inspiré par des contraintes économiques) c’est certainement un des principaux arguments motivant l’adoption des logiciels libres en remplacement de solutions propriétaires. »)
  • Busybox « in a nutshell » (novembre 2005, PDF. « Cet article décrit la mise en place rapide d’un système Linux embarqué autour
    d’un noyau 2.6 et du composant libre Busybox (http://www.busybox.net ). Il fait suite aux diverses publications de l’auteur sur ce sujet dont les références sont citées en annexe bibliographique. L’article décrira l’exemple d’un PC x86 mais les concepts sont bien entendu adaptables à d’autres architectures. Le projet buildroot utilisant BusyBox et uClibc sera brièvement présenté en fin d’article sous forme d’un exemple sur architecture ARM9.
    « )
  • Temps réel sous Linux (reloaded) (mars 2006, PDF. Cet article est une mise à jour du dossier Temps réel sous Linux paru en juillet 2003
    dans le numéro 52 de Linux Magazine. Après une définition des concepts liés au temps réel, nous nous attacherons à décrire les solutions Linux disponibles en insistant particulièrement sur le composant XENOMAI 2. La lecture et la mise en application des exemples décrits nécessite une
    bonne connaissance « système » de Linux en particulier sur la compilation du noyau. Les codes source des programmes présentés sont disponibles sur http://pficheux.free.fr/articles/lmf/hs24/realtime/hs24_test.tgz
    )
  • Routeur Wifi sous Linux (mars 2006, PDF. « Cet article décrit la mise en oeuvre d’un routeur WIFI sous Linux et utilisant une architecture
    compatible x86 (VIA C3). Le projet fut démarré en 2003 ce qui explique les choix techniques qui peuvent aujourd’hui paraître quelque peu désuets (noyau 2.4.20, pas de Busybox, etc.). Il est bien évident qu’une architecture plus récente conduirait au même résultat sans pour cela changer réellement la démonstration. Le projet est totalement viable puisque qu’il a conduit à un système utilisé dans un environnement domestique 24h/24H depuis 3 ans sans aucun redémarrage, mise à part les coupures de courant ou quelques évolutions du logiciel »
    )

A voir:

Des articles plus généraux:

  • http://fr.wikipedia.org/wiki/Syst%C3%A8me_temps_r%C3%A9el (« En informatique industrielle, on parle d’un système temps réel lorsque ce système informatique contrôle (ou pilote) un procédé physique à une vitesse adaptée à l’évolution du procédé contrôlé….Les systèmes informatiques temps réel se différencient des autres systèmes informatiques par la prise en compte de contraintes temporelles dont le respect est aussi important que l’exactitude du résultat, autrement dit le système ne doit pas simplement délivrer des résultats exacts, il doit les délivrer dans des délais imposés…« )
  • http://systeme.developpez.com/cours/#C3 (« des cours sur l’architecture, les systèmes embarqués, les systèmes temps réels, les systèmes d’exploitation, les systèmes répartis, les réseaux, le parallèlisme et les grilles de calcul, la sécurité, la compression audi et vidéo, les annuaires LDAP »)

Posted in Développement logiciel, GNU/Linux | Tagué: , | Leave a Comment »