Pourquoi les entreprises boudent-elles le parallélisme ?

Du côté des entreprises, la crise actuelle n'est pas forcément propice pour tenir compte de cette évolution matérielle. Nous venons d'un univers où les Hertz nous apportaient régulièrement un surplus de puissance et le récent passage à des matériels multi-cœurs pour tous les postes de travail, passe relativement inaperçu auprès des DSI. Pour les entreprises, les développeurs doivent avant tout se concentrer sur leur métier en conjuguant technique et fonctionnel et non sur des problèmes de programmation parallèle qui sont incompatibles avec leurs attentes. En effet, les problèmes de multithreading sont chronophages et risqués. Comment être certain que les tests seront fiables alors que le multithreading est par nature indéterminisme ? Comment s'assurer que la qualité du produit final est conforme aux attentes de toutes les plateformes d'exécution que le produit rencontrera au cours de son existence ?

Pour toutes ces raisons, les entreprises, en général, ne sont pas encore prêtes pour que les équipes de développement tirent parti des nombreux cœurs qui équiperont leurs prochains achats. Quelques rares cas, où traditionnellement les besoins fonctionnels réclament des performances élevées (moteurs de recherche, éditeurs de bases de données, site web d'une audience mondiale, Imagerie médicale ...), font exception car ils disposent déjà d’experts sur le sujet.

Notons que la société Evans Data, cabinet d'analyse, rapporte, dans une étude sur les habitudes des développeurs mondiaux, que sur les six derniers mois de 2008, seulement 3 % des développeurs auraient introduit dans leur code des instructions capables de gérer le parallélisme des multi-cœurs.

Les entreprises se tourneront vers le parallélisme lorsque le marché sera mature

Le passage à la programmation parallèle pour l'essentiel des entreprises sera sans doute long et couteux. La mise à niveau des développeurs applicatifs est essentielle mais elle ne se fera que lorsque les offres de programmation permettront de développer du code parallèle sans être un expert du sujet. Les offres actuelles sont à la fois trop rugueuses et trop compliquées pour qu'un développeur applicatif puisse en tirer parti facilement. Enfin, même en disposant de nouvelles offres de programmation moins élitistes, le besoin de formation sera sans doute nécessaire. D'un côté, les universités et les écoles devront augmenter la part des cours consacrés à la programmation parallèle. D'un autre côté, les établissements de formation devront ajouter à leur catalogue des formations permettant de développer en parallèle efficacement. L'objectif sera de permettre à une large audience de développeurs d’acquérir des connaissances suffisantes pour produire du code parallèle de bonne qualité sans être un expert du sujet.

Il est parfaitement imaginable que de nombreuses entreprises décident de se lancer dans des projets de migration pour adapter leurs codes séquentiels au monde parallèle. Lorsque ce moment viendra, les offres logicielles permettant de développer plus facilement du code parallèle devront être disponibles pour une large population de développeurs. Ces prochaines offres devront non seulement proposer de nouveaux modèles de programmation, mais aussi de nouveaux outils afin de faciliter la mise au point, les tests, le profilage des codes parallèles. Naturellement, ces prochains outils devront être accessibles au plus grand nombre de développeurs. C'est donc un énorme challenge que doivent résoudre les éditeurs de logiciels de développement.

Pourquoi les entreprises boudent-elles le parallélisme ?

Du côté des entreprises, la crise actuelle n'est pas forcément propice pour tenir compte de cette évolution matérielle. Nous venons d'un univers où les Hertz nous apportaient régulièrement un surplus de puissance et le récent passage à des matériels multi-cœurs pour tous les postes de travail, passe relativement inaperçu auprès des DSI. Pour les entreprises, les développeurs doivent avant tout se concentrer sur leur métier en conjuguant technique et fonctionnel et non sur des problèmes de programmation parallèle qui sont incompatibles avec leurs attentes. En effet, les problèmes de multithreading sont chronophages et risqués. Comment être certain que les tests seront fiables alors que le multithreading est par nature indéterminisme ? Comment s'assurer que la qualité du produit final est conforme aux attentes de toutes les plateformes d'exécution que le produit rencontrera au cours de son existence ?

Pour toutes ces raisons, les entreprises, en général, ne sont pas encore prêtes pour que les équipes de développement tirent parti des nombreux cœurs qui équiperont leurs prochains achats. Quelques rares cas, où traditionnellement les besoins fonctionnels réclament des performances élevées (moteurs de recherche, éditeurs de bases de données, site web d'une audience mondiale, Imagerie médicale ...), font exception car ils disposent déjà d’experts sur le sujet.

Notons que la société Evans Data, cabinet d'analyse, rapporte, dans une étude sur les habitudes des développeurs mondiaux, que sur les six derniers mois de 2008, seulement 3 % des développeurs auraient introduit dans leur code des instructions capables de gérer le parallélisme des multi-cœurs.

Les entreprises se tourneront vers le parallélisme lorsque le marché sera mature

Le passage à la programmation parallèle pour l'essentiel des entreprises sera sans doute long et couteux. La mise à niveau des développeurs applicatifs est essentielle mais elle ne se fera que lorsque les offres de programmation permettront de développer du code parallèle sans être un expert du sujet. Les offres actuelles sont à la fois trop rugueuses et trop compliquées pour qu'un développeur applicatif puisse en tirer parti facilement. Enfin, même en disposant de nouvelles offres de programmation moins élitistes, le besoin de formation sera sans doute nécessaire. D'un côté, les universités et les écoles devront augmenter la part des cours consacrés à la programmation parallèle. D'un autre côté, les établissements de formation devront ajouter à leur catalogue des formations permettant de développer en parallèle efficacement. L'objectif sera de permettre à une large audience de développeurs d’acquérir des connaissances suffisantes pour produire du code parallèle de bonne qualité sans être un expert du sujet.

Il est parfaitement imaginable que de nombreuses entreprises décident de se lancer dans des projets de migration pour adapter leurs codes séquentiels au monde parallèle. Lorsque ce moment viendra, les offres logicielles permettant de développer plus facilement du code parallèle devront être disponibles pour une large population de développeurs. Ces prochaines offres devront non seulement proposer de nouveaux modèles de programmation, mais aussi de nouveaux outils afin de faciliter la mise au point, les tests, le profilage des codes parallèles. Naturellement, ces prochains outils devront être accessibles au plus grand nombre de développeurs. C'est donc un énorme challenge que doivent résoudre les éditeurs de logiciels de développement.

Estoy escribiendo un intérprete no tipado con sintaxis tipo C#, que bauticé AjSharp. Hace un tiempo escribí sobre este proyecto de código abierto en:

AjSharp Programming Language a C#-like Dynamic Language
AjSharp: un lenguaje dinámico en C#

Pueden bajarse la versión actual desde http://code.google.com/p/ajcodekatas en trunk/AjLanguage (AjLanguage define el árbol de ejecución del intérprete, AjSharp tiene un parser, un lenguaje definido para construir ese árbol; la idea es colocar otros parsers sobre AjLanguage, por ejemplo, AjBasic).

Ayer sábado, agregué una nueva característica, la definición de un objecto. Ya de antes, AjSharp soporta la definición de una clase dinámica:

class Person
{
  var Name;
  var Age;
  
  function AddYears(years) 
  {
    this.Age = this.Age + years;
  }
}

Pueden crear un objecto usando:

adam = new Person();
adam.AddYears(800);
adam.Name = "Adam";

El objeto creado es dinámico: se le pueden agregar variables de instancias y métodos, en cualquier momento:

adam.LastName = "unknown";
adam.EyeColor = "brown";
adam.SayHello = function() { PrintLine("Hello"); };

Pueden crear objetos, con esta notación, inicializando su estado:

adam = new Person() { FirstName = “Adam”, LastName = “Genesis”, Age = 800 };

Y hasta pueden definir un objeto sin tener una clase asociada:

dynobj = new { Name = “Adam”, Age = 800 };

Esto es equivalente a hacerlo más “programáticamente” así:

dynobj = new DynamicObject();
dynobj.FirstName = “Adam”;
dynobj.LastName = "Genesis”;
dynobj.Age = 800;
dynobj.FullName = function() { return FirstName + “ “ + LastName; }

Esto estaba implementado desde hace meses. Ayer agregué la notación:

object Adam
{
  var Name = "Adam";
  var Age = 700;
  
  function AddYears(years) 
  {
    this.Age = this.Age + years;
  }
}
Adam.AddYears(100);

donde se puede definir un objecto único, dándole estructura, conducta y nombre.

La idea de AjLanguage es que pueda acceder a todas las clases y objetos del framework subyacente (en este caso, .NET, pero está pensado para ser reescribible sobre Java, si fuera necesario, claro, cambiando cualquier referencia a tipos nativos):

ds = new System.Data.DataSet();
dinfo = new System.IO.DirectoryInfo(“.”);
foreach (fi in dinfo.GetFiles())
{
    PrintLine(fi.FullName);
}

Desde ayer, seguí implementando constructores. Tengo pensado definir visibilidades privadas y públicas (por ejemplo, las variables y métodos de instancia que comiencen con minúscula, hacerlas automáticamente privadas). También agregar propotipos, como en Javascript, lo que permitiría implementar cosas similares a los métodos de extensión de .NET.

Pero si van hoy al trunk, encontrarán que estuve implementando canales, como en en lenguaje Go de Google.

channel = new Channel();
go for (k=1; k<=5; k++) channel <- k;
for (j=1; j<=5; j++)
	result = result + <-channel;

Pero eso dará para otro post más detallado. Con esa característica quiero explorar temas como programación reactiva, agentes, actores, shared transactional memory, ver:

http://clojure.org/Agents

http://en.wikipedia.org/wiki/Actor_model

http://en.wikipedia.org/wiki/Axum_%28programming_language%29

Por ejemplo, sería interesante que los canales comunicaran no sólo dos códigos en paralelos, sino máquinas diferentes. Y definir esas máquinas en tiempo de deployment, sin cambiar el código del programa. Podría reescribir los ejemplos de Distributed Agents using DSS/VPL o  Genetic Algorithms with AjAgents and Concurrency and Coordination Runtime (CCR)

Como verán, me estoy divirtiendo!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Pourquoi peu de développeurs connaissent  la programmation parallèle ?

Pour les développeurs, la prise en compte effective de ce changement technologique peut se révéler très compliquée. Rappelons qu'il y a déjà une petite vingtaine d’années que les techniques de multithreading se sont intégrées dans un écosystème fortement séquentiel.

Néanmoins, les détracteurs du parallélisme peuvent trouver de nombreuses raisons pour ne pas s'adapter à cette nouvelle donne. La culture séquentielle à l’origine de l’informatique peut être considérée comme la plus légitime. Nous sommes aussi certains que le cerveau humain éprouve des difficultés à raisonner en multitâches ce qui peut être vu comme un frein pour le passage en mode parallèle.

Aujourd’hui, nous pouvons reconnaitre que les environnements de programmation comme les outils, les librairies, offrent peu d’adhérence avec ces concepts. Alors, comment s’assurer que la mise en parallèle de certaines parties du système est à la fois fiable et pertinente vis-à-vis du langage de programmation et de l’infrastructure matérielle ? Définir avec certitude que les notions d’isolation, d’immuabilité ou de synchronisation sont correctement exprimées vis-à-vis du problème posé au regard des environnements, des langages, des outils, sont des préoccupations essentielles que nous abordons difficilement, faute d’un outillage adapté.

Dans le cas des langages C et C++ où l’héritage d’une culture séquentielle se comprend facilement (Le langage C est issu d’une philosophie très système inspirée par la plateforme UNIX AT&T originelle où la notion de multithreads n’existait pas) mais dont l’adaptation au multithreading est  venue se superposer à un existant séquentiel donnant lieu à un jeu d’APIs rudimentaires difficilement compréhensibles pour le développeur non système. Initialement, la notion de thread à été introduite pour offrir aux développeurs un moyen de paralléliser du code sans avoir à créer plusieurs processus systèmes (très couteux sur le plan des ressources du système d'exploitation). On constate avec le recul que de nombreux environnements se sont inspirés des interfaces vétustes originelles, plaçant le multithreading au rang des technologies réservées aux experts.

Les principaux écueils de la programmation parallèle ?

Après 20 ans de multithreading, nous pouvons reconnaitre que les modèles parallèles sont à la fois peu répandus, peu connus, et difficiles à implémenter. Pour un novice en développement parallèle, Il est très facile de provoquer de nombreux problèmes potentiels sans forcément les constater. En effet, l'exécution parallèle ne nous offre pas de certitude sur l'ordre d'exécution des instructions associées aux threads courants : le principe d'incertitude énoncé par Heisenberg défini en physique quantique à été renommé Heisenbug pour qualifier ce principe en informatique . En d'autres mots, toute ressource partagée par plusieurs threads doit faire l'objet d'une protection, sinon gare aux incohérences des résultats. Pour illustrer la dimension des difficultés rencontrées, nous pouvons citer les erreurs les plus courantes en programmation parallèle :

Race condition

Le code C# ci-dessous, pourtant très simple est tout de même faux dans le cas où la propriété Status est plongée dans plusieurs threads parallèles.

Si de nombreux threads appellent simultanément cette propriété, l'exécution se déroulera souvent correctement mais parfois l'incrémentation sera fausse lorsque les threads se chevaucheront sur l'instruction d'incrémentation. De nombreux développeurs imaginent que l'operateur d'incrémentation est atomique alors qu'il n’en est rien comme le montre le code assembleur.

Pour corriger notre code il nous suffit de remplacer notre opérateur d'incrémentation par une méthode InterLocked.Increment(ref _status) qui nous assure une exécution atomique.

 Cependant, les ressources à protéger ne sont pas toujours des entiers, mais sont souvent des types complexes. Dans ce cas, nous ferons appel à un outillage de synchronisation plus polyvalent. En contrepartie, ces outils peuvent occasionner de nombreux problèmes qui aboutissent parfois à des codes parallèles plus lents que leurs équivalents séquentiels. Voici d'autres exemples souvent rencontrés dans le cadre la programmation parallèle.

Deadlock

 Parfois nommé étreinte fatale, le deadlock est provoqué par des threads mutuellement verrouillés. Cette situation peut être comparée à deux personnes dessinant des diagrammes tout en se partageant un crayon et une règle. Si une personne prend le crayon et l'autre prend la règle, un blocage se produit lorsque la personne avec le crayon a besoin de la règle pour terminer son travail alors que la personne avec la règle a besoin du crayon pour terminer son travail à son tour. Les deux demandes ne peuvent être satisfaites, un blocage se produit.

Pour de nombreux développeurs l'ouvrage sur les Design Patterns du fameux Gang of Four est sans aucun doute un ouvrage de référence pour tous les développeurs. Avez-vous déjà tenté de passer en parallèle un des patterns du GoF ? Par exemple l'Observer. Lors d'une présentation chez Microsoft Research, Edward A. Lee, chercheur et professeur en informatique à l'université UC Berkeley, a montré que l'utilisation de mutexs peut rapidement aboutir à des étreintes fatales potentielles. Voici le fragment Java illustrant ce problème.

En protégeant les méthodes addListener et setValue à l'aide du mot clef synchronized on pourrait croire que le code ci-dessous supporte une utilisation partagée par plusieurs threads. Mais supposons que la méthode valueChanged () cherche à obtenir un verrou sur un autre objet. Si le titulaire de ce verrou appelle la méthode addListener (), alors nous tombons dans le cas d'une étreinte fatale ! Cet exemple illustre une recommandation en programmation parallèle : conservez des sections synchronisées les plus courtes possibles.

Livelock

Le livelock provoque une situation de famine entre des threads qui se disputent des ressources partagées limitées souvent illustré par le fameux Dîner des philosophes.

La situation est la suivante : cinq philosophes se trouvent autour d'une table. Chacun des philosophes a devant lui un plat de spaghetti et à gauche de chaque assiette se trouve une baguette. Un philosophe n'a que trois états possibles :

·         Penser pendant un temps indéterminé

·         Etre affamé (pendant un temps déterminé et fini sinon il y a famine)

·         Manger pendant un temps déterminé et fini

Lorsqu'un philosophe a faim, il va se mettre dans l'état affamé et attendre que les baguettes soient libres pour manger. Un philosophe a besoin de deux baguettes : celle qui se trouve à gauche de sa propre assiette et celle qui se trouve à gauche de celle de son voisin de droite (c'est-à-dire les deux baguettes qui entourent sa propre assiette). Si un philosophe n'arrive pas à s'emparer d'une baguette, il reste affamé pendant un temps déterminé, en attendant de renouveler sa tentative. Le problème consiste à trouver un ordonnancement des philosophes tel qu'ils puissent tous manger, chacun à leur tour.  Une solution à base de sémaphores énoncée par Dijkstra est souvent utilisée en programmation parallèle.

Pourquoi les codes parallèles sont-ils difficile  à maintenir ?

Un autre point regrettable avec l'usage des technologies actuelles est la complexité d'écriture pour implémenter du code parallèle. Pour illustrer ce point, prenons deux exemples. Le premier implémente une méthode naïve en C++0x dédiée à la multiplication de matrices.

Le second exemple implémente cette fois en C# une méthode dédiée à la recherche multicritères dans une liste mémoire de bébés.

Adaptons  ces codes afin d’exploiter les technologies parallèles actuelles.

En premier le code C++.

En second le code C#.

Sans être un expert du multithreading, vous conviendrez que ces nouvelles versions sont bien plus compliquées et regorgent de défauts importants : le partitionnement statique du traitement sans adhérence avec le nombre de CPU présents sur la machine courante, un mécanisme de synchronisation trop intrusif et très coûteux sur le plan des ressources (surcharge CPU provoquée par des passages fréquents du mode utilisateur au mode noyau), un usage direct de l’entité thread couplée au système d’exploitation entraînant des coûts substantiels pour le système d’exploitation (1 Mo de mémoire par thread).  On note que le Framework .NET n'échappe pas à l’héritage de la culture séquentielle, mais son incarnation est relativement moins rugueuse qu'en langage C++. Par nature, le code géré est plus simple à appréhender, cependant il reste compliqué lorsqu'on parle de parallélisme.

Hi all!

My name is Giovanni Dicanio, and I'm a Microsoft Visual C++ MVP.

(I received my first VC++ MVP Award on July 1st, 2007.)

The odds are good that I'll be writing about C++ and Windows programming (and maybe something more) on this blog.

Thanks,
Giovanni

I found that out personally when buying APC 1500 UPS's that look like this -- and found out the hard way that it would not keep the server up.  So then we purchased the SMART-UPS, also rated 1500 and that model would keep the server up.  

Mind you the normal 1500's were good enough to keep the old server up, but I had to get the SMART-UPS to support the new server.

So keep in mind all UPS's are not alike and spec accordingly.

Pourquoi les ordinateurs grand public sont-ils multi-cœurs ?

En 1965, Gordon Moore (co-fondateur d’Intel) observait que le nombre de transistors contenus dans un semi-conducteur disponible sur le marché, doublait tous les 18 à 24 mois. C'est de ce constat empirique qu'est née la loi de Moore. En d’autres mots les capacités techniques des ordinateurs s’amélioraient régulièrement, permettant aux programmes informatiques d'en tirer parti sur le plan de la rapidité d’exécution sans grandes modifications (souvent aucune). Ce constat a fait le bonheur de plusieurs générations d'informaticiens, au point que certains appelaient ce phénomène le « free lunch ». A cette époque, les fondeurs basaient le plus gros de leur discours marketting sur une course au GigaHertz, chacun de se ventant d’aller plus vite que l’autre

Depuis quelques temps, vous avez sans doute remarqué l'apparition de processeurs multi-cœurs allant de deux à quatre cœurs dans les offres constructeurs grand public. Cependant vos applications ne tournent sans doute pas plus vite sur ce type de matériel. En effet les systèmes d'exploitation, les applications d'aujourd'hui ne sont pas adaptés pour tirer parti efficacement d'une architecture multi-cœurs. En d'autres mots, cette évolution matérielle n'est pas forcément vécue comme un gain important par les utilisateurs.

Pourquoi les fondeurs ont-ils changé de paradigme ?

Depuis quelques années les constructeurs ont été confrontés à des contraintes physiques fortes (chaleur & consommation) qui ne permettaient plus d'améliorer leurs offres en restant sur les mêmes bases techniques. Par exemple, Intel avait prédit dès 2006 que la température de ses puces reposant sur la microarchitecture Netburst (Pentium IV) atteindrait environ 6000 degrés en 2015, soit environ la température à la surface du soleil. Ne pouvant plus croitre sur le plan des Hertz, les constructeurs ont choisi de répartir la puissance sur plusieurs cœurs au sein d'un même processeur (architecture multi-cœurs). La course aux Hertz est donc terminée, place à la course au nombre de cœurs ! Dès aujourd'hui, les constructeurs de microprocesseurs disposent de nouvelles plateformes sachant grandir facilement en nombre de cœurs tout en améliorant les performances de l'infrastructure interne du processeur lui-même. Le tout dernier processeur Intel Core i7 (Nehalem) rencontre déjà un franc succès auprès de constructeurs d'ordinateurs. Les ordinateurs de demain seront donc massivement multi-cœurs (supérieur à 8 cœurs), les américains parlent du passage du Multi-core au Many-core, ce qui peut sembler une bonne nouvelle.

Les systèmes d'exploitation sont déjà en cours d'adaptation

De leur côté, les éditeurs de systèmes d'exploitation sont conscients que leurs produits ne sont plus adaptés pour exploiter correctement ces nouvelles architectures matérielles.

Windows 7 en 64bit est pleinement capable de gérer 256 cœurs

Les systèmes Windows 7 en 64bit et Windows Server 2008 R2 profitent de ces nouvelles offres qui aujourd'hui peuvent sembler exagérées au regard des besoins actuels, mais n'oublions pas que le monde change et que les progrès techniques ont toujours été porteurs d'innovations qui aujourd'hui nous apparaissent normales. A titre d’exemple, dans sa version 64 bits, les systèmes Windows 7 x64 et Windows Server R2 2008 sont capables de gérer pleinement 256 cœurs. Nous comprenons mieux avec cet exemple la nouvelle appellation Many-core pour qualifier des matériels regorgeant de cœurs.

The free lunch is over

Dès 2005, Herb Sutter, célèbre architecte C++ de chez Microsoft, annonçait "The free lunch is over". En d'autres mots les gains de performances de vos applications constatés sur les nouveaux matériels sont terminés. C'est donc aux développeurs de réviser leurs codes pour retrouver de la puissance. Dans ce contexte, pouvons-nous affirmer que le « free lunch » est définitivement révolu ? Pour enrayer cette catastrophe, devons-nous engager une révision radicale dans nos pratiques de développement ?

                Depuis la conférence PDC08, je m'intéresse particulièrement à l'offre Parallèle de Visual Studio 2010. Afin d'évaluer les versions intermédiaires de Visual Studio 2010 (je vous encourage à télécharger la beta2 en attendant une RC en février), je exécuterai mes expérimentations sur un portable Dell Precision M4400 incorporant un processeur Intel Core 2 Extreme Quad Core QX9300 (la gamme "Extreme" réintroduit la capacité d'overclocker le processeur). Le constat est sans appel, le matériel informatique se tourne définitivement vers des architectures multi-cœurs de plus en plus sophistiquées.

                Aujourd'hui toutes les machines disposent de plusieurs cœurs, même les derniers notebooks. Il est donc urgent de prendre en compte cette nouvelle donne afin d'en tirer partie. L'objectif de ce blog est de vous aider à programmer parallèle en abordant à la fois la modélisation et l'implémentation d'applications parallèles.

                J'espère que ce blog vous apportera suffisamment d'aide pour comprendre et développer des applications parallèles efficaces afin de retrouver le fameux "Free Lunch".

Security challenges will continue in 2010. This edition of Red Tape from MSNBC's Technical division summarizes their predictions for a stormy year ahead.

MSNBC - 12 things computer users should fear in 2010
http://redtape.msnbc.com/2009/12/about-once-a-year-computer-security-news-leaps-out-of-the-technology-section-and-onto-the-front-page-and-the-top-of-network.html

QUOTE: Predictions for 2010 are summarized below:

1. E-mail attachments are back - Trojan horse attacks continue to increase
2. Anti-virus products less effective - AV Vendors have difficulty keeping up with bad guys
3. Fake anti-virus software - In 2009 consumers shelled out $150 million for rogue softare
4. Social networking attacks will continue to increase
5. Botnets - may be even worse
6. Spam - 95 percent? 
7. Finally, Apple gets respect - from cybercriminals
8. Cell phones-  may see a significant attack against cell phone or smart phone users.
9. SEO poisoning - malicious sites manipulae search engines to rank high
10. WINDOWS 7 - Microsoft has continued to improve security and will malicious attackers be successful?
11. URL shorteners - may take users to malicious web sites
12. Gumblar - advanced website injection to build botnet.

For users getting their first home PCs, these tips are shared in an easy to understand approach.  The keys are to ensure the Windows Security Center is "all green", being up-to-date on Windows updates, and best surfing practices.

Kim Komando - Safety Tips before going online with new PC
http://www.komando.com/tips/index.aspx?id=7762

QUOTE: QUESTION: I'm getting a new laptop. Could you give me a few tips before I connect to the Internet? I've heard you say how quickly you can get infected. Any help would be greatly appreciated. I listen to you every Saturday. —Dave in Wichita, KS, listening on KFH 98.7 FM

ANSWER That's a great question, Dave. Lots of people are getting computers for Christmas. You don't want to start out by being attacked. If you hit the Internet, your new computer could be compromised in minutes. The big problem is drive-by attacks. They take advantage of unrepaired holes in Windows.

These days, nearly any site could contain attack software. Most sites have flaws, which are openings for criminals. They post their malicious programs there. If you go to the site, it will try to download to you. A patched copy of Windows would be OK. Unpatched copies are at great risk. Stay away from e-mail, too. Heaven knows what's in the spam attachments. You probably know better than to open attachments. But we all make mistakes. Better to avoid temptation.

Windows includes many robust services that start automatically when the system boots up.  While most of automatically started services are needed, I recently discovered one more having to do with special inputs or additional languages that can be safely disabled. 

Advanced users may tweak their systems to diable unnecessary services at startup. Performance improves when unneeded services aren't starting improving bootup times.  This service supports alternative inputs and languages starts and if it's not needed, it can be toggled off (and reset in future if needed). 

With tools like msconfig, MS SysInternals, or ccleaner, technicians can detect all startup processes and disable unnecessary ones.  In each case, it's important to research the service (web search) and the safety in discontinuing it.  As many users don't need alternative inputs or languages, this service can be safely disabled following advice below:

CTFMON.EXE - Extended Language Support safely disabled on Windows startup
http://en.kioskea.net/faq/sujet-1780-disable-ctfmon-exe-at-startup

QUOTE: The ctfmon.exe is a Windows generic process for managing entries alternative text input software such as voice recognition, electronic recognition, braille keyboards, or any alternative to the keyboard. The ctfmon.exe process is useful only for taking different languages, or if one of the features mentioned above is used. Otherwise, this process is not necessary.

Ctfmon.exe file is responsible for monitoring technology "Modes User Input". It starts the component of the "Language Bar" (via the system tray), and starts every time Windows start, continuing to run in the background, whether an Office XP program was started or not.

I attended and presented at the first SDC conference in Gothenburg in March this year. It was a well-arranged one-day conference with lots of good speakers (Kent Beck did the keynote, just to mention one). Next year the conference is back and this time for two full days.

I’ve got the opportunity to talk at this conference as well:

and this is what I plan to cover:

Testing, testing. A first-look at the new testing capabilities in Visual Studio 2010

The new release of Visual Studio Team System will include a large set of powerful testing features. Whether you're into manual or automated testing there will be things you want to check out!

We'll look at the many of the exiting new features in VSTS 2010, including:

• Test planning and execution
• Issue tracking with rich bugs
• Eliminating the "works on my machine / cannot reproduce" scenario
• Automated UI Testing
• Virtual Lab Management

Visit http://www.scandevconf.se/ for all the details about the conference and make sure to sign up early!

Hola comunidad,

El siguiente post es acerca de algo que recientemente me sucedió en mi proyecto actual, el cual está basado en Microsoft CCF 2009, WPF, WCF y algo de automatización. Entre uno de los requerimientos estaban, el no permitir que ninguna otra ventana se pudiera colocar sobre la ventana de nuestra aplicación además que ésta debe anclarse al tope superior de la pantalla, evitando así que pueda moverse a otra parte.

Pues bien, me dije puedo colocar el código en el procedimiento de ventana y procesar el mensaje WM_WINDOWPOSCHANGED  para así obligar a nuestra ventana que no pueda moverse, pero el único inconveniente era que la ventana principal de nuestra aplicación es de tipo Window y no expone ningún WndProc sin mencionar que no podíamos cambiar la implementación a estas alturas por HwndSource que si expone el procedimiento de ventana e inclusive el hWnd de la ventana, entonces, ¿ahora qué podía hacer?

La solución fue implementar un gancho (hook) que aplica solo a nuestra aplicación y procesamos el evento EVENT_OBJECT_LOCATIONCHANGE (0x800B). El código es similar al mostrado a continuación

   1: public delegate void HookCallback(IntPtr hWinEventHook, uint Event, IntPtr hWnd, int idObject,

   2:                                   int idChild, uint dwEventThread, uint dwmsEventTime);

   3:  

   4: private void SetUpHook() {

   5:            IntPtr positionHook = IntPtr.Zero; 

   6:            int processId = Process.GetCurrentProcess().Id;

   7:            GCHandle? positionHandler = GCHandle.Alloc(new WindowUtility.HookCallback(HookHandler));

   8:  

   9:            // Set up hook to determine when our application is covered by another window

  10:                if ((positionHook = WindowUtility.SetWinEventHook(WindowUtility.EVENT_OBJECT_LOCATIONCHANGE,

  11:                        WindowUtility.EVENT_OBJECT_LOCATIONCHANGE, IntPtr.Zero, (WindowUtility.HookCallback)positionHandler.Value.Target,

  12:                        processId, WindowUtility.ZERO, WindowUtility.WINEVENT_OUTOFCONTEXT)) != IntPtr.Zero) {

  13:                        _currentHooks.Add(Guid.NewGuid(), new HookDetails() {

  14:                                        EventValue = WindowUtility.WINEVENT_OUTOFCONTEXT, HookHandle = positionHook,

  15:                                        ManagedHandler = positionHandler, MaxEvent = WindowUtility.EVENT_OBJECT_LOCATIONCHANGE,

  16:                                        MinEvent = WindowUtility.EVENT_OBJECT_LOCATIONCHANGE, ProcessId = processId,

  17:                                        ThreadId = WindowUtility.ZERO

  18:                                });

  19:                        }

  20:                }

  21:  

  22:  

  23: private void HookHandler(IntPtr hWinEventHook, uint Event, IntPtr hWnd, int idObject,

  24:                          int idChild, uint dwEventThread, uint dwmsEventTime) {

  25:   int titleBarLength = 0;

  26:   StringBuilder windowText = null;

  27:   IntPtr foregroundHwnd = IntPtr.Zero;

  28:  

  29:    // Location change | event 32779 (EVENT_OBJECT_LOCATIONCHANGE = 0x800B) occurs then 

  30:    //                   force docking the window to the top

  31:    

  32:    if (Event == WindowUtility.EVENT_OBJECT_LOCATIONCHANGE) {

  33:           if ((foregroundHwnd = WindowUtility.GetForegroundWindow()) != IntPtr.Zero) {

  34:                titleBarLength = WindowUtility.GetWindowTextLength(foregroundHwnd);

  35:                windowText = new StringBuilder(titleBarLength + 1);

  36:  

  37:           if (WindowUtility.GetWindowText(foregroundHwnd, windowText, windowText.Capacity) > WindowUtility.ZERO &&

  38:               windowText.ToString().ToLower().Equals(WindowUtility.OFFICE_CLASS)) {

  39:                    WindowUtility.CloseWindow(foregroundHwnd);

  40:           }

  41:  

  42:          // Let's set a new style to the window (Hide Icon in Task Switcher)  

  43:          if (!_newStyleSet) {

  44:                 WindowStyle = WindowStyle.ToolWindow; // Same as WS_EX_TOOLWINDOW

  45:                 _newStyleSet = true;

  46:          }

  47:  

  48:         // let's re-dock our application bar

  49:         applicationBar = new ApplicationBar(this);

  50:         applicationBar.RegisterBar(true);

  51:          } 

  52:       }

  53:    }

  54:  

  55:  

  56:  protected override void OnClosing(System.ComponentModel.CancelEventArgs e) {

  57:    if (!appLoaded)

  58:          e.Cancel = true;

  59:    else {

  60:      // Cleaning up hook related stuff

  61:      _currentHooks.ToList().ForEach(hook => {

  62:                    WindowUtility.UnhookWinEvent(hook.Value.HookHandle);

  63:                    hook.Value.ManagedHandler.Value.Free();

  64:          });

  65:       }

  66:   }

  67:  

La única aplicación que podía causar problemas era la barra de office, por lo que si esta es colocada sobre nuestra ventana, entonces procedemos a minimizarla. También era requerido que el icono de la aplicación no fuese mostrado en la ventana las tareas, para esto podíamos cambiar los estilos extendidos de la ventana a través de la función SetWindowLong en conjunto con el estilo WS_EX_TOOLWINDOW, sin embargo con WPF es tan sencillo como

   1: WindowStyle = WindowStyle.ToolWindow; 

Como mencione al principio, la clase Window no expone el hWnd de la ventana, pero si deseamos obtener este lo podemos hacer de la siguiente manera

   1: private void Form_Loaded(object sender, RoutedEventArgs e) {

   2:    IntPtr hWnd =  Process.GetCurrentProcess().MainWindowHandle;

   3: }

Aunque la solución del gancho funciona sin inconvenientes, estaba aún con la curiosidad de hácerlo a través del procedimiento de ventana, mi idea era la siguiente:

• Tener un método que hiciera las veces de procedimiento de ventana
• Obtener la dirección de dicho método
• Cambiar el procedimiento de ventana y utilizar mi método

Para ello creé una solución basada en WPF, cambié las propiedades del proyecto para permitir código inseguro (unsafe). En C/C++ puedo obtener la dirección de memoria de una función a través del operador de dirección (referencia)

   1: typedef float (*FUNCPTR) (float,float);

   2:  

   3: float Add(float a, float b);

   4:  

   5: int main() {

   6:    FUNCPTR ptr = &Add;

   7:    float result = ptr(5, 5); 

   8:    return 0;

   9: }

  10:  

  11: float Add(float a, float b) {

  12:   return a + b;

  13: }

pero lamentándolo mucho en .NET eso no es posible, porque incurriríamos en un error CS0211 y en caso de querer obtener la dirección en memoria de un tipo administrado obtendríamos un error CS0208, pero en ambos casos no es “completamente cierto” y se puede ver en la siguiente imagen

Desde la ventana de “Inspecciones” puedo obtener el puntero y la dirección del método, pero ¿por qué entonces la siguiente línea en mi código fuente no me deja compilar?  El misterioso mundo de VS .NET

Así mismo, es posible obtener la dirección de un tipo gestionado de la siguiente manera

   1: GCHandle pinnedCallBack = GCHandle.Alloc(new WndProcCallback[] {WndProc});

   2:  

   3: GCHandle pinnedArray = GCHandle.Alloc(pinnedCallBack , GCHandleType.Pinned);

   4:  

   5: // Get address of pinned array

   6: IntPtr pinAddress = pinnedArray.AddrOfPinnedObject(); 

   7:  

   8: // Get address of callback (delegate)

   9: IntPtr callbackAddress = Marshal.UnsafeAddrOfPinnedArrayElement((WndProcCallback[])(((GCHandle)(pinnedArray.Target)).Target), 0);

Retomando la idea principal, mi intención era obtener la dirección del nuevo procedimiento de ventana y a través de la función SetWindowLong apuntar a dicho procedimiento.

   1: Win32Support.SetWindowLong(hWnd, Win32Support.GWL_WNDPROC, wndProcAddress);

Entonces ejecuto mi aplicación, muestro las direcciones en memoria del procedimiento de ventana actual, el arreglo que contiene mi delegado (callback) y el callback en sí tal como es mostrada en la imagen a continuación

Nótese lo siguiente:

• La información sobre el procedimiento de ventana es la misma, es decir, lo que nos muestra Microsoft Spy++ y la aplicación que escribí
• Mi aplicación deriva de la clase Window, pero Spy muestra una clase llamada HwndWrapper (que no está documentada)

La clase HwndWrapper no está documentada por lo que me llama la atención así que decido, ejecutar mi aplicación con CLR Profiler para ver si consigo el procedimiento de ventana así como quién asigna a esté

Procedimiento de Ventana (MS.Win32.NativeMethods.WndProc)

La clase Window depende de HwndWrapper y HwndSource, pero ¿por qué no exponer el WndProc?

Una vez descubierto esto, me propongo a cambiar el procedimiento de ventana para así no utilizar el gancho mencionado al principio del post… Pero no funciona :-|  por lo que ejecuto WinDbg, y me doy cuenta que las direcciones que me regresa el CLR son “inválidas”  ya que después de ejecutar SetWindowLong (que por cierto se ejecuta sin errores, por el valor que retorna y lo que me devuelve GetLastError). A continuación muestro el WndProc de la aplicación

Al establecer el nuevo procedimiento de ventana, recibo una excepción de tipo C0000005 – Violación de Acceso, que se traduce en un montículo que se ha corrompido como es mostrado en la siguiente imagen

Antes de llegar a una conclusión, decido verificar que la dirección regresada por el CLR coincide con la del método que quiero establecer como procedimiento de ventana, para ello ejecuto el comando bm WPFAPP!* desde WinDbg y puedo ver los métodos y su dirección de memoria

Oops… La dirección que tengo no aparece ahí. Lo interesante es que hay una función en el Debugger Engine que me permite enumerar los métodos de un proceso dado. La función GetSymbolEntriesByName.

Al final tuve que dejar la implementación con el gancho que había hecho previamente, si quiero tener control sobre el procedimiento de ventana entonces derivo de HwndSource y me evito de estar “agregando” funcionalidad a la clase Window.

WPF nos permita hacer interfaces de usuario muy ricas y todo lo demás, pero al mismo tiempo las cosas que eran sencillas de hacer con Win32 se hacen engorrosas ó simplemente díficiles de implementar y lo irónico es que aún por debajo de todos los nombres nuevos y marcos de trabajo, lo que se ejecuta es Win32.

Saludos,

Angel

Since it’s Christmas time, I thought you’d like to know there 2 presents waiting for you:

• First Look: Microsoft Office 2010 - For a limited time you can download this free e-book without stepping through any registration. First Look: Microsoft Office 2010, by Katherine Murray, offers 14 chapters of early content.
• Windows PowerShell v.1 TFM - With the recent release of Windows PowerShell v.2 and the immanent publication of our well regarded Windows PowerShell v.2 TFM book by Don Jones and Jeff Hicks, SAPIEN is releasing our Windows PowerShell v.1 TFM eBook as a FREE download to the public. Even though this eBook is for version 1 of PowerShell, the book still contains loads of valuable information about PowerShell’s core workings and cmdlets.

• Exchange Server 2010 Compliance Capabilities
• Upgrade Exchange 2003 to Exchange 2010
• Customizing the Outlook Address Book
• Roadshow follow-up – Part 2: Set-Mailboxautoreplyconfiguration
• Upgrading to Exchange 2007 SP2 and Impersonation
• Exchange Server 2010 RTM and Organizational Health miscalculation
• Forefront Protection 2010 for Exchange Server (FPE) Capacity Planning Guidance v. 2
• What’s new in the Outlook Navigation Pane
• Check Out These Conversations Videos!
• To virtualize Exchange or not to virtualize Exchange?
• U-BTech: Exchange 2010 ROI Tool
• Using PowerShell to sort mailboxes by size
• Using ADSI to find your CAS or Mailbox Role servers in VBS or PowerShell
• Exchange 2010 & synchronization/provisioning using IIFP/ILM/FIM
• Federated Sharing - Points To Note…
• Busting the Exchange Trusted Subsystem Myth
• Fix for Cannot Logon to OWA Using ISA 2004
• OWA Customization in Exchange 2010

Beim vergangenen Treffen der Forefront User Group am 10. Dezember habe ich ein paar organisatorische Änderungen vorgeschlagen, die mir bei der Vorbereitung der Treffen etc. helfen. Wir haben ausführlich darüber diskutiert und die Vorschläge wurden von den anwesenden Teilnehmern einstimmig angenommen.

Gleichzeitig habe ich ûber Änderungen/Neuigkeiten im Microsoft Partner Programm berichtet. Darüber werde ich bald separat bloggen.

Was sind nun die angesprochenen Änderungen bei der User Group?

Obwohl ich immer dagegen war, müssen/sollten wir die User Group etwas formaler gestalten. Da ich auch schon lange den Anmeldeprozess für die Treffen renovieren wollte, legen wir das nun zusammen. Ich möchte aber das Rad nicht neu erfinden und so haben wir uns geeinigt, Xing als Organisationsplattform zu nutzen. Dort kann sowohl eine Mitgliedchaft als auch recht einfach Einladungen verwaltet werden. Ihr müsst künftig nicht mehr über den Anmeldelink im Blog eine E-Mail versenden und auf Rückantwort von mir warten. Über Xing kann ich allen eingetragenen Mitgliedern der Gruppe eine Einladung mit allen Infos senden und ihr braucht dann nur noch ja oder nein anklicken. Ich glaube, das ist eine einfache aber wirksame Lösung.

Gleichzeitig können wir in der Xing-Gruppe ein kleines Diskussionsforum einrichten. Nein, ich plane nicht damit die Newsgroup abzulösen oder innerhalb Xing regelmäßig Supportfragen zu diskutieren. An noch einer Front können wir nicht kämpfen. Bei Xing sollen nur organisatorische Dinge wie Themenvorschläge, Termine, Orte etc besprochen werden.

Wer noch keinen Account bei Xing hat, möge das bitte nachholen. Und für die Totalverweigerer, die an solchen Plattformen nicht teilnehmen môchten - niemand zwingt euch, mehr persönliche Daten anzugeben als Name und E-Mail-Adresse. Das müsstet ihr an jedem anderen System auch. Also sehe ich das Argument nicht, jemand will keine persönlichen Details von sich ins Netz stellen.

Ihr könnt euch hier zu Xing kostenfrei anmelden.

Disclaimer: wenn ihr diesen Link nehmt, bekomme ich für 7 erfolgreiche Anmeldungen einen Premium-Monat im Wert von 5,95€ kostenfrei. Alternativ könnt ihr euch natürlich auch direkt über www.xing.de anmelden.

Die Gruppe steht allen offen, die sich für die Forefront User Group interessieren. Eine Mitgliedschaft beinhaltet keine Verpflichtung (hm, ok, ausser Einladungsmails zu empfangen - wobei auch das abgeschaltet werden kann).

Wer schon Xing-Mitglied ist, kann sich über diesen Link zur Gruppe anmelden. Sie ist freischaltungspflichtig durch Christian oder mich und die Beiträge sind (vorerst) auch nur für Gruppenmitglieder sichtbar. Die regelmäßigen Teilnehmer, die bereits ein Kontakt von mir in Xing sind, erhalten bis Montagabend eine Einladung. Sollte ich jemanden vergessen haben, bitte nicht persönlich nehmen!

Damit ihr auf dem Laufenden bleibt, kann man in Xing recht einfach Benachrichtigungen bei neuen Einträgen für die jeweiligen Foren aktivieren. So bekommt ihr eine E-Mail wenn jemand was gepostet hat.

Wir benötigen noch ein klein wenig kreative Unterstützung. Bitte schaut euch meinen Beitrag dazu an.

Vorschläge, Wünsche etc. sind wie immer willkommen!

Viele Grüße

Dieter

--
Dieter Rauscher
MVP Forefront

As many of you know the virtual machines that Microsoft kindly provides for evaluation of Visual Studio and Team Foundation Server expire on December 31. Fortunately Brian Randell has been busy creating a set of new virtual machines for VSTS/TFS/VS:

http://www.mcwtech.com/blogs/brianr/post/Happy-Holidays-and-look-what-Santae28099s-brought-2009-edition.aspx

This time we get both Virtual PC 2007/Virtual Server 2005 and Hyper-V compatible images, which is really useful since I use both Hyper-V and Virtual PC for demos and presentations. And we get images for VSTS 2008 SP1 and VS 2010 beta 2. The beta 2 image will be really useful for testing out the coming version (which I really recommend you checkout if you haven’t done so already). Here are the links to the full VPC images:

• Microsoft® Visual Studio® Team System 2008 Team Foundation Server SP1 and Team Suite SP1 VPC Image (Trial)
• Microsoft® Visual Studio® 2010 and Team Foundation Server® 2010 Beta 2 virtual image for Windows Virtual PC

Here are the file sets if you use the Free Download Manager for downloads:

Microsoft Visual Studio Team System 2008 Team Foundation Server SP1 and Team Suite SP1 VPC Image

http://download.microsoft.com/download/D/7/3/D73B91D4-6DAA-4DA6-8635-3F10A1B918DB/en_visual_studio_team_system_2008_sp1_december2009_vpc.part0001.exe
http://download.microsoft.com/download/D/7/3/D73B91D4-6DAA-4DA6-8635-3F10A1B918DB/en_visual_studio_team_system_2008_sp1_december2009_vpc.part0002.rar
http://download.microsoft.com/download/D/7/3/D73B91D4-6DAA-4DA6-8635-3F10A1B918DB/en_visual_studio_team_system_2008_sp1_december2009_vpc.part0003.rar
http://download.microsoft.com/download/D/7/3/D73B91D4-6DAA-4DA6-8635-3F10A1B918DB/en_visual_studio_team_system_2008_sp1_december2009_vpc.part0004.rar
http://download.microsoft.com/download/D/7/3/D73B91D4-6DAA-4DA6-8635-3F10A1B918DB/en_visual_studio_team_system_2008_sp1_december2009_vpc.part0005.rar
http://download.microsoft.com/download/D/7/3/D73B91D4-6DAA-4DA6-8635-3F10A1B918DB/en_visual_studio_team_system_2008_sp1_december2009_vpc.part0006.rar
http://download.microsoft.com/download/D/7/3/D73B91D4-6DAA-4DA6-8635-3F10A1B918DB/en_visual_studio_team_system_2008_sp1_december2009_vpc.part0007.rar
http://download.microsoft.com/download/D/7/3/D73B91D4-6DAA-4DA6-8635-3F10A1B918DB/en_visual_studio_team_system_2008_sp1_december2009_vpc.part0008.rar
http://download.microsoft.com/download/D/7/3/D73B91D4-6DAA-4DA6-8635-3F10A1B918DB/en_visual_studio_team_system_2008_sp1_december2009_vpc.part0009.rar
http://download.microsoft.com/download/D/7/3/D73B91D4-6DAA-4DA6-8635-3F10A1B918DB/en_visual_studio_team_system_2008_sp1_december2009_vpc.part0010.rar
http://download.microsoft.com/download/D/7/3/D73B91D4-6DAA-4DA6-8635-3F10A1B918DB/en_visual_studio_team_system_2008_sp1_december2009_vpc.part0011.rar
http://download.microsoft.com/download/D/7/3/D73B91D4-6DAA-4DA6-8635-3F10A1B918DB/en_visual_studio_team_system_2008_sp1_december2009_vpc.part0012.rar

Microsoft Visual Studio 2010 and Team Foundation ServerR 2010 Beta 2 for Microsoft Virtual PC 2007 SP1 Image

http://download.microsoft.com/download/0/2/6/026148BB-44EB-444F-BA8B-BFF39901A7CA/en_visual_studio_2010_beta2_december2009_vpc.part0001.exe
http://download.microsoft.com/download/0/2/6/026148BB-44EB-444F-BA8B-BFF39901A7CA/en_visual_studio_2010_beta2_december2009_vpc.part0002.rar
http://download.microsoft.com/download/0/2/6/026148BB-44EB-444F-BA8B-BFF39901A7CA/en_visual_studio_2010_beta2_december2009_vpc.part0003.rar
http://download.microsoft.com/download/0/2/6/026148BB-44EB-444F-BA8B-BFF39901A7CA/en_visual_studio_2010_beta2_december2009_vpc.part0004.rar
http://download.microsoft.com/download/0/2/6/026148BB-44EB-444F-BA8B-BFF39901A7CA/en_visual_studio_2010_beta2_december2009_vpc.part0005.rar
http://download.microsoft.com/download/0/2/6/026148BB-44EB-444F-BA8B-BFF39901A7CA/en_visual_studio_2010_beta2_december2009_vpc.part0006.rar
http://download.microsoft.com/download/0/2/6/026148BB-44EB-444F-BA8B-BFF39901A7CA/en_visual_studio_2010_beta2_december2009_vpc.part0007.rar
http://download.microsoft.com/download/0/2/6/026148BB-44EB-444F-BA8B-BFF39901A7CA/en_visual_studio_2010_beta2_december2009_vpc.part0008.rar
http://download.microsoft.com/download/0/2/6/026148BB-44EB-444F-BA8B-BFF39901A7CA/en_visual_studio_2010_beta2_december2009_vpc.part0009.rar
http://download.microsoft.com/download/0/2/6/026148BB-44EB-444F-BA8B-BFF39901A7CA/en_visual_studio_2010_beta2_december2009_vpc.part0010.rar
http://download.microsoft.com/download/0/2/6/026148BB-44EB-444F-BA8B-BFF39901A7CA/en_visual_studio_2010_beta2_december2009_vpc.part0011.rar
http://download.microsoft.com/download/0/2/6/026148BB-44EB-444F-BA8B-BFF39901A7CA/en_visual_studio_2010_beta2_december2009_vpc.part0012.rar

Enjoy!

So I was repurposing my HP ML 370 G4 from it's old job of being a SBS 2003 to another operating system.  And I threw on Windows 2008 64 bit to see if it would load.  While the box won't support HyperV (sniff) it may have a few years left to be a spare server duty out of it.  My first interesting factoid is that since it's been turned off for two weeks the controller card battery was low (this is why I plan for hardware change outs after five years).  The next thing I noted was exactly what is documented in this thread:

http://forums13.itrc.hp.com/service/forums/questionanswer.do?admit=109447627+1261799137682+28353475&threadId=1385979

Install using the smart start media and after you log into the OS the jet engines (better known as the fans on that sucker) turn on and do not turn off.

Do not use smart start. Set up the array without smart start and install the OS without smart start. Then install HP tools after OS installed

If you let it install ALL of the drivers, the jet engine sound will turn you deaf.

As that thread indicates, run 2003 on it, and it won't sound like a jet engine.  Put 2008 with the smart smart and wear ear plugs. 

So the moral of this story is.... sometimes you don't want to use that HP smart start media especially when you are putting server operating systems that are not the same "vintage" as the server is. 

As I always explain... sometimes you have to make sure you match the kids on the playground to ensure they are the same age to get them to play the nicest together.  That's why the vintage G4 + smart start + Windows 2003 plays nice and a G6 (my current model) and smart start and Windows 2008 works the best. 

My Analyzer ... the ultimate Data Dictionary Tool by Crystal Long, fellow Access MVP

With Crystal’s analyzer in your toolkit, you can get a handle on  what you have in Access ... structure, relationships, and  data.  It is, without a doubt, the most important set of  programs she has ever written for Access.

and the first thing you want to install is CCH PFX Engagement 6.0?  Doesn't everyone?

(okay so like maybe it's just the beancounters on Christmas morning that are giddy with delight of installing tax and accounting software on Windows 7, but in general this is the best way to install line of business applications, older software, and just in general getting a new box set up)

Step one turn off UAC.

Yes, you heard me, turn off UAC.  Turn it off DURING THE TIME YOU ARE INSTALLING SOFTWARE.  Not turn it off on your Windows 7 permanently, silly.

I have personally found that if I leave it on during the install of software (especially beancounter stuff) it doesn't quite install right even if I run as administrator and run the application compatibility wizard and all that.

So turn off UAC.  You will be prompted to reboot your Windows 7.  Then install the SQL 2008 (this is on the Engagement CD) and then install the PFX Engagement 6.0 from the MSI file (not autorun).

Remember Vista and Windows 7 have .net installed already.  Once you do that the program will run just fine.

Then go back and move UAC back up (mind you as a Vista veteran I move it all the way to the top but the default is one notch from the top).

Windows 7, CCH, pfx Engagment 6.0