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

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/

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

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.

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

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

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.

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” :

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.

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.

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 :

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

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 Video High-Def
	Ignite

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

	This week on Channel9
	10-4
	Going Deep
	Toolshed
	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.

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 :

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 :

En C# si l’on souhaite utiliser le mot clé sizeof, la documentation précise qu’il est nécessaire d’utiliser le mode unsafe grâce au mot-clé du même nom.

En effet, si l’on souhaite par exemple récupérer la taille d’une struct à l’aide de ce mot-clé et non via l’utilisation de la classe Marshal il vous faudra écrire :

public struct MyStruct
{
    public int A;
    public int B;
}

class Program
{
    unsafe static void Main(string[] args)
    {
        int s = sizeof (MyStruct);
        Console.WriteLine(s.ToString());
    }
}

Mais bizarrement, si vous souhaitez faire un sizeof du type int, vous n’aurez pas besoin d’utiliser de code unsafe et R# indique même que le mot-clé unsafe devrait être supprimé car redondant :

Mais comment ce contexte peut-il être redondant puisque nous n’avons utilisé le mot clé unsafe qu’une seule fois, et qu’il ne l’était pas dans l’exemple précédent ? La réponse est simple mais si elle n’est pas évidente au premier abord : il n’est plus nécessaire depuis C# 2 de spécifier un contexte unsafe lors de l’utilisation de l’opérateur sizeof sur les types .net prédéfinis.

On peut d’ailleurs voir la différence de comportement du compilateur dans les deux cas évoqués puisque lors de l’utilisation de l’opérateur sizeof sur le type int, le compilo inline directement le résultat :

private static void Main(string[] args)
{
    Console.WriteLine(4.ToString());
}

Tandis que lors de l’utilisation avec un type personnalisé, la valeur ne sera pas inlinée, et le code généré fera appel à l’instruction sizeof présente dans l’Intermediate Language :

private static void Main(string[] args)
{
    Console.WriteLine(sizeof(MyStruct).ToString());
}

Pour plus d’infos :
http://blogs.msdn.com/abhinaba/archive/2006/02/24/538525.aspx

Deux employés de Microsoft viennent de lancer un site proposant aux utilisateurs des outils bureautiques de la gamme Office de donner leurs idées sur les fonctionnalités manquantes ou corrections nécessaires pour améliorer ces logiciels.

L’idée est intéressante, mais n’est pas nouvelle. En effet, les testeurs des différentes versions d’Office (versions pré-beta) disposent déjà d’un outil donnant la possibilité de remonter ses feedbacks grâce à l’outil Send a Smile (ou Frown) :

Cet outil permet d’indiquer les + et les – des différents outils de la gamme Office. Microsoft utilise ces informations au travers d’un portail qui leur donne accès à tous les feedbacks envoyés par les différents testeurs. Vous pouvez en savoir plus sur le process utilisé ici : http://blogs.technet.com/office2010/archive/2009/07/15/tell-us-what-you-think-about-office-2010-technical-preview.aspx

En ce qui concerne cette nouvelle initiative, il est à noter qu’elle permet donc d’ouvrir la possibilité à tout un chacun de donner ses propres retours afin d’aider Microsoft à prioriser les différentes fonctionnalités à implémenter. Cette priorisation est essentielle car elle permet à l’éditeur de sélectionner les tâches à réaliser en fonction du budget et délais alloués au projet.

L’arrivée de ce nouveau site web est donc un plus mais il lui manque à mon sens une donnée essentielle : il n’est pas possible d’indiquer l’importance, la criticité de l’idée soumise. Il est ainsi possible de voter pour n’importe quelle idée (apparemment aucune limitation au niveau du nombre de votes par utilisateur), mais pas de donner un poids pour chaque idée. Il serait préférable de disposer d’un certain nombre de votes (par exemple 10) et de laisser libre choix à l’utilisateur d’allouer le nombre de votes qu’il souhaite à chaque idée. Ainsi sur l’idée “Detach Outlook UI from the network thread(s)” j’aurais pu positionner 8 votes sur les 10 alloués. Le système proposé par le service UserVoice repose d’ailleurs sur ce principe. Vous pouvez le tester via le mécanisme de feedback mis en place pour bDule : http://feedback.sobees.com/pages/17279

Quoiqu’il en soit, ce site permet d’avoir des informations sur l’utilisation des différents outils de la gamme Office. Ainsi Outlook est le logiciel qui a suscité le plus de réaction et quand à Access, il s’agit de celui qui en a suscité le moins avec une seule et unique idée proposée… pour le moment.

En savoir plus :
http://makeofficebetter.com/
http://blogs.technet.com/office2010/archive/2009/07/15/tell-us-what-you-think-about-office-2010-technical-preview.aspx

Sortie de la RTM de Windows 7 pour les abonnés MSDN et Technet. Coté développeurs, le training kit a été mis à jour et le Windows API Code Pack for .net a été finalisé en version 1.0. Scott Hanselman a d’ailleurs fait un excellent post sur les 10 éléments à savoir sur Windows 7.

Novell a ouvert une beta privée de MonoTouch. MonoTouch est une API managée qui permet de développer des applications iPhone. Oui, développer pour iPhone en C# sera bientôt possible et disponible pour tous. Vous pouvez d’ailleurs visionner comment l’ensemble fonctionne grâce à cette vidéo.

Coté évènements, les inscriptions à la PDC09 ont été ouvertes. Cet évènement majeur traitera majoritairement de Windows Azure, Windows 7, Visual Studio 10 et le framework .net 4.0, etc. De nombreuses nouveautés devraient donc être présentées à l’occasion de cette conférence qui aura lieu mi-novembre à Los Angeles.

Du coté de  la presse, Microsoft Press a annoncé que Jeffrey Richter allait sortir une version mise à jour de son ouvrage CLR via C# afin d’étudier les nouveautés proposées par .net 4.0. A noter qu’il devrait être disponible lors de la sortie du framework .net 4.0 et de Visual Studio 2010.

Du coté des posts techniques, je vous recommande l’excellent compte rendu de Romain Verdier (@romainverdier) à propos de la session ALT.net #16. Cette rencontre traitait de l’utilisation du debuggeur windbg afin de résoudre des problèmes de fuite mémoire, de deadlocks et autre freezes. A noter l’annonce d’un projet fort intéressant : LinqToWindbg.

Autre lecture technique intéressante Tout ne dérive pas d’Object d’Eric Lippert.

A la semaine prochaine !

Si vous avez installé la beta 1 de Visual Studio 2010 sur un Windows 7 RC, il est possible que vous ayez deux process msiexec.exe qui tourne en permanence. Le problème est que ces deux process peuvent prendre aléatoirement pas mal de CPU sur votre machine, et surtout empêchent l’exécution de MSI qui vérifient si un autre programme d’installation est en cours d’exécution.

Bien sûr il est inutile d’essayer de killer ces process via le gestionnaire des tâches car ceux-ci ressusciteront très rapidement en causant toujours les mêmes désagréments.

Le problème est que le setup essaie de trouver une ressource dans le dossier C:\Program Files (x86)\Microsoft Visual Studio 9.0\Common7\IDE\PublicAssemblies\en\. Dossier qu’il ne trouve pas.

Afin de résoudre le problème il vous faut donc :

• Créer un dossier nommé “en” dans le dossier C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\PublicAssemblies
• Copier le contenu du dossier PublicAssemblies dans ce dossier en
• A présent quand vous killerer msiexec.exe, il ne reviendra plus dans tâches !

En savoir plus :
Explication du bug et Workaround sur Connect

Comme annoncé hier, je vous propose un webcast décrivant l’hébergement de différentes versions de CLR au sein d’un même process grâce au framework .net 4 et la CLR 4. Le programme est simple : Aucun slide, 1 PostIt édité tout au long de la vidéo, et des démos.

Synthèse de la vidéo :

Vidéo :

Vous pouvez également le télécharger ici  :

N’hésitez pas à me faire vos retours sur ce webcast via les commentaires !

En savoir plus :
http://channel9.msdn.com/shows/Going+Deep/CLR-4-Side-by-Side-In-Process-What-How-Why/
http://blogs.msdn.com/clrteam/archive/2009/06/03/in-process-side-by-side-part1.aspx
http://blogs.msdn.com/clrteam/archive/2009/06/07/in-process-side-by-side-part-2-common-in-proc-sxs-scenarios.aspx

Le site MSDN de Microsoft indispensable à tous les développeurs est par défaut avec une mise en page qui donne beaucoup trop d’importance à des éléments annexes aux articles proposés (arborescence de navigation très large, bandeau rouge trop important, etc.) Du coup la zone de lecture s’en trouve très diminuée :

Sachez qu’il est possible d’avoir une mise en page beaucoup plus lisible et “propre” en sélectionnant l’option “Switch on low bandwith view” présente en haut de chaque page. On se retrouve avec cette mise en page qui est beaucoup plus agréable à la lecture :

Les équipes de Microsoft ont mis à jour début Juillet les outils disponibles afin de développer pour Windows Azure. A noter que ceux-ci sont à présent compatible avec Windows 7, et s’intègrent correctement avec Visual Studio 2010 Beta 1. Voici la liste des éléments indispensables pour se lancer dans le développement d’applications dans le cloud :

• Windows Azure Tools for Microsoft Visual Studio July 2009 CTP

• Windows Azure Software Development Kit (July 2009 CTP)

• Microsoft .NET Services SDK (July 2009 CTP)

• Le training kit n’a pas encore été mis à jour mais reste disponible dans sa version du mois d’avril.

A noter que suite à la suspension de Microsoft .net Workflow Service jusqu’à la finalisation de Worflow Foundation 4.0, les Azure Services Managements Tools auparavant disponible sur Code Gallery, sont pour le moment “dépréciés” et donc non disponibles.

En savoir plus :
http://www.microsoft.com/azure/windowsazurefordevelopers/default.aspx

Bewise s’agrandit puisque après le site de Toulouse dédié à l’expertise sur les technologies de développement Microsoft, après le site Bewise Sud-Est situé à Aix en Provence et Vertice société éditrice du logiciel 3D temps réél Nova,  Vertice Design voit le jour !

Vertice Design est un studio de création graphique spécialisé dans le design d’applications web (HTML, Flash et bien sûr Silverlight) et dans l’ergonomie. En plus de la réalisation d’interfaces, Vertice Design propose tout un ensemble de formations afin de vous accompagner dans votre montée en compétence sur les outils de la gamme Microsoft Expression, Dreamweaver CS4, Flash, Photoshop, Illustrator, etc.

N’hésitez pas à vous rendre sur le site web dédié afin d’avoir plus d’informations : http://verticedesign.com

La news est quasiment passé inaperçue et pourtant elle est d’importance. Les flux RSS ont à présent la possibilité d’être temps réel grâce à PubSubHubbub. PubSubHubbub permet de changer le mode de consommation des feeds RSS d’un mode Pull (le client consomme à intervalles réguliers le feed afin de savoir si de nouveaux éléments ont été publiés) à un mode Push (les clients sont notifiés dès qu’un nouvel élément est publié). Certains moteurs de blog permettent déjà de pinger différents services tels que FeedBurner afin d’indiquer la modification d’un feed. Dans le cas de FeedBurner ce mécanisme de Ping permet de re-générer le feed hébergé par le service instantanément sans attendre la fin du cache de 30 minutes habituellement utilisé. Ce système est déjà très bien mais il permet uniquement d’avertir certains services et non des clients RSS.

Des développeurs de Google sont allés un peu plus loin et proposent un nouveau protocole nommé PubSubHubbub. Ce protocole permet de notifier des clients RSS dès qu’un feed a été modifié. Il est alors possible de rafraichir automatiquement l’interface afin de proposer à l’utilisateur les billets qui viennent d’être publiés.

Les readers web vont d’ici peu implémenter PubSubHubbub afin de fournir cette expérience temps-réel. Un prototype de Google Reader a déjà été développé, et FriendFeed implémente déjà cette fonctionnalité. Je vous invite à regarder cette vidéo afin de bien comprendre le potentiel de ce protocole.

Pour les détails techniques d’implémentation, les slides suivants expliquent de manière détaillée comment fonctionne le protocole ainsi que les différents éléments à mettre en œuvre afin de faire fonctionner l’ensemble.

La bonne nouvelle est que FeedBurner permet d’ores et déjà de rendre vos feeds compatibles avec cette nouvelle technologie. Il vous suffit d’aller dans les paramètres de votre feed et d’activer le service PingShot afin de bénéficier du protocole.

A noter que cette technologie n’est pas propriétaire à Google, elle est proposée en open source sur Google Code.

Voilà une excellente nouvelle qui va permettre aux flux RSS d’avoir le même niveau de réactivité que les tweets publiés via le service Twitter.

En savoir plus :
http://code.google.com/p/pubsubhubbub/
http://adsenseforfeeds.blogspot.com/2009/07/whats-all-hubbub-about-pubsubhubbub.html