Bravo l'innovation!!!

Bon désolé mais là c'est trop gros, voici 2 programmes:


Le leur:
----------8<--------------------------------------------------------------------------
using System;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;

namespace Volume_27
{
///
/// Linux.Ars Volume 27 Example 1
///
class Example1
{
static void Main(string[] args)
{
if( args.Length == 0 )
{
Usage();
Console.ReadLine();
return;
}

String input = "";
for(int i = 0; i < args.Length; i++)
input = input + ((i==0)?"":" ") + args[i];

Console.Write
("Enter a regular expression to test the string \"{0}\": ", input);
String regex = Console.ReadLine();

bool matches = Regex.IsMatch( input, regex );

Console.WriteLine
("\"{0}\" DOES {1} Match \"{2}\"", input, (matches)?"":"NOT", regex);
}

public static void Usage()
{
String ExecPath = Environment.GetCommandLineArgs()[0];
String Executable =
ExecPath.Substring(ExecPath.LastIndexOf(Path.DirectorySeparatorChar) + 1);
Console.WriteLine("-------------------------------------------------");
Console.WriteLine("{0} usage:", Executable );
Console.WriteLine();
Console.WriteLine("\t{0} [Input String]", Executable);
Console.WriteLine();
Console.WriteLine
("\t[Input String]: An input string that should be tested against");
Console.WriteLine("\t the prompted regular expression");
Console.WriteLine();
Console.WriteLine("-------------------------------------------------");
}
}
}
----------8<--------------------------------------------------------------------------


Et le mien:
----------8<--------------------------------------------------------------------------
#!/usr/bin/perl

sub usage {

printf <<EOF
-------------------------------------------------
0ドル usage:

0ドル [Input String]


[Input String]: An input string that should be tested against
the prompted regular expression
-------------------------------------------------
EOF
}

$input = shift;
if (not $input) {
usage();
<>;
exit(0);
}

printf ("Enter a regular expression to test the string \"$input\":");
$regex = <>;
chomp $regex;
$matches = $input =~ $regex;
printf("\"$input\" does%s match \"$regex\"\n",($matches ? "": " NOT"));
----------8<--------------------------------------------------------------------------


Et maintenant je passe en revue leurs arguments:

1) L'article:
A user of a platform that supports Mono will hopefully see better-quality applications, applications that can just be installed (no compiling, not even for packaging), and applications that are secure.

Ce que j'en dis:
Bullshit marketting. La problématique d'installation dépasse largement le cadre de la compilation. Il n'y a qu'à voir le cas de Java où bien que le bytecode soit parfaitement portable et que la compilation soit souvent faite de manière transparente par les divers environnements de prod (serveurs d'appli par exemple), le packaging est une science en soi. Quand à l'argument sur la sécurité, ça me laisse rêveur.

2) L'article:
Mono also has the concept of garbage collection. Gone are the days of using malloc() and free()

Ce que j'en dis:
Eh oh les copains réveillez-vous ça fait plus de 10 ans que ça existe...

3) L'article:
And now to execute the same exact binary on Linux

Ce que j'en dis:
Certes Perl génère le bytecode à la volée donc la notion de binaire est ici faussée, ceci dit en terme de compatibilité entre les différentes plate-formes .NET a du retard à rattraper, et pas que par rapport à Perl, grosso-modo à part Visual Basic tout le monde est en avance... Mon p'tit programme Perl il marche sur bien plus de machines que celui en Mono.

4) L'article:
The great power of Mono and .NET lies in the ONE line of code:
"bool matches = Regex.IsMatch( input, regex );"

Ce que j'en dis:
The great power of Perl lies in the ONE line of code:
"$matches = $input =~ $regex;"

5) L'article:
Things like Input validation, network communication, file reading and writing, text encoding, regular expressions, formatting, XML Parsing, LDAP Access, remoting, and GUI development are reduced to just a few lines of code compared to possibly hundreds.

Ce que j'en dis:
http://www.cpan.org(...)

6) L'article:
forgue@ahab:~$ ./v27e1.exe Linux.Ars is cool
Enter a regular expression to test the string "Linux.Ars is cool": ^L.*\.C*
"Linux.Ars is cool" DOES Match "^L.*\.C*"

Ce que j'en dis:
Ils utilisent quoi comme shell? Parce que moi bash il m'explose le Linux.Arts is cool en 3 paramètres "Linux.Arts" "is" "cool". Et ce traitement est fait par le shell avant d'envoyer les paramètres au programme donc pour parler "en C" argv[1]="Linux.Arts" et argv[3]="cool". Donc concrêtement sur une machine Linux de base (c'est souvent bash qui est installé mais je soupçonne les autres shells de faire pareil...) leur exemple ne fonctionne pas il faut taper:
forgue@ahab:~$ ./v27e1.exe "Linux.Ars is cool"
avec les guillemets donc.
Ils l'ont vraiment testé leur programme sous un UNIX ou bien ils ont pris l'exemple Windows et remplacé l'invite shell après coup??? J'ai des doutes...

7) L'article:
Console.WriteLine("-------------------------------------------------");
Console.WriteLine("{0} usage:", Executable );
Console.WriteLine();
Console.WriteLine("\t{0} [Input String]", Executable);
Console.WriteLine();
Console.WriteLine
("\t[Input String]: An input string that should be tested against");
Console.WriteLine("\t the prompted regular expression");
Console.WriteLine();
Console.WriteLine("-------------------------------------------------");

Ce que j'en dis:
Et après on va dire que Perl n'est pas clair, honnêtement je trouve la construction avec <<EOF bien plus élégante mais bon.


Bon, pour conclure, je ne critique pas .NET ni Mono je connais pas trop le détail mais je suis pas ébourriffé par la présentation 8-)


PS: Je tiens à préciser que je ne suis vraiment pas expert en Perl ni défenseur de Perl, mais franchement n'importe quel langage de script (Python, Ruby, Perl...) permet de coder leur truc en 2 coups de cuillère à pot. Le problème c'est que leur exemple est mal choisi: un langage compilé est assez inadapté à ce type de code/réalisation. Et ça reflète un problème récurrent de l'industrie logicielle: on utilise souvent les mauvais outils...