décembre 2004 - Messages
Etant donné l'actualité mouvementée, un petit post pour se reveiller.
J'ai mis à jour ma petite librairie JavaScript, toujours
disponible ici.
Les petites nouveautés, c'est des petites fonctions inspirées du monde ruby, qui permettent de travailler avec ce que l'on pourrait appeller des closures. Un petit exemple :
var ppj = new Array("Pierre", "Paul", "Jacques");
ppj.each(function(elem) {
document.write(elem + "<br />");
});
Très simple à implémenter en JavaScript cette fonction each, surtout quand on sait qu'en JavaScript une fonction est un type comme un autre :
/**
* Appelle une fonction pour chaque element
* du tableau
*/
Array.prototype.each = function(functor) {
for (var i = 0 ; i < this.length ; i++) {
functor(this[i]);
}
}
Franchement, c'est classe non ? Si on a besoin de travailler impérativement avec les index, on peut utiliser cette fonction :
var ppj = new Array("Pierre", "Paul", "Jacques");
ppj.eachWithIndex(function(elem, i) {
document.write("at " + i + " : " + elem + "<br />");
});
Bien pratique, j'ai rajouté cette fonctionnalité sur ma Hashtable, du coup, ça donne ça :
var ht = new Hashtable();
ht.put("jbe", 21);
ht.put("pvb", 24); // et toujours pas marié
ht.each(function(key, value) {
document.write(key + " is " + value + "<br />");
});
Alors, qui a dit que le JavaScript était un "sous" langage. C'est d'autant plus appréciable qu'on le retrouve un petit peu partout, bref, comment professionaliser le développement XUL par exemple hein ?
Il y a peu je me plaignais du manque de caractère de SharpDevelop.
Ce matin, Hans Fratz sur la liste de Mono a annoncé la preview d'un nouvel IDE très prometteur : x-develop.
Hey, good work !
Google, des gens qui n'ont pas fini de nous surprendre.
Tout droit sorti des labs, la dernière petite nouveauté, c'est la complétion de votre requête.
C'est assez impressionnant, petit exemple :
Pour essayer vous même :
Pour des raisons que le monde entier découvrira un jour, je viens d'installer un Linux sur mon ordinateur. J'ai choisi comme distribution Ubuntu, car la philosophie du produit est sympa, et tout tourne à merveille. Ubuntu pour les gens qui ne connaissent pas, c'est une Debian un petit peu retouchée, je vous invite à aller voir le lien que vous trouverez ci-dessous. Deuxième lien bien pratique, un LiveCD Linux, basé sur une Gentoo, qui m'a permis de resizer mes partoches NTFS, sans rien perdre, sans douleur, sans chemise, ni pantalon. Et puis vu le nom je suis sur que ça peut servire à des tas d'autres trucs.
Je suis tombé amoureux d'un nouveau projet, oui, un de plus.
Ca fait un tiers d'année que je suis au labo.net, et le Java me manque. Ce soir, au lieu de bosser comme je devrais le faire, et suite à un post sur la ML développeur de Mono, je me suis a butiner frénétiquement l'Internet multimédia, jusqu'à tomber la dessus :
JNode. Qu'est ce que JNode, c'est tout simplement un OS écrit à plus de 90% en Java. Seule la couche basse est écrite spécifiquement pour la plateforme (seul les x86 sont supportés pour le moment). Et tout le reste est écrit en Java, et mes amis, quel Java. Tout est très propre, très bien écris, avec une magnifique architecture ouverte, où l'on peut se brancher un peu partout. Mon rêve en fait. Ca n'utilise que du bon, Ant, Eclipse, Jakarta-commons, et tous plein de projets tous aussi géniaux les un que les autres.
Imaginez un peu un OS où l'on pourrait choisir ses composants très facilement, se brancher de manière sécurisée n'importe où ou presque dans l'OS, que ce dernier soit portable partout, qu'il bénéficie d'un formidable existant. C'est tout ça JNode. C'est quand même impressionant. Je dois avouer je suis bluffé quand même. C'est triste je n'ai pas réussi à le faire fonctionner sur Virtual PC, même avec le SP1, qui malgré deux erreurs, s'est installé (il est quand même fort ce SP1), il va falloir que je retrouve où j'ai mis ma licence VMWare...
EDIT : J'ai quand même réussi à le faire tourner avec QEMU, après avoir compilé le machin, c'est marrant, pas très rapide, mais c'est quand même fort, mais pas très rapide.
Quand je pense à toutes les possibilitées que ça ouvre, c'est dingue. Imaginez une FS type Unix où l'on pourrait accrocher ses propres méta données, oui, comme pour WinFS (un beau jour peut-être), ou comme BeOS le faisait si bien. Dans vos programmes vous les retrouvez ni une ni deux. Ensuite imaginez ça combiner avec tous les petits plus du langage en 5.0, comme ils refont une VM, on peut très bien espérer un support des générics pour de vrai. Ca rentre tout à fait dans mes fantasmes technologiques, il y a des millions de choses à faire.
Un jour, il faudra le faire en C# quand même, on va pas laisser ces c*ns d'intellos nous empêcher de devenir CRS !!!
Je redonne le lien, au cas ou j'ai réussi à vous donner (au moins) envie d'aller voir :
De bon matin, et parce que j'ai été ammené il y a peu à utiliser un de mes langages favoris, le
Ruby, je vais me fendre au fil de quelques articlets à venir de divers points comme :
- La découverte du Ruby
- Tous ces petits plus qui vous changent la vie en Ruby
- LE framework ultime pour le développement web en Ruby
- Et surement d'autres choses...
En attendant, et comme il serait dommage de ne pas vous appater avec un petit peu de code, voila un lien fort sympathique :
Comme vous pouvez le constater en rafraichissant la page, la liste de lien est aléatoire.
Vous pouvez par exemple regarder sa source première (qui n'est pas de mon fait), ici :
require 'sqlite'
db = SQLite::Database.new ( "../sample4.db", 0 )
rs = db.execute ( "SELECT id FROM sample4;" )
na = []
def rebuild ( arr )
arr2 = []
arr.each { |row|
if ( !row.nil? )
arr2.push ( row )
end
}
return arr2
end
def setValue ( arr, arr2 )
if ( arr.size > 0 )
r = rand ( arr.size )
arr2.push ( arr[ r ] )
arr[ r ] = nil
arr = rebuild ( arr )
return setValue ( arr, arr2 )
end
return arr2
end
na = setValue ( rs, na )
na.each { |id|
db.execute ( "SELECT title, url FROM sample4 WHERE id=#{id['id']};" ) { |lien|
puts "<a href=\"#{lien['url']}\">#{lien['title']}</a>"
if ( id != na.last )
puts "<span class=\"separator\"> | </span>\n"
end
}
}
Et la version actuelle (que j'ai écrite) :
require 'sqlite'
db = SQLite::Database.new( "../sample4.db", 0 )
rs = db.execute( "select title, url from sample4;" )
ar = [ -1, 1 ]
res = rs.sort { |x,y|
ar[ rand( 2 ) ]
}
res.each { |record|
puts( "<a href=\"#{record[ 'url' ]}\">#{record[ 'title' ]}</a>" )
puts( "<span class=\"separator\"> | </span>" ) if( record != res.last )
}
Comme vous pouvez le constater, le SGBD utilisé est
sqlite.
Oui, les ruby-istes n'ont pas attendu php5 pour découvrir sqlite.
puts("Stay tuned !")
Après avoir modifié un peu Rail, et bien pesté, je suis tombé sur un site magique :
Les archives, c'est là qu'il faut aller !
Mon dieu, mais je connais tellement de
développeurs dont le code pourrait être ainsi mis en valeur...
Oui, moi, compris...
[EDIT] Un que j'adore :
Grand petit pas pour AspectDNG ce soir, j'ai réussi à bidouiller Rail pour passer outre certains bugs de Mono. Du coup, premier round-trip réussi sous Mono.
Qu'est ce qu'un round-trip ? C'est tout simplement le fait de passer une assembly à la moulinette ILML, et ré-assembler l'assembly à partir de l'ILML.
D:\temporary\ilml>hello.exe
Hello World !
D:\temporary\ilml>il2ilml hello.exe hello.exe.xml
D:\temporary\ilml>ilml2il hello.exe.xml hello.new.exe
D:\temporary\ilml>hello.new.exe
Hello World !
D:\temporary\ilml>mono il2ilml.exe hello.exe hello.exe.xml
D:\temporary\ilml>mono ilml2il.exe hello.exe.xml hello.new.exe
D:\temporary\ilml>mono hello.new.exe
Hello World !
D:\temporary\ilml>
On va y arriver !
Les gens qui font Mono se sont réunis autour d'une table, le compte rendu est disponible ici :
Summit Notes
Important, si vous voulez savoir de quoi sera fait le futur proche de Mono.
Symposium DotNetGuru, plus que 16 heures...
Outre ma courte démonstration du PetShopDNG 2.0 porté sous Mono, ce sera une bonne journée pour l'AOP, et ce, pour deux raisons :
- Thomas GIL présentera son ouvrage Conception Orientée Aspect en exclusivité cette journée.
Ce sera pour vous l'occasion de l'acquérir pour la modique somme de 27,5€. Prévoyez le carnet de cheques, DNG Edition ne prend pas encore les cartes bleues :)
- Nouvelle exclusivité, sera présenté la version 0.5.5 de notre tisseur d'aspect AspectDNG.
Cette version améliore radicalement les performances de la couche basse du tisseur, et corrige de nombreux bugs. Cette version sera téléchargeable sur le site juste après le Symposium.
Sur ce, je vous dis à demain !
Dans la série je réagis aux postes de
c2i, des liens et des logiciels que j'utilise ou que j'ai regardé dans le cadre de développement de logiciels. Notons qu'une méthodologie de développement correctement outillée est indispensable à l'industrialisation d'un projet.
Liens :
Logiciels :
- NAnt : un outil de build, "à la" Ant, excellent, l'essayer, c'est l'adopter
- Subversion (SVN) : Le futur du SCM, destiné à remplacer CVS
- Trac : un excellent wiki modifié destiné à la gestion mono project (utilise SVN comme SCM)
- GForge : un clone de sourceforge, donc multi projects (utilise CVS comme SCM)
- TortoiseSVN : l'équivalent de TortoiseCVS (que j'utilise pour mes projets sf.net), mais pour SVN
- NUnit : Pour les tests unitaires, bien évidemment
Je completerai surement cette liste au fil de mes pensées.
Good Morning Everyone,
Je réagis par rapport à la news que je viens de voir passer sur le DotNetLogue,
C2I rapportant une news des
Tech Head Brothers, concernant la possibilité de faire du multi base sur .net.
Une solution très élégante et qui à le mérite d'exister depuis longtemps, est celle de
Mono, et du Namespace Mono.Data, implémentant donc le
DP GOF Abstract Factory, ce qui va donc permettre donc de changer de fournisseur de SGBD, sans toucher à l'implémentation. A voir aussi tous les fournisseurs que
Mono inclu dans sa distribution.
Exemple d'utilisation fournis dans Mono, donc sous license MIT/X11 :
Et la configuration qui lui est associée :
Mono Rocks !
Tiger, la version 1.5 de Java vient de sortir.
Je m'en vais la tester de ce pas. Vivement qu'Eclipse soit compatible avec toutes les nouveautées.
Et on attend toujours la beta 2 du Framework .net, avec une licence permettant la mise en prod.
Can someone tells me how it is possible to embed a file as a resource into an AssemblyBuilder at runtime ? I begin to think it is not possible.
Just a little note about the context. In Rail, we mount into memory an object graph of an assembly, readed by Mono.PEToolkit, and then, after some instrumentation, we emit it using System.Reflection.Emit. So, a resource for us is just a struct containing a string Name, another string FileName, a byte array for the Data, and a ResourceAttribute set to public or private.
The framework doc tells me that there is two ways to deal with resources. Let's take a look. The first one is calling DefineResource on an AssemblyBuilder or a ModuleBuilder. By doing it this way, you get an IResourceWriter, and then, you add Data to it. Why not, this seems pretty obvious. But, if you do it this way, the IResourceWriter is designed for .resources files, for strings localizations. When simply putting a byte array
in it, with a name, and a public attribute, the IResourceWriter implementation will generates extra bytes, and make the resource (remember, a simple file) unreadable.
The next way (according to the doc), is to use the AddResourceFile method from an AssemblyBuilder. Let's try this way. First, it only wants a file on the HDD, no way to set a stream or something else. So I have to write my byte array of data on the disk, I call AddResourceFile, and once the assembly is builded, I delete temporary resources files. Wrong... The resource is only linked, not embedded. And THERE IS NO WAY TO SPECIFY HOW I WANT IT TO BE DONE.
I've looked how Mono mcs deals with resources. It's amazing ! They have to use Reflection on AssemblyBuilder to get a private method called EmbedResource. If the method is not found, it means that the runtime in used is not the Mono one, so it throw an error, Resources can only be embedded using Mono runtime. Sounds weird no ? Notice that it looks to be possible with the .net 2 framework using the DefineManifestResource method of ModuleBuilder, taking a string Name, a Stream of data, and attributes. Can't wait for the new version of the framework.
So I throw the sponge, as we say in France !
Die Wahrheit Ist Irgendwo Da Draussen
Petite release pour Mono, spéciale Bug Fixes.
C'est la deuxième, et oui, comme son nom l'indique, depuis la sortie de la 1.0.
Cela confirme bien le mode de release rapide qu'on avait tous présentis. Ca prouve aussi que Mono n'est malheureusement pas si mature que ça.
N'hésitez pas à aller regarder les release notes pour savoir ce qui a changer.
Ce sera la version utilisée pour la démonstration Mono au Symposium DNG du 8 octobre.
Il est beau le site d'AspectDNG. Il est neuf le site.
Il est fait en 10 minutes à la mano ce matin à minuit.
Il est magnifique, allez, visitez le !
http://aspectdng.sourceforge.net/
Discourant avec un développeur VB.Net, nous discussions de la meilleure manière d'écrire du code dépendant du Type d'une instance. Bien que tous les deux persuadés qu'un switch serait idéal, je soutenais qu'on ne pouvait en C# faire un switch sur le type d'une instance d'un objet. Mais mon collègue m'assurait qu'on pouvait le faire en VB.Net. Et effectivement, en VB.Net, le code suivant marche :
Une traduction en C# pourrait être :
Or ce code ne compile pas. En effet, l'expression
a is AA n'est pas constante, comme le requiert un switch en C#. Alors comment fait ce diable de compilateur VB.Net ? Il transforme tout simplement son bloc switch en l'équivalent d'une cascade de
if / else if, ce qu'il faut faire en C# pour avoir du code qui compile. Du coup, à la compilation, le
MSIL ne contient pas d'instruction switch. Cependant, même en C#, un bloc switch ne sera pas toujours converti en switch MSIL, alors c'est bien dommage de ne pas avoir d'équivalent, car cela éviterait des constructions syntaxiques plutôt lourdes comme on peut en trouver dans ma libraire
ILML. En effet, le traitement des instructions correspond parfaitement à l'exemple fourni ci dessus. Messieurs de chez Microsoft, un bon geste siouplé.
Marrant le moteur d'insertion de pub pour GMail :
Etant en train de finir de préparer ma (courte) session sur Mono lors du Symposium DNG prochain, je discutais avec le créateur de Mono à propos de quelques sujets qui me tenaient à coeur. Et voila que GMail me propose quelques liens en relation avec le contenu de mon mail :
Etonnant non ?
I was trying to make an exemple more representative of what we try to do following to my
post.
I'm front of another incomprehension. The key of the problem is here, in this assembly :
It is valid IL, and the result is peverified. Notice that the assignement of int(2) if it can look tricky is nothing more than AnEnumeration.B. Anyway as an enum is a valuetype, the CLR only manipulates integers when using this AnEnumeration.
I've used ilasm to produce an assembly 3.dll.
I next wrote a little program that use this assembly, 4.exe :
It is simple. In my head, I expect the result to be True. What do you think ?
But no, it is not, executing this on ms .net framework 1.1, it prints False.
I've open the 4.exe assembly in ildasm, here is the result :
What does it means ? It means that we first push the value of the field on the stack, then when push AnEnumeration.B on the stack, here csc have made a shortcut, and push directly 2, then we find the ceq opcode. The ceq operand mean "Compare Equals". It will compare the last two values from the stack, and push 1 if they are equals, 0 if not. Here it put 0, that is boxed in Boolean to be printed as False.
So the value of the field is not 2. The snippet 5.exe will convince you :
The ouput is 2 == 0 => False.
We can reproduce the same problem using Reflection to read the value of the field.
For the MS .net Framework, its value is 0, not 2. But why ???
Once again, every pieces of code works perfeclty, with the expected behavior on Mono.
For Mono the value of the field is 2, not 0.
It is not a great problem for us because we use Rail to read the library, that do not use System.Reflection. But it can be a problem for someone else.
Anyway we then have the problem described in the previous
post, to set the constant value 2 on the field.
While I was trying to solve a problem with the author of
Rail, it seems that we have discovered a not so little bug inside the .net framework.
I explain. All of this concerns the UnderlyingSystemType of a Type. In .net you may manipulate types like :
- Arrays
- References
- Enumerations
typeof(AType[]) is very different from typeof(AType). You may want to know what is the "underlying type" from an array.
For example :
Console.WriteLine(typeof(AType[]).UnderlyingSystemType.ToString());
Console.WriteLine(typeof(AnEnum).UnderlyingSystemType.ToString());
Should write :
AType
System.Int32
Instead of this expected behavior, the result is :
AType[]
AnEnum
So the UnderlyingSystemType property of a Type does not reflect the real "underlying system type".
This is a real problem when playing with System.Reflection.Emit. For example, you define a new assembly, a new module, and then, a new type.
On this type you want to add a field, and you want it to be of type AnEnum. This seems simple, you can write it like that :
FieldBuilder myFieldBuilder= myTypeBuilder.DefineField("MyField",
typeof(AnEnum),FieldAttributes.Public|FieldAttributes.Static);
Ok, now let set it a value :
myFieldBuilder.SetConstant(SomeHelper.GetExpectedConstant());
The helper may for example get the value on a field using System.Reflection (that what we were doing), so it returns an Object.
But we can use System.Reflection to see that the expected value of the field is an integer. It is not amazing, in the assembly, the value of an enum is storred as an int32 if the underlying system type of the enum is int32. So we set the constant, everything compiles, we run it, and here, we caught an ArgumentException saying that the type of the constant does not match the type of the field...
After a short look inside the code of the BCL using the
SSCLI, we can see that if the type of the wanted field is an enum, it will check if the underlying system type of the enum matches the type of the constant. It's normal behavior, but remember, the underlying system type is not the expected one. So it is blocking, and also frustrating.
I've mailed some guys I know inside Microsoft, and I'm waiting for their answers...
But you know what is good ?
...
It works with Mono 1.0 :)
Mono set the underlying system type to the correct one, that allows my snippet to run
The problem seems to be still there in the Framework 2 beta 1.
If someone knows who I may contact, or tells me that I'm wrong, I'll be glad to discuss with him :)
This sounds amazing that no one noticed that before. So I wonder about my understanding of the thing...
And of course the sscli runs into the same behaviour as the .net 1.1 framework.
UPDATE : I've removed the code samples because I think they were not relevant enough. I will try to make one soon.
Alors la je suis fou.
La nouvelle version de l'
AJDT est disponible.
L'
AJDT c'est un plugin eclipse qui intègre mon outil d'AOP Java favori,
AspectJ, au coeur de l'IDE.
C'est donc la première version officielle de l'outil pour
eclipse 3
Au menu tout un tas de nouveautés :
Le mieux que vous puissiez faire, c'est d'y jeter un coup d'oeil.
Le lien direct pour le téléchargement :
Autrement c'est une bonne source d'inspiration pour le plugin AspectDNG pour VS.Net qui je le rappelle, a toujours besoin de contributeurs.
Here is a NAnt task to use the Microsoft Research ILMerge software in your build scripts :
http://www.evain.net/public/ilmergenant.zip
You can take a look to the source here :
http://www.evain.net/public/ilmergenant.cs
To build it yourself, you just have to configure the path to ilmerge.exe in the .build, and run nant.
ILMergeNAnt is builded againt ILMerge 1.0.1661.24486.
Due to license restriction, I can not include ILMerge here, so if you don't already have downloaded it, you can get it
here.
If you still wonder about what ILMerge is, let's go
here.
Ayant vu passer un
post sur le DNL parlant d'ajouter des fonctionnalités manquantes au Javascript, je me permet de balancer la mienne :
http://www.evain.net/public/script.js.html
Notez que la méthode Object.clone (shallow copy) embête pas mal par la suite.
[UPDATE]
Y'a de la couleur maintenant, c'est plus lisible.
Certains savent que je suis fan de
Ruby, ce langage particulier permet de faire des raccourcis syntaxiques certes pas toujours cavaliers, mais souvent bien pratiques.
La nouvelle mouture du Framework et les changements apportés à la syntaxe du prochain C# vont permettre d'emprunter certains de ces raccourcis.
Attention tout de même à ne pas verser dans l'excès d'entousiasme.
Une des problèmes apporté par les méthodes anonymes est la possible multiplication de code copié/collé.
En plein milieu d'une actualité .net déjà chargée par le TechEd Europe, Novell vient de sortir la version 1.0 de l'implémentation libre du framework .net.
UPDATE
Le site à l'air de peiner un peu la quand même.
Allez y doucement ;)
Mine de rien ça en fait des trucs à tester ces prochains temps :
Un article complet devrait suivre dans la prochaine semaine sur Mono 1.0.
Ce sera l'occasion de faire le point, et de donner un avant gout de ma présentation au
Symposium DotNetGuru
Look the tiger, Look the tiger !
Introducing Longhorn
Ca y est, la machine est lancée.
Une formidable journée en perspective :
Rendez-vous le 8 octobre !
La release candidate 1 de Mono est disponible depuis hier.
Si tous les gens un peu intéressés pouvaient essayer leurs applications dessus, et remonter les derniers bugs vraiment bloquants avant la sortie de la 1.0, ce serait sympa.
http://www.go-mono.com
Mon IDE préféré arrive enfin à sa version 3.0.
C'est beau, c'est rapide, c'est très agréable à utiliser.
http://www.eclipse.org
Pour ceux qui ne le savent pas encore, eclipse, ce n'est pas qu'un IDE Java. Son architecture (magnifique au passage) ouverte a permis la création de kilomètres de plugins.
En voici quelqu'uns des plus intéressant :
Et c'est sans parler de tous les plugins non officiels, pour les Ruby, Perl, Python, Javascript, et même Php, avec support du debug. Bref mangez en !
C'est l'occasion de faire un peu de pub pour des gens que j'aime bien, des petits français doués et sympa, qui nous ont fait là un petit bijou très bien intégré :
Et puis pour lancer le petit troll de la fin, je me dis que je vois la communauté Java avec
La communauté .net à encore bien du chemin à parcourir.
J'ai jeté un coup d'oeil au framework 2.0, j'ai quelques doléances, la version française est en bas.
I've just downloaded the preview of the 2.0 framework now available in a
standalone distrubtion, without VS Whidbey, on MSDN.
As a developer of an AOP tool, and maintainer of the low layer of this tool,
my first thought was to take a look into the System.Reflection namespace.
If few things are better than in the 1.1, this is still insufficient. The
instrumentation part of the framework has been undervalued since the first
versions.
In the good points of this tech preview, we find the ability to get the
details of the creation of Custom Attributes.
This is done by using a static method of the new type
System.Reflection.CustomAttributeData :
public static IList!1<CustomAttributeData> GetCustomAttributes(
MemberInfo target
);
Good job with the IList, instead of an ArrayList or something else.
However, a simple array would have been enough. For more details, take a look here :
ms-help://MS.NETFramework.v20.en/cpref/html/T_System_Reflection_CustomAttributeData_Members.htm
The next lack concerns the body of the methods. For the moment, the good point is the new type :
System.Reflection.MethodBody
But it is very incomplete. In an assembly, exceptions and instructions are stored in different places,
this is why we found here methods to access data separately.
The exception part is clean, with read access to start and end offset of
clauses, the type of the exception in case of a catch handler, etc.
However, the instruction part is very, very, very, insufficient.
The only method is
public byte[] GetILAsByteArray();
I want to be able to manipulate instructions ! It is not much, and an
Instruction type would be quite simple to write :
public sealed class Instruction {
private OpCode m_opCode;
private uint m_offset;
private object m_operand;
//...
}
So I ask for a method :
public Instruction[] GetInstructions();
In the MethodBody type, or, if you want to do it in a "generic way",
public IList!1<Instruction> GetInstructions();
Still talking about methods details, I want to be able to read p/invoke
data, like the entry point or the library used. I haven't found anyway to
read this.
This should be enough for this time,
Sorry for my poor English.
----------------------------------------------------------------------------
Je viens de télécharger la preview du framework 2.0 maintenant disponible en
stand-alone sur la MSDN, sans l'ami VS Whidbey.
En tant que co-développeur d'un outil d'AOP, et responsable de la couche
basse de ce dernier, ma première envie fut d'aller jeter un coup d'oil au
namespace System.Reflection. Il y a du progrès, mais ce n'est nettement pas
suffisant. La partie instrumentation du framework est minorée depuis sa
création. C'est plus que dommage.
Dans les nouvelles fonctionnalités qui vont bien, la possibilité d'obtenir
le détail des CustomAttributes. Cela se fait par le biais d'une méthode
statique de la classe CustomAttributeData :
public static IList!1<CustomAttributeData> GetCustomAttributes(
MemberInfo target
);
Bravo pour le IList au passage, plutôt qu'un ArrayList ou autre.
Cependant, n'y aurait t'il pas ici un petit excès de zèle, un simple tableau eu suffit.
Pour des détails supplémentaires sur cette fonctionnalité, je vous renvoie vers la documentation :
ms-help://MS.NETFramework.v20.en/cpref/html/T_System_Reflection_CustomAttributeData_Members.htm
Voila pour un gros manque de la 1.0. Le second, plus évident, c'est le corps
des méthodes. Pour l'instant, la seule amélioration, c'est la présence d'un objet
System.Reflection.MethodBody
Il faut savoir que dans une assembly, les exceptions et les instructions
sont stockées dans des endroits différents. Pour l'instant, cet objet nous
permet d'accéder proprement aux exceptions, ie les offsets de début et de
fin des clauses, le type de l'exception, etc. Stupeur et tremblements, pour
les instructions, cet objet expose seulement la méthode
public byte[] GetILAsByteArray();
C'est nettement insuffisant. Je veux que l'on puisse accéder de manière
standardisée aux instructions. Ce n'est pas grand-chose pourtant, un objet
Instruction est simple à écrire.
public sealed class Instruction {
private OpCode m_opCode;
private uint m_offset;
private object m_operand;
//...
}
Je souhaiterais donc voir apparaître la méthode
public Instruction[] GetInstructions();
Voir, si on continue dans le zèle,
public IList!1<Instruction> GetInstructions();
Toujours dans le cadre du détail des méthodes, en cas de p/invoke, je veux
pouvoir avoir accès aux données du p/invoke, comme la librairie, le point
d'entrée, etc. Car si on définit une méthode p/invoke par un attribut
DllImport dans le code, il n'en reste rien dans l'assembly produite.
Voila, déjà ça ce serait pas mal.
Je viens de voir sur le DotNetLogue un article :
http://www.asp-php.net/tutorial/divers/iis_https.php
Marrant le nombre de gens qui ne savent pas que Microsoft fourni un outil justement nommé
SelfSSL qui permet de se génerer un certificat en ligne de commande TRES facilement plutôt que de galérer avec l'ami OpenSSL.
A noter que si cet utilitaire fait partie du webkit de IIS 6, je l'ai fait fonctionner (et celui la seulement, pas essayé le reste) sur un IIS 5 sous Windows 2000 sans problèmes.
Accompagnant la beta 2, MonoDevelop est disponible en package pour permettre à tout un chacun de l'installer facilement.
Une fonctionnalité très intéressante est celle de l'import de solutions et de projets VS.Net. En un clic de souris, on a tôt fait de convertir ses projets.
Bien entendu il ne faut pas s'attendre à un modèle de stabilité, mais pour une version 0.4, c'est déjà fort sympathique. Les habitués de
SharpDevelop se sentiront à l'aise, les autres prendront vite le coup.
A noter qu'un patch malencontreux appliqué juste avant la mise en packages empêche l'utilisation du débuggeur. Les plus courageux se rabattront sur la version
CVS, les autres attendront un mois de plus jusqu'à la sortie de la première release.
Au vu de la manière dont se passe les sorties successives des beta, on peux entrevoir un mode de release rapide, et ou les numéros fixes ne seront pas forcément gage de stabilité.
Pour finir un autre petit screenshot, pris lors des essais des imports de solutions :
http://www.evain.net/public/monodevimp.png
Pour les curieux du fond, ce que vous voyez la devrait sortir dans la deuxième moitié du mois en cours. Patience.
Mesdames, Mesdemoiselles, Messieurs,
A vous de jouer :
http://www.go-mono.com/download.html
[UPDATE]
Un petit screenshot de ma machine quand même :
http://www.evain.net/public/monobeta2.png
Avec la beta 2, tout le monde peut profiter des outils de développement Mono avec un minimum d'effort, les packages étant fournis, et disponibles via red-carpet.
Bravo aux gens de Mono !
Pour tous les curieux qui aiment les langages :
http://www.99-bottles-of-beer.net/
Si vous aimez la bière, vous pouvez allez voir aussi.
Pour toutes les personnes ayant utilisé l'installer de la beta 1, souffrant de pas mal de problèmes (GAC),
une nouvelle version vient de paraitre :
http://www.go-mono.com/download.html
Ruez vous.
Bon, je peux pas vous en dire beaucoup, mais voila, et bien,
un soir, je suis allé dormir chez mes cousins...
Que Du Babillage
Nemerle is a new hybrid (functional, object-oriented and imperative) programming language for the .NET platform.
Moi, mon dada, c'est les langages... En voila un qui me titille depuis ce matin : Nemerle
Exemple :
class LineCounterWithoutLoop {
public static Main () : void {
def sr = System.IO.StreamReader ("SomeFile.txt");
mutable line_no <- 0;
def read_lines () : void {
def line = sr.ReadLine ();
when (line != null) {
System.Console.WriteLine (line);
line_no <- line_no + 1;
read_lines ();
}
};
read_lines ();
System.Console.WriteLine ("Line count: {0}", line_no);
}
}
Autre chose d'intéressant : This compiler is self-hosting, et ça, c'est quand même assez fort.
Les industries tremblent, une partie du code source de Windows 2000 est en "libre" circulation sur le net. C'est vrai que c'est assez effarant. Il suffit pour s'en persuader de jeter un coup d'oeil dedans.
http://www.evain.net/public/winmain.c.html
C'est marrant ça a fait moins de bruit l'attaque des serveurs debian il y a peu.
Sympa le fastpath chez free, gratuit, et activable/désactivable à la demande :
C:\Documents and Settings\jbe>ping www.dotnetguru.org
Envoi d'une requête 'ping' sur www.dotnetguru.org [213.186.40.29] avec 32 octets
de données :
Réponse de 213.186.40.29 : octets=32 temps=14 ms TTL=56
Réponse de 213.186.40.29 : octets=32 temps=13 ms TTL=56
Réponse de 213.186.40.29 : octets=32 temps=14 ms TTL=56
Réponse de 213.186.40.29 : octets=32 temps=14 ms TTL=56
Statistiques Ping pour 213.186.40.29:
Paquets : envoyés = 4, reçus = 4, perdus = 0 (perte 0%),
Durée approximative des boucles en millisecondes :
Minimum = 13ms, Maximum = 14ms, Moyenne = 13ms
Pas encore sure de bien saisir à quoi ça va me servir ça :]
A y est mesdames et messieurs, Mono 0.3 est dans la nature !
Dans la soirée les détails de l'installation sur la xbox, maintenant célèbre :]
[UPDATE]
Bon, en fait c'est limite pas drôle. Download, compilation, installation, configuration, tout s'est passé tout seul, juste à suivre la doc pour le mod_mono. Maintenant il faudrait faire un test avec une vrai application web. Mais on verra ça plus tard. Bonne nuit !
Vous parlez anglais, tant mieux, c'est par la que ça se passe :
http://www.dotnetguru.org/us
http://www.theserverside.net/news/index.aspx
Deux sorties le même jour, pour des sites de références.
Bravo à nos frenchies préférés, et bon courage !