Petit problème avec le composant papervision3D collada scene : comment localiser le fichier .dae lors d'une publication sur un site dynamique?
Ma solution écrire l'url du fichier dans le paramètre Collada File et laisser vide le paramètre Local Directory.

Qui dit mieux?

Petite revue des points essentielles que j'ai noté sur les nouvelles technologies de l'année 2007.
Je ne traite pas des technologies Web et Open-sources qui occupent des niches souvent prometteuses mais moins diffusées dans l'industrie. Je ne traite pas non plus des technologies Sun par gout personnel...

Les technologies microsoft :

• Xaml est définit à un niveau de granularité plus faible que le mxml, il est donc plus flexible mais nécessite de manipuler plus de code.
• WPF est intégré à vista mais nécessite l'installation du Framework .net 3.0 pour les autres windows. C'est un chargement très lourd et peu pertinent. Une application WPF ayant une interface Xaml reste facilement skinnable. .net CLR intègre de plus en plus de languages avec notamment ruby.
• Silverlight sera intégré à Visual studio 2008 que microsoft propose déja une beta. Comme WPF il repose sur une interface Xaml. Ces principaux point faibles sont le manque de références, une littérature encore limitée (Les bouquins amériquains sur silverlight 1.0 vont sortir à partir d'octobre). Les démos techniques sont prometteuses, et disposent de bonnes performances.

Les technologies Adobe :

• ActionScript 3.0 dispose d'un compilateur JIT (just-in-time) très performant. Il permet notamment l'utilisation de technologies 3D avancées.
• AIR est très facile d'installation (moins de 10 mega), il intégre un browser webkit et permet à chaque application de s'auto-updater selon son numéro de version.
• L'intégration de flex avec AIR serait finalisée avec flex 3. La principale faiblesse de .air reste ses limites en terme de protocoles de communication en raison d'une sécurité élevée : .air peut seulement lire et écrire des fichiers, appeler des Webservices et accéder à une base de données SQLite.
• L'interface mxml est plus facilement skinnable que celles reposants sur des composants flash (à travers des attributs et la CSS).

Créer un launcher avec un affichage flexunit comme ci dessous.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx=" http://www.adobe.com/2006/mxml" layout="absolute"
     xmlns:flexunit="flexunit.flexui.*" applicationComplete="ini()">
<mx:Script>
    import flexunit.framework.TestSuite;
   
    private function ini():void
    {
         testRunner.test = createSuite();
         testRunner.startTest();
     }
     
     private function createSuite():TestSuite {
              var suite : TestSuite = new TestSuite(MainTest);
             return suite;
    }
</mx:Script>

    <mx:Canvas x="10" y="19" width="252" height="247" borderColor="#FFFFFF">
    </mx:Canvas>
    <flexunit:TestRunnerBase id="testRunner" width="100%" height="100%" />
</mx:Application>

Créer une suite de tests du type :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

package {
 
     import flexunit.framework.TestCase;
     import flexunit.framework.TestSuite;
    
     public class MainTest extends TestCase {
         
          public function MainTest() {
               super( methodName );
           }
     
  public function testToInt():void {
    //un test de la function toInt par exemple
  }
           
         
      }
}

Voila vous êtes prêt, il ne vous reste plus qu'à organiser votre code selon les tests. Pour plus de renseignement je vous renvois à ma source d'inspiration.

Ce schéma représente l'ensemble des technologies du sdk flex et compatibles flash cs3.

Voici quelque liens pour découvrir les possibilités de Flex :

• Component explorer
• Style explorer
• Filter explorer
• Effect explorer(ne marche pas actuellement)
• Primitive explorer

Quelques démos techniques :

• Flexstore
• sliderocket
• cube 3D
• foorplanner
• papercritters
• anywhere.fm

Quelques tutorials :

• Débuter
• Effects
• Liquid layout
• Skinning
• Gradient

Quelques documents de références :

• UIComponent
• Evenement
• Dessin
• Son
• Video
• Image

La version 1.5.1 supportait les sélecteurs CSS3, cette fois la principale amélioration concerne la gestion des évènements.
La release candidate 1.6 propose les améliorations suivantes :

• La cadre de Element#oberve fait correspondre au "this" l'élement qui l'appelle automatiquement (pas besoin de binding, ou de Function#methodize).
• L'appelle à plusieurs méthodes "statiques" est désormais possible depuis les instances.
• On peut accèder à l'event.target dans tous les navigateurs.
• Element#fire permet de créer un type d'évènement dont l'identité peut être "écoutée".
• La function onload ultime a été implémentée à travers l'évènement "contentloaded".

Cette nouvelles versions apporte d'autres nouveautés parmis lesquelles voici mes préférées :

• document.viewport permet d'accéder aux dimensions et à la position de la fenêtre avec : getDimensions(), getWidth(), getHeight() et getScrollOffsets().
• Function#wrap permet d'étendre une fonction (ca doit permettre les mixins).

Il y aussi ajout de syntaxique sugar :

new Element("input", { name: "user", disabled: true })

$("header").setStyle("font-size: 12px; float: left; opacity: 0.5");

Et pour finir un exemple d'héritage bien sympathique:

1
2
3
4
5
6
7

// subclass that augments a method
var Cat = Class.create(Animal, {
  eat: function($super, food) {
    if (food instanceof Mouse) return $super();
    else return this.say("Yuk! I only eat mice.");
  }
});

Connaissez vous le JavaScript Hijacking? Il s'agit d'une méthode qui pirate la protection du code éxécutable par votre navigateur (localisée par nom de domaine). Le pirate crée ou profite de brèches à travers le transfert Asynchrone (XHR, IFrame ou <script>) pour récupérer des données sensibles.
Pour prévenir ce risque, de nombreuses bonnes pratiques sont à suivre, en voici quelques exemples :

• Limiter l'accès aux URL qui renvoient les données non publiques, à l'aide d'une clé pouvant reposer sur l'identifiant de session, ou un paramètre obligatoirement envoyé en POST.
• L'ajout préfixé d'un code au JSON qui doit alors être nettoyé par le client.

La version 1.5.1 de prototype a aussi apporté des améliorations notables pour y faire face :

• Codage et décodage JSON avec evalJSON(true) qui propose un paramètre sanitize pour éviter des attaques XSS (cross-site scripting, le danger de toute approche web2.0).
• Il est de plus hautement conseillé d'envoyer son JSON commenté, et avec le bon header requestHeaders: {Accept: 'application/json'},)

Ruby est purement objet même lorsqu'il permet de la programmation fonctionnelle, mais le paradigme "héritage & aggrégation" me semble remis en cause par son approche modulaire plus centrée sur le "namespace & introspection".

La métaphore qui se rapproche le plus du mixin est le skinning, on part d'une classe spécialisée auquelle on applique un comportement plus général. Pour simplifier, la OOP classique c'est de l'architecture et la MOP c'est de l'alchimie.

Warning! attention ce billet va partir en trip (vous êtes prévenu)

Programmation Orienté Alchimie ? L'idée m'a amusé et j'ai été voir ce que Wikipédia disait à ce propos. Je partages avec vous quelques passages tirés de sa définition :

1
2
3
4
5
6
7
8
9
10
11

def alchimie
"L'alchimie est une science ésotérique dont l'objet est l'étude de la matière 
et de ses transformations..." +
"..les textes alchimiques possèdent la particularité d'être codés. Il s'agit 
d'un savoir qui n'est transmis que sous certaines conditions.." + 
"..seul un être vivant intelligent pourrait effectuer des opérations alchimiques. 
Vouloir automatiser les procédés alchimiques ne servirait donc à rien." +
"Les présupposés populaires laissent à penser que la terminologie descriptive
 de l'alchimie se réduit à une sémantique propriétaire ..C'est là une des plus 
grandes erreurs que commettent les profanes."
end

Surprenant non? De là à trouver des vertus philosophales à notre chère pierre précieuse...(la pierre philosophale est vraiment censée être rouge! Après Da Vinci Code, serions nous en plein dans du Da Matz Code? ;) )

La prochaine fois qu'on vous demandera ce que vous pouvez faire de plus gràce à Ruby, répondez donc de l'or!

Le FocusManager permet de donner le focus à un composant de votre interface, il est très facile d'utilisation :

focusManager.setFocus(componentId);

Note : Il m'est arrivé d'avoir des débordement de pile à cause d'un bug de flex présent dés qu'on utilise une autre application que la navigateur. Dans ce cas je conseille de mettre le focusEnabled de chaque composant à false.

La famille Eval se compose des méthodes suivantes :

• eval() interprête un string comme du code dans un contexte pouvant être rattaché à un binding.
• instance_eval() inclue le code interprété à l'instance qui l'appelle (l'objet self par défaut)
• class_eval() inclue le code interprété comme des méthode de la classe l'appelant
• module_eval() est un alias de class_eval

Il faut surtout retenir que instance_eval et class_eval sont définis en fonction du cadre de leurs définitions et pas du destinataire final de leurs interprétation (La Class ou l'objet instancié).

Mon classement des trucs les plus cools avec Ruby :

• Mixin (Ruby)
• Minimal Syntax for DSL (Ruby)
• MVC (Rails)
• URL Routing (Rails)
• Eval family (Ruby)
• Pure OOP (Ruby)
• ActiveRecord (Rails)
• Introspection (Ruby)
• Functionnal Programming (Ruby Procs/Blocs)
• Automatisation (Rake, Capistrano, Rdoc)
• Migration (Rails)
• Shell scripting (Ruby)
• Active Resource (Rails)
• Generators (Rails)
• irb (Ruby)
• Gem (Ruby)

Sacrée liste! je ne pensais pas qu'elle serait si longue quand je l'ai commencée. Ya pas à dire Ruby est vraiment cool!
On pourrait presque faire un bouquin avec ca, il devrait s'appeler: "Ruby is so cool !" (en fait je pense que Why est déja en train de l'écrire).

J'ai eu envie de me simplifier la vie aujourd'hui. J'ai décidé d'écrire une tâche Rake pour uploader des fichiers souvent mis à jours, sur un serveur distant.
Je n'avais aucunes idée de la meilleure solution et comme souvent dans ces cas là, ca n'a pas été simple de la découvrir.

Je me suis d'abord intéressé à Capistrano mais je l'ai trouvé surdimensionné par rapports à mes besoins personnels. Je croyais que rsync serais à ma mesure mais le manque de documentation m'a freiné.
Et puis j'ai réalisé qu'un simple sftp me convenait parfaitement. Cela avait plusieurs avantages : possible connection automatique (il semble que ce soit la différence avec scp) et possible utilisation de la librairie Net::SFTP.
Mais mauvaises surprises: je n'aime pas la syntaxe de Net::SFTP (NB: et il existe déja un script pour la synchronisation à distance) et la connection automatique de sftp par batchfile n'accepte pas les passwords!
Il a donc fallu générer des clés partagées avec la commande (ssh-keygen -t rsa) et après un peu de shell scripting via le Kernel, voici donc une tâche Rake muy buena :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#Attention, n'utilisez pas ce script si vous ne le comprenez pas!
#Nécessite d'avoir sftp d'installé et une clé partagée avec le serveur

desc "sftp command to customize"
task :sftp do
        #server address
        server_address = "you@example.com"
        #sftp command
        source_dir = "#{RAILS_ROOT}/dir_to_upload/*"
        destination_dir = "remote_dir/"
        command = "put "+ source_dir
        #sftp call
        call = "sftp -b /dev/stdin" + " " + 
                server_address + ":" + destination_dir + 
                " <<EOF\n" + command + "\nquit\nEOF\n"
        puts call
        system(call)
end

Pour ceux qui ne connaissent pas sftp, voici les principales commandes qu'il supporte :

• cd : changement de répertoire distant.
• lcd : changement de repertoire local.
• ls : liste des fichiers distants.
• lls : liste des fichiers locaux.
• put : upload de fichier.
• quit : fin de la connection.
• get : download de fichiers.
• mget : multiple get.

Vous avez remarquez ? ce billet est dans la section agilité, et bien ce n'est pas une technologie mais une philosophie qui participe à l'écriture de bon programmes.
Tout ca pour écrire ce que j'entends par agile :

• Une automatisation de tous les workflows répétitifs.
• Des fonctions organisées de facon à être testées et DRY.
• Une séparation souple de la configuration du programme et de ses règles logiques.
• Une approche pragmatique et itérative de la gestion de projets.
• Pas de sur-optimisation et de sur-spécification.

C'est ma vision personnel de ce que certains appellent Getting Real.

J'ai décidé de partager une petite méthode qui génère le cache d'une page..
Comment ca? ca existe déja! Ha non attendez, c'est très différent regarder bien le nom des fonctions : caches_page (!=) caches_page_now.

Vouz avez compris? Non! Bon arrêtons de perdre notre temps, allez lire un autre billet et revenez quand vous aurez besoin d'exporter des pages web.

1
2
3
4
5
6
7
8
9

def caches_page_now(attrs)
    #be carefull to add a route for '.html'
    path = "#{RAILS_ROOT}/public/#{attrs[:controller]}/#{attrs[:action]}.html"
    #don't forget to instanciate the action variables
    content = render_to_string(:action => attrs[:action])
    File.delete(path) if File.exists?(path)
    FileUtils.makedirs(File.dirname(path))
    File.open(path, "wb+") { |f| f.write(content) }
 end

Envie d'une url se terminant en .html pour votre application Rails?
Dans X_controller.rb, redéfinissez la méthode default_url_options qui sert aux UrlHelper :

1
2
3

def default_url_options(options)
  { :format => 'html' }
end

Dans routes.rb on définit le format des urls manipulées par Rails.

1
2

map.connect ':controller/:action.:format' # pour action.html
map.connect ':controller/:action/:id.:format' # pour id.html

La métaprogrammation permet de personnaliser de Ruby à ses besoins, pour en faire un langage de programmation sur mesure. Que demander de plus à un langage haute-couture haute-programmation? Voici quelques exemples d'utilisation :

• Créer dynamiquement des fonctions d'après un unique prototype avec eval

  1 2 3 4 5 6 7

  def make_function(function_name) eval <<- FLAG def #{function_name}(function_arg) @#{function_name} = function_arg end FLAG end

• Définir une syntaxe ouverte avec public_method_defined?(symbol)
• Modifier une fonction avec wrap_method

  1 2 3 4 5 6 7 8

  class Module def modify_function(function_name) wrap_method(function_name) do |org_method, args, block| # exemple: args = args.collect{|x| puts x} org_method.call(*args, &block) end end end

• Charger dynamiquement des fichiers de codes avec load et require