Archives mensuelles : août 2009

News de la semaine #4

image

Comme la semaine
dernière
nous allons commencer cette série de news avec des nouvelles concernant
Windows Azure. Microsoft a en effet annoncé que les Live
Services allait être supprimé
de l’offre Windows Azure. Azure sera donc essentiellement
composé des modules .net Services et SQL Services (SQL Azure), tous les détails finaux
seront présentés lors de la PDC de novembre.

Toujours à propos d’Azure, Microsoft va présenter son offre de Cloud computing un
petit peu partout à travers le globe grâce à un
World Tour qui fera une escale à Paris le 9 octobre
.

Nikhil Kothari (architecte dans l’équipe ASP.net) nous propose une provider LINQ dédié
à la recherche sur le moteur Bing : Linq
To Bing
. Au delà de l’utilité du provider en lui-même, il est surtout intéressant
de consulter les sources afin de voir comment il est possible de créer son propre
provider LINQ afin de requêter n’importe quelle source de données.

Du côté de WPF, il est à noter une initiative intéressante de Chris Cavanagh. Celui-ci
a développé un
vrai contrôle WebBrowser en WPF
basé sur le moteur d’affichage de Google Chrome.
L’intérêt d’un tel contrôle est qu’il est possible d’appliquer des styles et/ou transformations
sur le webbrowser contrairement au contrôle fournit avec WPF qui n’est qu’un simple
wrapper de l’ActiveX d’IE.

John Robbin le guru du debugging de Wintellect nous propose quand à lui un post intéressant
propos du contenu des PDBs
.

Et enfin Scott Guthrie, que l’on ne présente plus, débute une série de posts à propos
des nouveautés de Visual Studio 2010 et du framework .net 4.0. Vous pouvez consulter chaque
“épisode” de la série sur cette page
.

Crossposté vers THB

Les cables, espèce en voie de disparition

Mes collègues de bureau pourront le confirmer il n’arrive pas à un mois où je ne râle
pas sur le fait qu’il n’y est pas quelqu’un qui ait inventé un système permettant
d’éviter d’avoir à utiliser des câbles d’alimentation que cela soit pour alimenter
des appareils électroniques d’usage quotidiens tels que les téléphones portables ou
les lecteurs MP3, ou encore les laptops.

Si les câbles d’alimentation m’ennuient tellement c’est pour la simple et bonne raison
qu’il s’agit des seuls câbles que j’utilise encore (que je branche et débranche régulièrement).
Entre l’utilisation du WIFI pour les connexions réseaux, et l’utilisation du bluetooth
pour l’utilisation de différents périphériques (clavier, souris, télécommande, mannettes
de jeu), j’essaie dès que je le peux de réduire au maximum l’utilisation de ces fils
qui sont une véritable contrainte. Je ne comprends d’ailleurs pas la sous-utilisation
du bluetooth. Un grand nombre de personnes utilisent encore des souris qui trainent
péniblement un fil à la patte alors que le bluetooth existe depuis maintenant bien
longtemps et fonctionne très bien. Vous l’avez compris je suis entièrement d’accord
avec Sheldon quand il indique que tout est mieux avec du bluetooth (“Everything is
better with bluetooth”) :

>>>

Si je vous fait part de cela, ce n’est pas pour partager certaines frustrations, mais
plutôt pour partager avec vous une technologie que je viens de découvrir via une
session TED
: la WiTricity. La technologie a été inventée par des chercheurs du
MIT en 2005 et permet d’alimenter des appareils grâce à des relais. En plus de pouvoir
alimenter une ampoule de 60W à une distance de 2M, cette technologie basée sur l’utilisation
des champs magnétiques permet de fournir en énergie, des téléphones portables, des
laptops et même une télévision. Ce n’est pas juste un concept, cela fonctionne vraiment
comme vous pourrez le constater grâce à cette vidéo :

>>>

Comme vous pouvez le voir la WiTricity semble assez avancée, il ne reste plus qu’
rester patient en attendant l’industrialisation du process, et une exploitation commerciale.
Même s’il va falloir attendre plusieurs années avant de voir la WiTricity bouleverser
nos habitudes, on sait à présent que l’électricité sans fil, c’est (presque) pour
demain !

En savoir plus :

http://www.witricity.com/

Critique : The Pragmatic Programmer

L’ouvrage “The Pragmatic Programmer” sous-titré “from journeyman to master” est certainement
un des livres que je lis le plus régulièrement. J’essaie en effet de le relire au
moins une fois tous les ans afin de revoir comment je peux améliorer mes habitudes
de développeurs. Il est en effet très important d’analyser ses méthodes de travail
et de les confronter avec les meilleures pratiques dans le domaine afin d’améliorer
la qualité du travail fini, améliorer sa productivité, et tout simplement travailler
dans de meilleures conditions. The Pragmatic Programmer est LE livre qu’il vous faut
si vous aussi vous avez cet objectif.

De l’utilisation d’outils de contrôle de code source, de la pertinence d’utiliser
des techniques de refactoring, de la nécessité de tester son code, d’améliorer ses
techniques de debugging, ce livre évoque un grand nombre de vérités que l’on peut
parfois considérer comme des banalités, mais qui ne sont parfois pas si simple à mettre
en œuvre dans la vraie vie.

Un sujet qui pourrait vite être rébarbatif et ennuyeux si la pédagogie de l’ouvrage
n’était pas aussi réussie. Les analogies employées sont par exemple très intéressantes
et sont une vraie valeur ajoutée. Ce point est d’ailleurs crucial puisque travaillant
en équipe, il est important de savoir partager les idées proposées afin de convaincre
les personnes avec lesquelles vous travaillez d’améliorer les méthodes de travail
habituellement utilisées.

Vous l’avez compris, contrairement au
précédent ouvrage dont je vous avais parlé
, je vous recommande la lecture de ce
livre. Même s’il n’est plus tout jeune, les principes et conseils proposés sont toujours
d’actualité.

En savoir plus :

The
Pragmatic Programmer: From Journeyman to Master

image

Après Workflow Services, c’est le tour du Live Framework

Microsoft lancait en grande pompe Windows Azure il y a près d’un an à Los Angeles
lors de la PDC 2008, et s’apprête à lancer la première version commerciale lors de
la PDC 2009 en novembre.

image

L’éditeur profite de l’année qui sépare ces deux évènements afin de faire les “derniers
ajustements” avant de se lancer pour de bon dans la stratégie du cloud computing.
Premier changement de taille : la brique Workflow Services qui faisait partie de .net
Services a été supprimée (pour être plus précis suspendu jusqu’à nouvel ordre). Cette
suspension fait suite à des retours utilisateurs qui souhaitent que Workflow Services
se base sur Workflow Foundation présente dans le framework .net.

Aujourd’hui, Microsoft vient d’annoncer une autre suppression et celle-ci est de taille
puisqu’il s’agit d’une brique tout entière de Windows Azure, le framework Live, qui
se retrouve supprimé. Les services apportés par la CTP de ce framework seront en effet
complètement arrêtés le 8 septembre. Ce framework sera, dans le futur, intégré au
sein de Windows Live.

Who’s next?

Bon sinon il y a au moins une bonne nouvelle aujourd’hui, les premières clés d’accès
à SQL Azure viennent d’être envoyées. Il est donc enfin possible de tester cette brique
importante de Windows Azure.

En savoir plus :

http://www.liveside.net/main/archive/2009/08/21/live-framework-ctp-to-shut-down-september-8th.aspx

http://blogs.zdnet.com/microsoft/?p=3777

image

News de la semaine #3

image

Pour commencer les news de cette semaine, deux actualités concernant Windows Azure.
La première concerne la mise à jour du Training Kit qui s’enrichit de mois en mois
et dont l’August Update est à présent disponible
en téléchargement
. Wintellect propose quand à eux une application exemple qui
sert de presse-papier sur le cloud. CloudBoard est ainsi mis à disposition (binaires
+ sources) sur codeplex.

Toujours à propos d’applications exemples, DinnerNow.net est
à présent disponible en version 3.1. Cette nouvelle version ajoute le support de fonctionnalités
propres à Windows 7 et Windows Server 2008 R2.

Une présentation d’Eric Meijer réalisée à l’OSCON 09 est disponible. Celle-ci traite
de la programmation fonctionnelle et vous pouvez la
consulter ici
.

Du côté des publications françaises, Romain Verdier (oui
encore lui
), nous propose un article
sympathique sur les évènements en C#
.

En attendant
LinqToWinDBG
, Sacha Goldshtein nous propose une méthode afin de récupérer
les différents instances en mémoire d’un type
, une solution baséé sur les WeakReference.

Toujours aussi prolifique, Scott Mitchell a publié un article sur la gestion
d’exception
dans les applications ASP.net. Rien de neuf, mais cela ne fait jamais
de mal à revoir.

Du coté de WPF, Microsoft fournir une première version d’un outil fort utile nommé
: WPF
Control Verifier
. Cet utilitaire permet de tester les différents contrôles WPF
que l’on a développé afin de verifier que l’on respecte bien les guidelines fournies
par Microsoft.

Et enfin, pour tout ceux qui sont déçu de ne pas pouvoir télécharger les vidéos de
la NDC 2009 (il y avait du beau monde), sachez que vous pouvez télécharger une grande
partie des sessions via bitTorrent. Vous pouvez les récupérer ces deux torrents 1 & 2.
Il y en a en tout pour 20Go.

Crossposté vers THB

Encore une idée que je ne ferais pas : Linq To HLSL

C’est en lisant ce tweet de
Robert Pickering que j’ai eu l’idée d’écrire des posts sur les différentes idées (bizarre,
originales ou farfelues) qu’il m’arrive d’avoir. En effet, comme l’indique Robert,
et comme beaucoup d’entre vous je suppose, il m’arrive parfois d’avoir des idées qui
m’intéressent et qui me motivent mais par soucis de temps ou de compétences, je ne
les réalise que rarement. Je me propose donc de partager dorénavant certaines de ces
idées avec vous. Le but étant bien entendu d’avoir vos réactions, commentaires et
remarques. Commençons donc dès à présent avec la dernière idée en date que j’ai eu
(début de cette semaine).

Les GPU ont actuellement une puissance de calcul supérieure aux CPU et malheureusement
il n’est pas simple d’en profiter. Microsoft a étudié cette faisabilité via
le projet Accelerator
initié par Microsoft Research. DirectX 11 poursuit dans
cette voie grâce à l’apparition des Compute Shaders. Ces shaders particuliers n’ont
pas pour objectif de modifier un rendu graphique (d’effectuer des traitements sur
des pixels) mais d’effectuer différents types de calculs.

L’idée d’exploiter ces shaders m’est venu en rentrant un peu plus en détail dans le Windows
API Code Pack for .net
. Ce projet disponible sur Code Gallery permet principalement
d’exploiter les nouvelles APIs apparues avec Windows 7 directement depuis du code
managé. Mais l’API Code Pack for .net propose d’autres fonctionnalités tels que des
wrappers managés de DirectX 10.x et DirectX 11. Et en consultant la documentation
de ces wrappers je me suis rendu compte qu’il était possible d’appeler et d’exécuter
des Compute Shaders directement depuis du code managé. Ce fut une surprise puisque
depuis DirectX 9 qui disposait d’une version managée (un wrapper intelligent nommé
Managed DirectX), Microsoft avait fait un retour en arrière en ne proposant de développer
des applications DirectX qu’en code natif. Fonçant tête la première et pompant allègrement
un code natif trouvé sur le net je me retrouve rapidement avec ces quelques lignes
de code :

SwapChain swapChain;
SwapChainDescription swapChainDescription = new SwapChainDescription();
swapChainDescription.BufferCount = 1;
swapChainDescription.BufferDescription.Width = 1024;
swapChainDescription.BufferDescription.Height = 768;
swapChainDescription.BufferDescription.Format = Format.R8G8B8A8_UNORM;
swapChainDescription.BufferDescription.RefreshRate.Numerator = 60;
swapChainDescription.BufferDescription.RefreshRate.Denominator = 1;
swapChainDescription.BufferUsage = UsageOption.RenderTargetOutput;
swapChainDescription.OutputWindowHandle = m_windowHandle;
swapChainDescription.SampleDescription.Count = 1;
swapChainDescription.SampleDescription.Quality = 0;
swapChainDescription.Windowed = true;
var levels = new FeatureLevel[]
                            {
                                FeatureLevel.FeatureLevel_11_0,
                                FeatureLevel.FeatureLevel_10_1,
                                FeatureLevel.FeatureLevel_10_0
                            };
var driverTypes = new DriverType[]
                      {
                          DriverType.Hardware,
                          DriverType.Reference
                      };
D3DDevice device = null;

foreach(var driverType in driverTypes)
{
     device = D3DDevice.CreateDeviceAndSwapChain(null, driverType, null,CreateDeviceFlag.Default , levels,
                                                          swapChainDescription, out swapChain);
}

//Check Support for Compute Shader
FeatureDataD3D10XHardwareOptions options;
device.CheckFeatureDataD3D10XHardwareOptions(out options);
if(!options.ComputeShadersPlusRawAndStructuredBuffersViaShader4x)
    return;

device.CreateComputeShader();

Comme vous le devinez, la méthode CreateComputeShader attend un paramètre afin de
pouvoir être exécutée. Il faut en effet lui passer un pointeur vers le code d’un Compute
Shader compilé. Le problème suivant auquel j’ai donc été confronté fut donc de développer
un compute shader. Comme les shaders traditionnels, ceux-ci se développent dans un
langage spécialisé : le HLSL. Et après avoir jeté un oeil dans la documentation de
ce langage, je me suis vite rendu compte qu’il n’allait pas être simple d’implémenter
un traitement utile avec ce langage basé sur une syntaxe proche du C. Le langage propose
en effet un ensemble de types assez restreint et ne permet pas au pauvre développeur
managé que je suis de faire ce que je souhaite de manière simple. Partant de ce constat,
et pensant qu’il serait utile de simplifier l’accès au GPU via ces compute shader,
j’ai donc songé à l’idée de créer un provider Linq To HLSL. L’objectif de ce provider
est “simple” : Générer du code HLSL à partir d’un arbre d’expression, le compiler
en mémoire (ah mince D3DCompile ne semble pas implementé dans l’API Code Pack for
.net), l’exécuter et récupérer les informations en mémoire. Bien sûr en pratique,
il existe plusieurs difficultés de taille, notamment celle concernant le nombre de
types restreints supportés par HLSL contrairement aux langages managés. Il faudrait
lors de la génération de code convertir les types non supportés (quand cela est possible)
vers des types HLSL. Une chaine de caractères devrait être ainsi par exemple converti
en tableau d’entiers avant de pouvoir être manipulé.

Pourquoi je ne le ferais pas :

  • Il n’existe pas encore de cartes graphiques compatible DirectX
    11. La première qui sera disponible sera une carte AMD et devrait être mise en vente
    le 10 septembre. Il n’est donc pas encore possible de tester les réelles performances
    du projet.
  • Cela m’obligerait à apprendre un nouveau langage HLSL, langage
    très spécifique qu’il peu probable que j’utilise dans le futur.
  • Je n’ai absolument aucune idée du temps nécessaire pour développer
    ce type de provider (je sais que ça se rapproche de beaucoup mais je ne suis pas capable
    d’être plus précis que cela).
  • Et enfin, il semblerait que le langage Axum supporte à la fois
    le multi-core (plusieurs coeurs/processeurs) et many-core (différents types de coeurs
    (CPU/GPU)). Etudier ce projet devrait donc être plus pertinent que de développer ce
    provider.

clip_image001

La virtualisation, Windows 7 et le 64 bits

Lorsque l’on installe la version 64 bits de Virtual PC 2007 sur un OS 64 bits, on
est surpris de voir que le programme souhaite s’installer
dans le dossier Program Files(x86)
réservé aux applications 32 bits au lieu de
s’installer dans le dossier Program Files où reposent les applis 64 bits. Il n’y aucune
erreur dans l’installation, le fait est que Virtual PC 2007 64bits reste une application
32 bits mais qui utilise des drivers systèmes 64 bits.

Cependant le fait que Virtual PC reste 32 bits, a un impact important : vous avez
beau avoir installé un 0S 64 bits et disposer de Virtual PC 64 bits, il ne
vous sera pas possible d’installer un OS 64 bits en Guest dans une machine virtuelle
!
Si vous tentez une telle installation vous vous retrouverez avec l’erreur suivante
: “Attempting to load a 64-bit application, however this CPU is not compatible with
64-bit mode” :

clip_image001

La même limite existe pour Windows Virtual PC (la version de VPC dédiée
Windows 7) ainsi que pour Virtual Server 2005 R2.

La seule solution possible proposée par Microsoft pour virtualiser du 64 bits est
Hyper-V. A noter qu’il n’est pas conçu pour les notebooks et donc supporte
assez mal les mode de veille ou d’hibernation
.

Autre solution, se passer des solutions Microsoft et utiliser VMWare qui est même
capable de faire tourner une machine virtuelle 64 bits dans un OS 32 bits.

News de la semaine #2

Lionel
Limozin nous présente une des nouveautés apportées par le
feature pack de Visual C++ 2008
à propos des pointeurs. Avec schémas de la consommation
mémoire à l’appui, son
post est une bonne illustration
de l’utilisation de la classe shared_ptr.

Une mise à jour des Power Toys pour le Compact Framework 3.5 vient d’être mise à disposition
afin de résoudre des problèmes
de compatibilité
avec Windows Vista SP2, Windows Server 2008 SP2, et Windows 7.
Vous pouvez la télécharger
ici
.

Décidemment sur tous les fronts, après
avoir lancé une béta privée de MonoTouch
, l’équipe de Novell continue de bien
progresser sur le développement de Moonlight 2.0. Pour preuve, QuakeLight
tourne à présent sur Moonlight
!

Raymond Chen (The Old New Thing) nous propose sa CLR-week annuelle ! Au programme
: résolution
de problèmes courants liés aux p/invoke
, pourquoi
String.Format ne lève pas une exception lorsqu’on lui passe trop de parmaètres
, pourquoi
on ne peut pas passer de référence d’une classe dérivée à une méthode qui prend une
référence d’une classe de base par référence
.

Du côté de la bibliothèque Moq, Daniel
Cazzulino
nous annonce la
disponibilité d’une version beta de Linq to Mocks
qui permettra de créer ses mocks
de manière déclarative grâce des requêtes Linq.

Afin de fêter son 25ème anniversaire, Microsoft Press met à disposition en téléchargement
gratuitement, chaque mois, un ouvrage publié par l’éditeur. Ce mois-ci il s’agit d’Understanding
Microsoft Virtualization Solutions
.

image

Construire ses propres chaines de télévision grâce aux RSS et au protocole DLNA

Je vous propose au travers de ce post, de voir comment j’ai complètement changer l’utilisation
de mon poste de télévision en regardant quasiment exclusivement du contenu qui m’intéresse
réellement.

Depuis deux semaines, j’ai en effet complètement changé d’habitude puisqu’au lieu
de regarder des émissions disponibles sur les différentes chaines hertziennes, je
consulte à présent tout un ensemble de vidéos que je télécharge automatiquement grâce
à mon client RSS habituel. Afin d’avoir le meilleur confort visuel possible, il est
nécessaire de consulter les vidéos dans la meilleure résolution possible. Et c’est
ainsi avec une agréable surprise que j’ai découvert que les principaux sites auxquels
je souhaitais m’abonner proposaient, en plus du flux RSS principal qui proposent les
vidéos en qualité moyenne, des flux RSS proposant les vidéos en qualité haute-résolution.

Une fois ces vidéos automatiquement téléchargées grâce à mon client RSS, je les consulte
sur ma télévision grâce
à ma PlayStation 3 et au protocole DLNA
. Ce protocole permet d’interconnecter
de manière transparente différents équipements audio/vidéos via un réseau filaire
ou wifi. C’est ainsi qu’il est possible de consulter de manière très simple vos vidéos
stockées sur votre PC directement sur votre télévision via le WIFI :

Et le résultat est vraiment impressionnant. La qualité de diffusion est vraiment excellente
tant que l’on ne lance pas des téléchargements couteux en bande passante durant le
streaming de vidéo entre le PC et la TV et tout cela sans aucun câble.

L’activation du DLNA sous Windows 7 est simple à mettre en œuvre. la première étape
consiste a vérifier que votre connexion WIFI est configurée en tant que “Home Connection”
afin de partager votre contenu de manière simple et sécurisée :

image

Suivez ensuite les étapes suivants afin d’activer le streaming via DLNA :

image image image

Et c’est terminé ! Votre PC est désormais visible par les équipements compatibles
(XBOX ou PS3 par exemple) et vous pouvez consulter vos vidéos directement sur votre
télévision, en pilotant vos vidéos à l’aide de votre télécommande.

Pour info, voici une liste des sites auxquels je me suis abonné et que je consulte
donc tranquillement depuis mon canapé :

Sites non techniques :

TEDTalks (hd) TEDTalks Video High-Def
Ignite Logo Ignite

Et coté vidéos techniques, je suis abonné à différentes émissions :

This Week On Channel 9 This
week on Channel9
10-4 10-4
Going Deep Going Deep
Toolshed Toolshed
Inside Out Inside Out

Je teste ce principe depuis deux semaines, et je suis complètement convaincu. Je n’ai
aucune action manuelle à faire, il suffit que mon PC soit démarré sur mon bureau,
pour que je sois capable de consulter sur ma télé des contenus qui sont récupérés
automatiquement de manière transparente par mon client RSS.

clip_image001

Savoir si un CPU supporte le 64 bits

Si vous allez changer d’OS (pour migrer vers Windows 7 par exemple) et souhaitez être
sûr que votre machine supporte le 64 bits vous avez deux solutions simples.

Si votre CPU fait partie de ceux-cités dans le tableau suivant vous avez votre réponse
:

Processeur

32- or 64-bit

Intel Core Solo

32 bit

Intel Core Duo

32 bit

Intel Core 2 Duo

64 bit

Intel Quad-Core Xeon

64 bit

Sinon, vous pouvez utiliser un utilitaire proposé par Intel nommé “Intel
Processor Identification Utility
” qui vous permettra d’avoir toutes sortes d’infos
sur votre CPU comme par exemple celle du support du 64 bits :

clip_image001