Number, en plus d'être une classe, est également une fonction, tout comme le sont Array, Boolean et String. Elle permet de convertir un objet quelconque en une instance de Number.

Seulement, ce qui n'est pas précisé dans la doc, c'est que cette fonction suit les mêmes règles que parseInt, sans pouvoir toutefois lui passer de second paramètre, qui précise dans quelle base doit se faire la conversion. Ce qui signifie que :

• Les chaines de caractères commencant par "0x" seront considérées comme héxadécimales
  
• Les chaines de caractères commencant par "0" seront considérées comme octales.

Et c'est sur ce dernier point que je me suis fait avoir, en cherchant un long moment pourquoi mon "062" devenait 50... :\ J'ai donc du remplacer toutes mes conversions :var num:Number = Number("062") // num = 50
// par
var num:Number = parseInt("062", 10) // num = 62

Donc voilà, si ca peut profiter à quelqu'un..

Il est beau, il est tout neuf! Le Flash player est enfin disponible en version 7 pour les plateformes PocketPC. Le geek que je suis va enfin pouvoir se pavaner avec ses propres applications sur son téléphone!

Pour le téléchargement, rendez-vous sur la page dédiée du site de Macromedia, euh.... Adobe pardon!

Un certain nombre de librairies AS3 viennent d'être mises à disposition sur Adobe Labs. Elles offrent un accés à quelques API comme RSS, Atom, Flickr, et bien d'autres. Du feedback est le bienvenu évidemment!

Arghhhh, ce que c'est rageant de ne pas avoir le temps de me mettre à l'AS3...

Didier Brun aka Foxy, programmeur Flash freelance de son état, propose aujourd'hui une structure de formation d'une nouvelle forme : Flashead. Basée sur des années d'experience sur le terrain et dans le domaine de la formation, cette formule originale propose à tous de se former à la programmation Actionscript sur des cas concrets, avec à la fin de chaque section un veritable module qui tourne, directement utilisable dans le travail quotidien de tout programmeur AS! Vous l'aurez compris, cela consiste à rendre le stagiaire operationnel dés sa sortie de la session de formation.

Super concept, formateur trés compétent, Flashead ne peut être qu'une réussite!

Le passage à FDT n'est pas toujours sans douleurs... Les habitudes évoluent, et la façon de coder varie inmanquablement. Un des problèmes auxquels je me suis trouvé confronté a été l'utilisation de la commande 'trace', que l'on peut bien évidemment remplacer par un appel de méthode via l'option -trace de MTASC... Comme j'en ai déjà parlé, j'utilise la console SOS, pour le côté pratique de la connexion socket que sont la connexion à une console sur une machine distante, ou la gestion d'une couleur de fond différente par application (TRES utile !!!)

Le moyen que j'utilise aujourd'hui afin d'éviter les problèmes de non-importation de la classe s'occupant de se connecter à la console consiste à créer un petit répertoire utilitaire contenant les classes utiles à FDT, et de l'inclure dans mes "Linked librairies", et d'en appeler une méthode start(). Pour l'instant, seule le connecteur à la console est présent, mais il se peut que d'autres suivent (notamment mon petit framework de profiling, a venir plus tard :P)

Bref, voici ma classe SOSTracer, utilisée par MTASC avec l'option -trace SOSTracer.out :
/**
 * @author LAlex
 * @version 0.1
 * @since 2006-01-05
 */
class SOSTracer {
        // Console infos
        public static var SOS_HOST:String = "localhost";
        public static var SOS_PORT:Number = 4444;
        // Used for static method 'out'
        private static var __instance:SOSTracer;
        // Used for line number display
        private static var __lineNumber:Number = 1;
        // Allow to display line numbers
        public static var enableLineNumber:Boolean = false;
        // Static function, used for MTASC -trace option
        // SOSTracer.start() must be called before
        public static function out(o) {
                __instance.trace(o);
        }
        // Launch the static SOSTracer with
        // given background color
        public static function start(col:Number):Boolean {
                __instance = new SOSTracer(col);
                return true;
        }
        private var _bufferize:Boolean = true;
        private var _socket: XMLSocket;
        private var _isConnected:Boolean = false;
        private var _color:Number;
        // For later ;oP
//      private var _itv:Number = -1;
        // Buffer
        private var _stack: Array;
        function SOSTracer(col:Number) {
                if (col != undefined) {
                        _color = col;
                }
                _stack = [];
                _socket = new XMLSocket();
                _socket.onConnect = function (suc) {
                        var tr = arguments.callee.tracer;
                        tr._connected(suc);
                };
                _socket.onConnect.tracer = this;
                _socket.connect(SOS_HOST, SOS_PORT);
        }
        // Launched on socket connection
        private function _connected(sc:Boolean) {
                if (sc) {
                        if (_color != undefined) {
                                _socket.send("!SOS<appColor>" + _color + "</appColor>");
                        }
                        _flush();
                        _isConnected = true;
                } else {
                        _bufferize = false;
                        throw new Error("SOS Socket connection failed");
                }
        }
        // Flush buffer
        private function _flush() {
                while(_stack.length) _socket.send(_stack.shift());
        }
        // Display a string (or object representation)
        public function trace(o) {
                var no:String = (enableLineNumber ? "[" + __lineNumber++ + "] " : "") + o.toString();
                if (_isConnected) {
                        _socket.send(no);
                } else if (_bufferize) {
                        _stack.push(no);
                }
        }
} Le but est ici d'être indépendant de tout autre package, d'où l'utilisation d'une classe XMLSocket "de base" (j'en ai implémenté une plus évoluée), et l'utilisation d'un Delegate "à la main" Afin d'éviter de surcharger la connexion, je prévois ensuite d'utiliser un système de bufferisation éventuel, au moyen du buffer utilisé avant la connexion, et d'un setInterval (vous avez surement remarqué que la propriété pour l'intervalle est déjà prévue, mais pas utilisée encore :$). Pour l'utiliser, rien de plus simple, je lance un start() dans mon main et j'utilise trace() dans mon code : public static function main() {
        SOSTracer.start(0XFFFFCC); // Couleur de fond dans la console
}

Pour le déploiement, il suffit de changer dans MTASC l'option -trace SOSTracer.out par -trace no, et de commenter la ligne SOSTracer.start() (pas de import à commenter, du fait de l'absence de package 8))

::Télécharger SOSTracer.zip::

Il peut être trés pratique, voire parfois indispensable pour obtenir un code "clean", de ne pouvoir passer une valeur à une méthode, qui doit obligatoirement être une des valeurs "possibles"... C'est ce que l'on appelle des énumérations. Java gère cela nativement grâce à la classe Enum.

De même, avoir la possibilité de créer des constantes est également bien utile. Dans la pratique, il s'agit en fait de créer une propriété statique en lecture seule. Le moyen le plus sûr de faire cela serait de créer une variable statique privée, et un getter statique public.

Voici ce que cela pourrait donner dans le cadre d'une classe d'encryptage:
class Crypter {
        // Private static members
        private static var _NONE:String = "none";
        private static var _MD5:String = "md5";
        private static var _SHA1:String = "sha1";
        // Public constants
        public static function get NONE():String {
                return _NONE;
        }
        public static function get MD5():String {
                return _MD5;
        }
        public static function get SHA1():String {
                return _SHA1;
        }
        private var _cryptMode:String;
        function Crypter(mode:String) {
                _cryptMode = mode;
        }
        function encrypt(s:String):String {
                // Case use private vars, to avoid decreasing
                // performances by using a getter
                switch(_cryptMode) {
                        case _NONE:
                                return s;
                        case _MD5:
                                var md5crypted:String = "";
                                // Perform MD5 cryptage
                                return md5crypted;
                        case _SHA1:
                                var sha1crypted:String = "";
                                // Perform SHA1 cryptage
                                return sha1crypted;
                }
        }
}
// Usage
var myCrypter:Crypter = new Crypter(Crypter.MD5);
trace(myCrypter.encrypt("String to be encrypted")); Bien que tout cela soit quand-même assez clean, cette implémentation pose quelques problèmes:

• Tout accés aux constantes (de l'exterieur) fait appel à un getter, et donc les performances peuvent s'en ressentir, selon la fréquence de ces accés
• Il est possible de passer au constructeur une chaine de caractères qui ne fasse pas partie des valeurs attendues en entrée... Cela peut se résoudre avec un default: dans le case, mais ce n'est pas vraiment une solution satisfaisante...

• Impossible de rajouter des constantes non-prévues au runtime, du fait du constructeur privé.
• Toujours grâce au constructeur privé, impossible de modifier la valeur d'une constante, bien qu'il s'agisse d'une propriété publique.
• Impossible de passer une valeur non prévue à une méthode, si l'argument est typé avec l'énumération.
• Une compatibilité avec les types de bases. Bien que l'exemple se base sur un héritage de String, il est bien sûr possible de l'utiliser sur n'importe quel type "de base" (Number par exemple) comme sur des types plus complexes. Le '==' continue de fonctionner par exemple :trace(CryptMode.MD5 == "md5"); // true
  
• Petit bémol, le switch...case semble utiliser une comparaison stricte (===), donc ne pas oublier de faire un toString() ou valueOf() dans ce cas...
  
• Remplace presque parfaitement le fait de ne pas pouvoir créer de constantes dans les interfaces, offrant ainsi la possibilité de disposer d'une série de valeurs dans la création d'une API "pure" (sans aucune implémentation).

Bref, je suis assez content d'avoir trouvé ce moyen de rendre mes codes un peu plus clean. J'utilise dorénavant énormément cette astuce, notamment concernant la diffusion d'évenements, en créant une classe collection contenant les évenements diffusables par une classe définie, puis en utilisant le typage dans la signature de mes addEventListener (en parlant de ça, bientôt un tool de diffusion d'évenements maison).

Wala, wala! ^^

Le compilateur de Flash 8 semble contenir un bug qui, s'il est mineur, peut provoquer quelques arrachages de cheveux. En fait, lorsque l'on hérite d'une classe en précisant son chemin complet (donc sans import), le compilo va la considérer comme importée, mais ce n'est pas le cas à l'éxecution. La où l'on s'attend donc à obtenir une erreur de compilation, tout se passe bien, et on comprend donc mal où est l'erreur... :\

Petit exemple :class com.lalex.myappli.CustomSocket extends com.lalex.net.ExtendedSocket {
   function CustomSocket() {
      /**
      * ExtendedSocket.CONNECT_FAILED sera 'undefined'
      * car on a pas importé com.lalex.net.ExtendedSocket
      * Pourtant, le compilo laisse passer
      */
      addEventListener(ExtendedSocket.CONNECT_FAILED, this, handleConnectionFail);
   }
   private function handleConnectionFail(o) {
      trace("Connection failed");
   }
}
Bon, je vous l'accorde, on pourrait dire "Ben il n'avait qu'à importer la classe", ou "Il n'avait qu'à donner le chemin complet de la classe!"... mais le compilateur n'est-il pas là pour nous signaler ce genre d'oublis? :o

Flash Media Server 2 est enfin disponible! Plein de choses qu'elles sont bien, comme les connections côté serveur a des XMLSocket, XML et autre LoadVars. Pour moi, il s'agit également d'une découverte des fonctionnalités de base de FCS. J'apprécie beaucoup la simplicité avec laquelle on peut créer des applications multi-utilisateurs, ou des échanges de flux audio/video! Bon, ils auraient quand-même pu faire l'effort de l'AS2, surtout que le compilo AS1->AS2 existe déjà...

Seulement voilà, le débat fait rage. Le changement de nom de Flash Communication Server en Flash Media Server influe énormément sur les différentes licences proposées. En effet:

• les licences FCS étaient plus orientées sur les applications "data" (chat, jeux multi-user) qui nécessitaient de nombreuses connexions avec peu de bande passante. Elle pouvaient tourner sans problème sur une licence pro, offrant 2500 connexions simultanées pour une limite de 10Mbps, ce qui est largement suffisant pour de l'échange de données brutes.
  
• les licences FMS, elles, sont orientées sur les applications "media", avec un nombre de connexions assez limité mais sans limite de bande passante, ce qui est idéal pour la diffusion de contenus multimedia. Ainsi, la licence pro permet 100 connexions simultanées. Le problème étant que les applications "data" se retrouvent pénalisées, car pour avoir 2500 connexions simultanées, on se retrouve a devoir acheter 25 licences. Pour exemple, un provider qui voulait acheter pour 250.000$ de licences FCS se retrouve maintenant avec un investissement de 5.625.000$ à faire en licences FMS pour les mêmes capacités! En fait, il lui est possible de ne payer "que" 1.125.000$ en utilisant les licences Origin, mais ca fait quand-même du 450% d'augmentation! 8O

Cela pose un énorme problème, surtout qu'avec la sortie de FMS2, FCS n'est plus du tout vendu, et donc son système de licence n'est plus disponible... De nombreux développeurs de multi-user vont donc probablement se tourner vers des solutions de type SocketServer, ou pourquoi pas vers le trés prometteur Red 5 qui se pose aujourd'hui comme la seule alternative OpenSource à FCS/FMS avec de nombreuses features supplémentaires!

Un trés mauvais point pour Macromedia, qui devrait perdre du coup un grand nombre de développeurs, et donc de clients (car n'oublions pas que les développeurs sont quand-même les premiers commerciaux de Macromedia)! :\

PS: La solution de Macromedia en terme d'échange de données temps-réel nous viendrait peut-être de Flex, avec les Data Services de Flex Enterprise Services 2 qui peuvent, entre autres, utiliser le protocole RTMP.

Eh oui, je viens de le dire, je n'ai pas beaucoup de temps pour faire de la veille technologique en ce moment... En fait, il s'agit surtout de finir mes projets actuels, afin de prendre un nouveau départ!!!

En fait, je quite bientôt mon employeur actuel (avec une petite larme à l'oeil, CTC va me manquer quand-même :(), pour rejoindre l'équipe de Centile (avec la banane aux lèvres :D) pour un projet passionnant! Au coeur de ce que l'on peut appeler un "paradis pour développeurs" (y a que ca là-bas) dans ce qui semble être une super ambiance, ca va coder dur, et surtout en ActionScript (ben oui, malgré les nombreuses années depuis lesquelles je code en AS, c'est quand-même la première fois que c'est un travail a plein-temps, non freelance :P). Une nouvelle compétence chez eux, qui utilisaient plutôt des langages plus "institutionnels" (Visual, Java, ...). Bon, il faut avouer que celui qui a fait la première maquette est carrément balaise quand-même!

Au programme, connexion serveur temps réel et applications "standalone" de type mProjector... Je boût d'impatience!