dimanche 22 juin 2008

Le Logiciel Libre expliqué à ma Maman (et à toute personne non portée sur l'informatique...)

Le logiciel libre est une notion importante en informatique actuelle. Mais si n'importe quel geek, informaticien ou programmeur maîtrise ce concept, ce n'est pas le cas du grand public et particulièrement des personnes pour qui l'informatique n'est qu'un outil nécessaire, mais souvent un peu compliqué.

Le but de cet article est donc de tenter d'expliquer à ma maman, et par extension à toute personne peu portée sur l'informatique ce qu'est un logiciel libre.
Dans ce cadre, il est très probable que je fasse des raccourcis, analogies ou approximations sur certaines notions ou concepts liés ; à l'attention des personnes pointilleuses sur ces points qui font parfois débat (ou troll), n'hésitez pas à utiliser les commentaires afin de mettre les choses au point, point (poin poin !).
Par ailleurs, seuls les geeks semblent maîtriser le web et avoir le temps de lire les pages présentées dans les liens (et d'autres choses, comme la navigation par onglets sous Firefox ^^) : donc, la plupart des liens pointent vers une simple image (Une image vaut mille mots.).

Qu'est-ce qu'un logiciel ?

Commençons par le commencement ! Word, Excel, Firefox, Outlook Express et iTunes sont des logiciels. C'est probablement ceux qu'utilisent le plus ma maman. Mais ce ne sont que quelques exemples. Window$, MacOS X et Linux sont également des logiciels : ce sont des systèmes d'exploitation (c'est à dire le logiciel qui gère l'interaction avec le matériel, écran, clavier, etc ainsi que la base pour les autres logiciels cités en premier.).
Mais il y a également des logiciels plus "discrets" pour l'utilisateur de base : les "drivers" (ou pilotes) qui font fonctionner du matériel (imprimante, webcam, etc...) sur un PC, les systèmes assurant les transmissions bancaires, les applications web (comme Gmail, ou ce blog), le manager de vol d'un avion, un code calcul scientifique, le système d'un téléphone portable, un guichet de retrait de monnaie ou encore la synchronisation des feux dans les grandes agglomérations.

Pour résumer, sur un ordinateur (au sens large), un logiciel est toute la partie non-matérielle. En anglais, on parle de "Harware" pour le matériel (partie "dure") et de "software" pour les logiciels (partie "légère" ou immatérielle).

Comment construit-on un logiciel ?

Sans trop rentrer dans la technique, quelques notions sont utiles pour la suite.
Tout logiciel est construit à partir d'un "code source" qu'écrit le programmeur, développeur ou codeur (ou ingénieur logiciel, mais celui-ci, il se la pète un peu je trouve ^^). De quoi s'agit-il ? Il s'agit d'un texte, écrit dans un langage spécialement conçu pour "communiquer avec l'ordinateur". Il existe de nombreux langages permettant d'écrire du code.
Le code source peut être défini comme un ensemble d'ordre et de définitions d'ordres que le codeur donne à la machine. Du coup, le code source d'un logiciel peut être comparé à une recette de cuisine à laquelle on ajoute une définition des gestes techniques (abricoter, brider, delayer, etc...).
Par exemple, ci-dessous voici à quoi pourrait ressembler le code permettant d'ouvrir une fenêtre contenant une horloge à l'heure :

Programme Fenetre-Horloge :
ouvrir fenetre
fenetre contient horloge(heure_actuelle)
toutes les 1 secondes : mettre l'heure à jour dans horloge
fin programme


Bien sûr il s'agit de pseudo-code : c'est à dire un langage de programmation que la machine ne comprendrait pas. Mais dans l'esprit, on n'est pas très loin de ce à quoi pourrait ressembler un vrai code source. La preuve, voici un vrai programme faisant ce que je viens de décrire, en Ruby (Ruby est donc un "vrai" langage de programmation) :

stack do
background black
para @time.strftime("%a"),
span(@time.strftime(" %b %d, %Y "), :stroke => "#ccc"),

strong(@time.strftime("%I:%M"), :stroke => white),
@time.strftime(".%S"), :align => "center", :stroke => "
#666"
end

(source : hackety.org par Why's the Lucky Stiff)

C'est déjà moins compréhensible, mais ça marche ^^ !

Qu'est-ce qu'un logiciel libre ?

Un logiciel libre est un logiciel dont la licence dite libre donne à chacun le droit d'utiliser, d'étudier, de modifier, de dupliquer, de donner et de vendre ledit logiciel.
Cette citation Wikipedia est selon moi une bonne définition de ce qu'est un logiciel libre.
Mini-Tux, une mascotte de Linux (libre !)

Contrairement à ce qu'on pourrait facilement penser, un logiciel libre n'est pas forcément un logiciel gratuit. C'est sa licence qui est libre, c'est à dire le texte "juridique" définissant les droits de l'utilisateur sur le logiciel. Même si la majorité des logiciels libres sont gratuits, il en existe quelques un payants, ou en version payante (on y reviendra).

En l'occurrence, l'utilisateur, quel qu'il soit, à le droit d'utiliser le logiciel comme bon lui semble.

Contrairement à la plupart des logiciels propriétaires (non-libres donc), l'utilisateur a également le droit de copier, donner, vendre ce logiciel dans certaines conditions. Il n'y a donc quasiment pas de piratage dans le monde du logiciel libre puisqu'on est libre de dupliquer et de distribuer ces logiciels. Je dis quasiment car les conditions ne sont parfois pas respectées : par exemple une condi tion de redistribution peut être de continuer à montrer le code source (ce que ne font pas toujours les entreprises).

Le droit de vente peut paraître surprenant : pourquoi vendre un logiciel qui peut ensuite être redistribué gratuitement ? En pratique, peu de logiciels libres sont payants. La plupart du temps, le code source du logiciel est gratuit, mais c'est le support associé qui est rémunéré. Par exemple, le logiciel de développement que j'utilise actuellement est libre, mais mon entreprise paye la société qui le distribue pour corriger rapidement les bugs que nous rencontrons, ou ajouter de petites fonctionnalités. Je peux par contre utiliser la version amateur, sans support, gratuitement, à la maison.

L'utilisateur a également le droit d'"étudier" le logiciel : en pratique, cela signifie qu'il a le droit d'accéder au code source du logiciel pour comprendre (ou essayer de comprendre) comment celui-ci fonctionne. On parle alors de logiciel "Open-source" puisque ses sources sont accessibles à tous ; "ouvertes". Bien entendu, ce droit est surtout destiné aux développeurs : ceux qui sont capables de lire le code source.
Hormis le côté éducatif, ce droit a un avantage direct pour un logiciel libre : les bugs et autres erreurs dans le code source sont visibles par tous et donc, le plus souvent, rapide ment détectés. Cela explique également pourquoi les logiciels libres les plus utilisés proposent des mises à jours régulières : les erreurs sont fréquemment corrigées et on en fait profiter les utilisateurs le plus rapidement possible.
Enfin, dans le domaine scientifique, il y a un autre intérêt direct : la vérification. Dans un code de calcul notamment, il devient possible de vérifier les formules et algorithmes qui ont été employés. En cela, le logiciel libre garde l'esprit scientifique (particulièrement mathématique / pas de brevets en maths) qui veut que le savoir soit accessible à tous.

Le logiciel libre en pratique

Beaucoup de logiciels libres sont soutenus par une "communauté". Ce terme, qui fait un peu penser à "secte", "hippy" ou "communisme", désigne simplement un groupe de personnes soutenant un logiciel libre. Il s'agit bien sur de programmeurs qui le développent, mais aussi de simples utilisateurs qui l'utilisent bien sûr, mais aussi qui le testent (et donc préviennent de certains bugs), le diffusent, écrivent de la documentation (aide, wiki, manuels, etc...), font sa publicité, aident les débutants ou même le soutiennent financièrement.

Ce côté communautaire fait souvent croire que le logiciel libre est uniquement l'affaire de quelques passionnés, et que les entreprises ne les emploient jamais. Cela est faux.

Pour le simple utilisateur, un logiciel libre a plusieurs avantages. Comme on l'a vu précédemment, il est souvent gratuit, facilement trouvable puisque librement distribuable et mis à jour régulièrement.
Ensuite, du fait de l'ouverture du code, les logiciels libres sont souvent personnalisables puisque n'importe qui peut proposer un module complémentaire (comme un aspect graphique ou un add-on sous Firefox).
Enfin, de par la compétition (pour ne pas dire guerre) entre les logiciels libres et les logiciels propriétaires, les communautés attachent beaucoup d'importance à aider les nouveaux arrivants, notamment sur les forums d'aide (en principe du moins...).

Un aspect important du libre en informatique réside dans les standards des formats, ce point étant vital pour les utilisateurs de base et probablement encore plus pour les entreprises. Un format, c'est les dernières lettres d'un fichier : par exemple .jpeg ou .gif pour une image, .mp3 ou .ogg pour une chanson, .doc ou .rtf pour un document texte ou encore .xls pour un classeur Excel.
Plus que trois lettres après un point, ces formats désignent la façon dont la machine écrie et lit ces documents : c'est une représentation de la donnée de départ en langage machine ; en règle générale, un être humain ne peut pas lire ces formats.
Le problème est qu'il existe des formats propriétaires. Une entreprise peut donc décider de déposer une licence propriétaire, ou un brevet sur un format qu'elle aurait "inventé". C'est le cas pour Microsoft avec le .doc et le .xls ou le .aac par Sony (entre autres). Alors, elle peut décider de "libérer" son utilisation ou non.
Dans tous les cas, ces formats posent problèment car d'une part, une entreprise peut décider d'abandonner un format (si Microsoft abandonne le .doc, comment ouvrir ses documents dans 10 ans ?) ou d'autre part de restreindre sa diffusion en faisant payer les producteurs d'autres logiciels l'employant. Ou encore de se réserver entièrement les droits sur un format : par exemple pour de l'audio pour écouter un tel format créé par Toshiba, vous devez acheter un lecteur Toshiba (simple exemple).

En général, les logiciels libres préfèrent créer ou/et employer des formats libres et standards assurant ainsi la compatibilité entre les différentes applications (par exemple un format de tableau pourrait être lisible par différents logiciels tableurs -comme Excel-) ainsi que la pérennité des documents.

Quelques exemples de logiciels libres (propriétaires) :

  • Firefox ; navigateur web (InternetExplorer, Safari, Opera...)
  • Thunderbird ; outil de messagerie (Outlook Express...)
  • Azureus, EMule ; peer-to-peer (?)
  • OpenOffice.org ; suite bureautique (Microsoft Office...)
  • Linux ; système d'exploitation (Windows, MacOS)
  • The Gimp ; dessin et traitement d'image (Paint, Photoshop...)
  • SciLab ; outil scientifique (MatLab, Maple...)
Références :


Alors Maman, tu as compris ?

Les commentaires sont ouverts !

jeudi 12 juin 2008

Firefox 3 - D-Day !

Je ne vais pas vous faire étalage des avantages de Firefox sur la concurrence dans le monde merveilleux des navigateurs web. Non. Mais je vous encourage vivement à participer au Download Day de Firefox 3.

Il s'agit d'essayer d'établir le record du plus grand nombre de téléchargements pour un logiciel en 24H. Amusant non ? Outre le fait que c'est un évènement marketing sympa, c'est l'occasion de découvrir, ou mettre à jour l'un des meilleurs navigateurs disponibles sous toute plate-forme.

Vous pouvez déjà effectuer une promesse de téléchargement sur la carte du monde (la France n'est d'ailleurs pas si mal placée ^^) ou patienter gentiment jusqu'à... Mardi 17 Juin (selon Silicon.fr, qui a réalisé il y quelques jours une interview de Tristan Nitot, Prez' de Mozilla Europe, sur la sortie du dernier panda rouge).

Bon téléchargement !

samedi 7 juin 2008

Ruby Duck-Safe interface

Suite à un précédent article sur DiamondBack Ruby, j'ai un peu réfléchis à la question de la sécurisation de l'appel de fonctions/procédures/méthodes, au niveau des types dans un langage dynamique tel que Ruby (/Python,/Perl/Etc...).

Finalement, quel est le problème ? Quelque soit le paradigme, il se situe au niveau de la capacité d'une fonction/procédure/méthode à traiter ses arguments en fonction de leur type, classe ou comportement. Problème simple donc. (Les aspects plus bas niveau sont ici peu intéressants : on est actuellement capables de les éluder).

Tout est dans la notion d'interface : dans les langages statiques, une interface n'est pas seulement un moyen d'appeler un "service" (fonction/méthode/...) mais c'est également un "contrat" qui impose des conditions sur les informations passées à l'appel (le plus souvent sur leur type). Par exemple, la fonction acheter_une_baguette ne peut se contenter de prendre 0.45 en argument : il faut que 0.45 soit en €, "de type €".

Ruby est un langage dynamique comme tant d'autres. Mais de par sa conception, sa "philosophie", il fait le choix de se concentrer sur ce que fait un objet plutôt que sur ce qu'il est : c'est le Duck Typing. On peut facilement critiquer cette approche du typage pour plusieurs raisons. Cet article sur Otaku en expose plusieurs. Pour ma part, je me contenterais de dire qu'elle réside dangereusement sur la langue (quel rapport entre Balançoire.balancer et Coupable.balancer ?).

Mais les langages statiques ne sont pas nécessairement satisfaisants sur ce point non plus. Pour faire un parallèle avec les mathématiques, on peut considérer que :

f : R -> R
x |-> x + 2

avec R l'ensemble des réels, est une déclaration de type statique.

Pour autant, f reste valable de N dans N (naturels), de C dans C (complexes), etc... Le Duck Typing assure que f est valable du moment que x possède une méthode "+", ce qui évite de redéfinir f pour chaque espace où cette fonction est valable.

Mais est-ce suffisant ? Prenons :

f : x |-> 2 / x

Dans ce cas, on doit de plus assurer que x n'est pas nul. Si mathématiquement, cela s'exprime sur l'espace sur lequel est défini x, "informatiquement" on aura le plus souvent x entier ou flottant. Les contraintes sur un argument ne se limite donc pas à son type/classe, ni à son comportement (possède méthode "+"), mais aussi à d'autres paramètres, comme son état (ici sa valeur). De plus, s'il s'agit ici d'un exemple simple : il existe probablement d'autres exemples mettant en évidence l'influence du contexte d'appel.

Je vous propose ici un module (naïf) permettant d'exprimer assez simplement, lors de l'implémentation d'une méthode, les contraintes associées à ses arguments. Le but est d'assurer ces contraintes sans pour autant surcharger le code de structures conditionnelles avec gestion d'exceptions : on déclare simplement notre contrat.

(sources également disponibles **sans fuck1n' coupure** ICI)

module Safety

# Negator for error message
@@neg_converter = {:is_a? => "is not a",
:respond_to? => "does not respond to",
:include? => "does not include",
:each_element_is_a? => "contains element(s) that is(are) not"}

# Ensure that constraints are respected
def ensure_it cstr
cstr.each do |arg, cstrs|
value = cstrs[0]
cstrs[1...cstrs.size].each do |pair|
if not value.method(pair[0]).call(pair[1]) then
raise "Argument #{arg} (#{value.inspect}) \
#{@@neg_converter[pair[0].to_sym]} #{pair[1]}."
end
end
end
end

private

# A simple example of constraint method
def each_element_is_a? klass
assertion = true
self.each do |elt|
assertion = false if not elt.is_a? klass
end
assertion
end

end


La méthode ensure_it checke les contraintes passées. Une contrainte est facilement exprimable par une méthode telle que each_element_is_a?.

Exemples :


require 'Safety'

class Fixnum
include Safety
def mult_by_plus num1, num2
ensure_it({:num1 => [num1, [:is_a?, Fixnum]],
:num2 => [num2, [:respond_to?, :next]]})
self*num1+num2
end

end

a = 1
puts a.mult_by_plus(1,2)
puts a.mult_by_plus(1,1)
puts a.mult_by_plus(1,1.0) #=> Error raised


Et :


require 'Safety'

include Safety

def potamok tab
ensure_it({:tab => [tab, [:respond_to?, :each],
[:each_element_is_a?, Fixnum]]})
val = 0
tab.each do |elt|
val += elt**2
end
val
end

puts potamok [42,33,59]
puts potamok [1,2,3,6,59.3] #=> Error raised


Toute remarque est la bienvenue.