Categories
Computer Science

L’informatique pour tous

J’ai commencé une petite liste de ressources en ligne sur l’informatique. Ce sont des cours de très bonne qualité et certains peuvent être abordés par des non-informaticien(ne)s pour leur culture générale.

Nous remarquerons que Python est souvent utilisé pour apprendre les bases de la programmation. Comme dans cet excellent cours.

Après réflexion je me suis également dit que ces ressources sont bien utiles si vous êtes trop pauvre pour acheter des livres.

Categories
Computer Technology

systemd

Voilà, comme un bon nombre de Linuxien(ne) j’utilise dorénavant systemd. Je n’ai pas vraiment un avis tranché sur ce système ni de critiques aussi virulentes qu’il est possible de trouver un peu partout sur le Web. Pour moi systemd, ça signifie d’abord que je vais devoir maîtriser une nouvelle technologie et un tas de nouvelles commandes. Ce qui m’enchante. Et puis, je trouve qu’il est parfois bien de mettre un peu de côté d’anciennes technologies. Et même si cela donne plus de travail aux administrateurs systèmes/réseaux (ceci pour ceux qui pensent encore que des binaires sont nécessaires pour configurer systemd).
Pour le moment, il faut surtout que j’identifie mieux les limites fonctionnelles de systemd. Car il faut bien le dire, systemd peut gérer un tas de choses: services, multi-seat, configuration réseau, pare-feu, etc.

systemd a amélioré le temps de démarrage de ma station fixe de travail sous Kubuntu 15.04 (environ 46 secondes, kernel et userspace) et de mon ordinateur portable sous Debian 8.0. Ce n’est cependant pas tant la vitesse qui m’intéresse, mais surtout le bon fonctionnement et les possibilités d’analyses des logs.

Concernant le fonctionnement, déjà mon démarrage est «plus propre» qu’avant. Tous les services se lancent correctement, l’affichage au démarrage n’est pas trop verbeux et est clair (homogène). Je n’ai en réalité rien de spécial à dire sur ce point (j’ai surtout gagné du temps lors du montage du NAS, qui avant me posait quelques problèmes de manière assez aléatoire).

Du côté des moyens d’analyse des logs, la commande systemd-analyze est bien pratique. Voici quelques exemples.

$ systemd-analyze dot --user --order | dot -Tsvg > systemd-dependency-graph-user.svg

Dependency graph (userspace)
Systemd dependency graph (userspace)

$ systemd-analyze dot --order | dot -Tsvg > systemd-dependency-graph-system.svg

Dependency graph (system)
Dependency graph (system)

$ systemd-analyze plot > system-services.svg

System services
System services

Le graphique ci-dessus est un peu plus parlant. Il existe aussi la commande systemd-analyze blame qui liste les services ordonnés par temps de démarrage. Ce qui peut aider à voir quel service ralenti le démarrage du système. Il faut cependant faire attention car blame ne montre pas les liens: parfois un service prend plus de temps parce qu’il attend le lancement d’un autre service.

$ systemd-analyze dot 'tor.*' | dot -Tsvg > tor.svg

Dépendances du service Tor
Dépendances du service Tor

systemctl list-units est une autre commande très pratique permettant de vérifier l’état des services après le démarrage.

Légende des graphiques:

  • black: Requires
  • dark blue: Requisite
  • dark grey: Wants
  • red: Conflicts
  • green: After
    • Finalement cette migration vers systemd est une réussite et je suis plutôt content, pour le moment. Il va tout de même falloir que je bidouille un peu plus pour me faire un avis plus précis.

Categories
Computer

Kano

Une idée géniale de cadeau de Noël pour un enfant: Kano.

Categories
Computer

Partage de liens en vrac

Voici une série de liens que je veux partager avec vous depuis quelques temps.

Categories
Computer Liberty Security

TED de Bruce Schneier: The Battle for Power on the Internet

Une autre bonne présentation de Bruce Schneier. Au yeux de certains nous deviendrons tous pirate.

Categories
Computer Programming Python

Quelques benchmarks avec Ackermann

Un billet qui va peut-être intéresser quelqu’un et répondre à une question que je me pose.

$ gcc -Wall ./ackermann.c -o ackermann-c
$ go build -o ackermann-go ./ackermann.go
$ ocamlc ./ackermann.ml -o ackermann-ocaml
$ ghc ./ackermann.hs -o ackermann-haskell
$ python -c "import ackermann-python"

$ time ./ackermann-c 3 12
32765

real    0m4.345s
user    0m4.320s
sys     0m0.012s

$ time ./ackermann-go 3 12
32765

real    0m4.453s
user    0m4.436s
sys     0m0.000s

$ time ./ackermann-ocaml 3 12
32765

real    0m13.094s
user    0m13.053s
sys     0m0.000s

$ time ./ackermann-haskell 3 12
32765

real    1m11.108s
user    1m10.616s
sys     0m0.268s

$ time python ackermann-python.pyc 3 12
32765

real    2m33.121s
user    2m32.518s
sys     0m0.088s

Voici les codes respectifs: ackermann.c, ackermann.go, ackermann.ml, ackermann.hs et ackermann.py. Évidemment, j’ai fais les tests avec la version correspondant à la définition de la fonction (version naïve). Je peux même lancer tous les tests en même temps grâce aux 8 coeurs de l’i7. Ça ne change pas beaucoup les résultats!

Je pense que vous avez compris qu’elle est ma question. J’ai fais plusieurs tests et l’écart entre la version OCaml et Haskell est toujours aussi important (y compris en utilisant ocamlrun ./ackermann-ocaml). Les résultats avec les implémentations C, Go et Python ne sont pas vraiment une surprise.

Il y a tout de même presque une minute de différence entre les versions OCaml et Haskell. J’aimerai bien savoir ce que fait le compilateur OCaml afin d’avoir de si bons résultats (qui ne devrait pas être comparé à du C en fait).

Categories
Computer Programming Technology

Un premier projet pour votre Raspberry Pi

Si vous n’avez pas assez d’idées de projets pour votre Raspberry Pi, voici un cours très sympathique.

Categories
Computer Security

“Press DEL to enter SETUP”, bye bye?

J’aime bien ce passage:

So EFI has this cool shell, a loadable driver framework, and other nice features. Where “nice” obviously means “much more complex than the simple things they designed in the late seventies back when people were stupid and just wanted things to work”.

Tiré de cette conversation. Ça résume tout très bien.

J’ai changé d’ordinateur au bon moment avec ma nouvelle Debian. Les nouvelles machines pré-installées avec Ubuntu devront inclure obligatoirement une clé signée par Microsoft (Winqual), plus une clé Ubuntu. Cependant avec EFI il est possible d’installer une clé générée soi-même en désactivant d’abord Secure Boot (mais je ne pense pas qu’on puisse remplacer la clé de Microsoft). GRUB 2 sur Ubuntu devrait laisser place à efilinux (Linux supporte EFI depuis 2000) car des personnes chez Ubuntu pensent qu’il y a des problèmes avec la license GPLv3 (en rapport avec la clé privée que Canonical gardera sur ces serveurs). Ce qui est faut, il semble. Et donc, espérons le, d’après ce mail Canonical devrait changer de position.

Je me demande pourquoi on ne pense pas à des alternatives comme TrustedGRUB (dont Microsoft pourrait s’inspirer) supportant TPM qui est quand même à la base fait pour ça. Au lieu de virer BIOS qui fait bien son travail, amorcer le système (ou laisser GRUB le faire).

Et qu’en est-il des appareils utilisant le processus de démarage de Chromium OS? Qui a l’air bien intéressant et est compatible avec TPM. Je vois ici des idées plus innovantes et dont le but n’est pas juste de bloquer la concurrence sous prétexte d’augmenter la complexité sécurité des systèmes. Décidemment il y a des entreprises qui veulent vraiment faire perdre du temps au développement de l’informatique avec des conneries. Conneries que l’on est obligé de trainer pendant des années pour finalement les abandonner. Heureusement Linux avance à une vitesse supérieure et rend déjà EFI inutile. Via ce patch (Linux 3.3), il est possible de charger une image du noyau sans avoir à passer par le chargeur d’amorçage. L’option de configuration EFI_STUB modifie l’image du noyau bzImage en ajoutant des informations dans les champs libres des en‐têtes. On peut dire merci à Matt Fleming. La phase d’amorçage n’existe plus vraiment finallement.

Categories
Computer Programming Python

Sort this messy list

Avec l’odrinateur que j’utilisais en 2007 le tri à bulles s’exécutait en 41.33 secondes sur une liste de 10.000 éléments (avec Python 2.5.1c1). Maintenant il s’exécute en 8.62 secondes (avec Python 3.2.2).

Je pense que je vais essayer de faire tourner certains de ces tris sur plusieurs coeurs. Le résultat devrait être surprenant.

En attendant, tu peux aussi faire ces tests sur ton ordinateur.

Voici le détail des résultats:

Algorithme/Nb elements				500				1000				5000				10000

Tri Insertion			0.0400000000			0.1900000000			4.7000000000			18.6900000000
Tri Fusion			0.0100000000			0.0200000000			0.1100000000			0.2500000000
Tri Natif			0.0000000000			0.0000000000			0.0000000000			0.0100000000
Tri Bulle			0.1000000000			0.4100000000			10.2800000000			41.3300000000
Tri Selection			0.2100000000			0.8300000000			20.6900000000			84.2100000000
Tri Selection 2			0.0400000000			0.1600000000			3.9700000000			15.8300000000
Tri Insertion 2			0.0300000000			0.0800000000			2.1100000000			8.6000000000
Tri Casier			0.0300000000			0.0700000000			0.3100000000			0.6200000000

Temps exprimé en secondes.
Version de Python : Python 2.5.1c1
Date du Test : 28/05/2007

Nom générique de la machine : VAIO PCG-GRV616G
Système d'exploitation : Ubuntu 4.1.2-0ubuntu4 (Feisty Fawn) (avril 2007)
Noyau : Linux version 2.6.20-15-generic
Environnement de Bureau : Gnome 2.18.1
model name	: Intel(R) Pentium(R) 4 CPU 2.60GHz

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

Algorithme/Nb elements				500				1000				5000				10000

Tri Insertion			0.0400000000			0.1600000000			3.9200000000			16.0600000000
Tri Fusion			0.0000000000			0.0200000000			0.0900000000			0.1900000000
Tri Natif			0.0000000000			0.0000000000			0.0100000000			0.0100000000
Tri Bulle			0.0900000000			0.3800000000			9.2400000000			37.3700000000
Tri Selection			0.2000000000			0.7700000000			19.6400000000			78.8000000000
Tri Selection 2			0.0400000000			0.1500000000			3.5200000000			14.3500000000
Tri Insertion 2			0.0200000000			0.0700000000			1.8600000000			7.5800000000
Tri Casier			0.0400000000			0.0700000000			0.3400000000			0.6800000000

Temps exprimé en secondes.
Système d'exploitation : Mandriva 2007.1
Noyau : 2.6.24.4-desktop586-1mnb Linux
model name	: Intel(R) Pentium(R) D  CPU 2.66GHz

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

Algorithm/Nb elements				500				1000				5000				10000

Natif			0.0000000000			0.0000000000			0.0000000000			0.0100000000
Fusion			0.0000000000			0.0000000000			0.0200000000			0.0500000000
Selection			0.0400000000			0.1500000000			3.6200000000			14.3600000000
Casier			0.0100000000			0.0100000000			0.0700000000			0.1500000000
Insertion			0.0100000000			0.0400000000			0.7800000000			3.1500000000
Selection_Better			0.0100000000			0.0200000000			0.6700000000			2.5700000000
Insertion_Better			0.0000000000			0.0200000000			0.3600000000			1.5000000000
Bubble			0.0200000000			0.0800000000			2.2800000000			8.6200000000

Time in seconds.
Date : 2012/04/2012

System : Kubuntu 11.10
kernel : 3.0.0-17-generic
model name	: Intel(R) Core(TM) i7-2600 CPU @ 3.40GHz
Categories
Computer

À propos du multiprocessing

osm-parsing

J’aimerai bien pouvoir vraiment profiter de 8 coeurs pour le développement. Au lieu de laisser tourner un script plus de 4 heures sur 1 coeur. De temps en temps, il change de coeur cependant. Certainement pour qu’ils puissent se reposer.