IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Microsoft annonce la disponibilité de la préversion des outils R sur Visual Studio
Ainsi que la sortie des outils Apache Cordova Update 7

Le , par Olivier Famien

319PARTAGES

4  0 
Microsoft dévoile la préversion de Visual Studio 2015
avec un support du développement cross-platform et un émulateur Android

À l’occasion d’un événement en ligne animé par des grands noms de l’écosystème .NET, dont Scott Guthrie (à l’origine d’ASP.NET et responsable de la division Cloud de Microsoft) et S. Somasegar (responsable de la division développeur de Microsoft), Microsoft a levé le voile sur l’avenir de la plateforme .NET et de Visual Studio.

Il faut dire que cette première journée de l’événement de deux jours a été très riche en annonces. La première grande nouvelle est la publication de la préversion de Visual Studio 2015, la prochaine version majeure de l’environnement de développement de Microsoft.

Le mot d’ordre dans cette version est « l’ouverture ». L’EDI permet du développement multiplateforme avec le langage C++, dispose d’un émulateur Android et des outils pour le développement avec le framework open source Apache Cordova.


Développement multiplateforme C++ pour mobile. La preview de Visual Studio 2015 offre une prise en charge du développement multiplateforme avec le langage C++, qui tire parti des compilateurs open source Clang et LLVM. Ce support permettra aux développeurs de partager, réutiliser, développer, déboguer et déployer leur code sur les autres systèmes d’exploitation (Linux, iOS et Android). Pour l’instant, seul le support d’Android est offert. Des outils et modèles de projets sont disponibles pour l’OS de Google. Le support des autres plateformes sera disponible avant la sortie de la version finale de l’EDI.

Émulateur Android. Visual Studio 2015 dispose d’un émulateur Android, en plus de l’émulateur pour Windows Phone. L’émulateur Android est basé sur Hyper-V et, selon Microsoft, il est rapide et fiable. L’émulateur Android va permettre de tester et déboguer les applications mobiles pour Android.


Pour les développeurs intéressés par le développement d’applications hybrides, Visual Studio 2015 dispose d’outils pour le développement avec Apache Cordova. Apache Cordova permet de concevoir des applications hybrides en JavaScript, HTML5 et CSS, pouvant exploiter les principales fonctionnalités et ressources (géolocalisation, accéléromètre, etc.) des plateformes mobiles. Ces applications peuvent être déployées sur un large éventail de dispositifs fonctionnant sur les systèmes d’exploitation Android, iOS, Windows, Windows Phone et BlackBerry OS. Microsoft offre des simulateurs et le débogage iOS et Android pour Apache Cordova.


Cette préversion de Visual Studio embarque un aperçu de la prochaine version du Framework .NET, une nouvelle plateforme de compilation .NET, avec une prise en charge d’ASP.NET 5. Il est désormais possible de créer des sites ASP.NET qui fonctionnent sur d’autres plateformes, y compris Linux et Mac.

Microsoft a intégré dans cette version Smart Unit Testing, une technologie de test unitaire développé par sa division de recherche. Cette version dispose également d’outils permettant d’intégrer facilement les services Microsoft, dont Office 365 ou encore Azure dans les applications.

L’éditeur de code a eu droit à plusieurs améliorations, notamment un meilleur support des écrans tactiles. Blend arbore un nouveau look et opte pour un thème un peu plus sombre et s’enrichit de l’IntelliSense et d’une fenêtre d’aperçu pour XAML.

Dans Visual Studio 2015, les compilateurs pour C# et VB.NET ainsi que l’éditeur de code reposent sur le compilateur open source Roslyn. À titre de rappel, Roslyn est un compilateur en tant que service développé par Microsoft, qui ambitionne non seulement de fournir un outil de compilation pouvant être utilisé dans le Cloud, mais également de démystifier cette étape en donnant accès aux développeurs aux informations générées par le compilateur.

L’intelliSense, le refactoring, CodeLens, le débogage, les outils de diagnostics, etc. offrent désormais de meilleures performances grâce à l’utilisation du compilateur Roslyn.

Télécharger Visual Studio 2015 Preview

Source : Blog Visual Studio

Et vous ?

Que pensez-vous de l'ouverture adoptée par Microsoft pour Visual Studio ?
Vous avez lu gratuitement 3 articles depuis plus d'un an.
Soutenez le club developpez.com en souscrivant un abonnement pour que nous puissions continuer à vous proposer des publications.

Une erreur dans cette actualité ? Signalez-nous-la !

Avatar de JolyLoic
Rédacteur/Modérateur https://www.developpez.com
Le 06/04/2016 à 20:40
Le problèmes des PCH, c'est qu'ils ne sont pas composables. Tu ne peux pas dire je prend le PCH lié à la lib A, et celui de la lib B, et je les fait tourner ensemble. Tu es obligé de faire un PCH spécifique qui ne marche que quand tu utilises A puis B.

Donc les PCH sont spécifiques à chaque projet, et doivent être générés dans chaque cas. Et se pose la question de savoir ce qu'on met dedans, et ce qu'on garde sous forme de #include en dehors du PCH. Si on n'en met pas assez, on est trop lent, si on en met trop, à chaque compilation incrémentale, on va devoir re-générer l'ensemble du PCH et perdre du temps.

On peut voir les modules comme des PCH mais qui sont composables, et où tu aurais un PCH par header (ou groupe de headers étroitement liés). Tu as généré le code précompilé pour A, celui pour B, tu peux les utiliser séparément ou ensemble, dans l'ordre que tu veux. Du coup, quand tu livres ta bibliothèque, tu livres le précompilé avec qui peut directement être réutilisé. Jamais tu n'auras besoin de le code client de parser les headers de cette bibliothèque. Pourquoi peut-on faire ça avec les modules, mais pas avec les PCH ? Voir ma réponse à la seconde question.

isolation from macros = en quoi les macros posent pb ?
Ce sont elles qui empêchent toute composabilité. Quand tu inclues un .h dans ton code, la manière de l'interpréter dépend de l'ensemble des macros définies au moment où tu l'inclues. Qui n'a jamais eu sous windows un problème pour inclure un header d'une bibliothèque third party après un #include <windows.h> parce ce dernier définit une macro min... L'idée de base est qu'un module ne dépende pas des macros définies avant qu'il soit importé, et qu'en retour, il ne pollue pas l'environnement avec ses propres macros. Et là, la modularité commence à apparaître.
Je dis "l'idée de base" parce que certains aimeraient bien pouvoir dire que sélectivement, telle ou telle macro définie dans un module pourrait être visible de l'extérieur. C'est en discussion.

il y a plus de problemes non resolus que de REELS problemes resolus (pas de gestion de namespace donc conflits potentiels, pas de versioning, description des fonctions non lisibles dans les fichiers binaires de 'package').
Je ne pense pas qu'il s'agisse forcément de réels problèmes, mais d'une simple description de ce que les modules ne sont pas, pour éviter les confusions :

Namespaces : Certains langages (Java par exemple) lient structure physique du code (modules, fichiers source) et structure logique (namespaces, classes). D'autres ne le font pas (C# par exemple). La proposition de module pour le C++ choisi de ne pas le faire. Ce n'est en rien une limitation, mais un choix qui fait sens en C++ (sinon, comment ajouter une spécialisation de std::hash ?).
Versionning : On a déjà tous des outils pour gérer les versions, tu as parlé de nuget par exemple, je ne vois pas trop quel rôle les modules pourraient jouer là dedans, à part éventuellement en terme de réflexion, qui peut toujours s'ajouter.
Binary distribution : C'est un problème potentiel. Mais d'un autre côté, les autres langages ont bien réussi à résoudre ce problème. Quand on distribue une assembly .NET, c'est bien un binaire qu'on distribue, et ça fait déjà 15 ans que ça dure sans problèmes. Ce qui va être plus dur est d'avoir un format compatible entre différents vendeurs (Microsoft a proposé d'open-sourcer le sien, Clang a dit qu'il était hors de question qu'ils l'utilisent). Mais la situation ne sera pas pire que ce qu'elle est aujourd'hui : On risque de devoir quand même compiler une bibliothèque pour le compilo qu'on utilise, comme on le fait aujourd'hui. C'est juste qu'on risque aussi de ne pas avoir besoin de le faire, si le mainteneur de la bibliothèque nous fourni un module compilé pour notre compilateur, chose qui était très difficile avant, à cause des multiplicités de gestions de macros. Donc la situation ne devient pas parfaite, mais elle s'améliore quand même.

Et sinon, pour avoir expliqué à pas mal de débutants, oui, les #include, c'est compliqué. Et parfois même des professionnels aguerris galèrent pendant des heures pour faire un #include dans certains contextes...
3  0 
Avatar de Aurelien.Regat-Barrel
Expert éminent sénior https://www.developpez.com
Le 06/04/2016 à 10:29
Bonjour,

Une autre nouveauté importante de l'Update 2 pour C++ concerne les modules (création de "packages" en C++ au lieu des classiques fichiers headers). Des améliorations importantes ont été faites pour les rendre utilisables (c'est ce qu'ils disent, moi j'ai pas pu tester encore!).

Citation Envoyé par Olivier Famien Voir le message
Nous rappelons que les coroutines sont similaires aux routines, mais se démarquent de ces dernières en ce sens qu’elles offrent la possibilité de suspendre et reprendre explicitement leur exécution en utilisant des opérations supplémentaires, alors que les routines s’achèvent généralement lorsque les processus parents prennent fin.
Je n'ai pas trouvé ce passage très clair, aussi je partage ma propre explication Une coroutine c'est une fonction qui peut être interrompue dans son exécution qu'elle reprendra là où elle l'avait laissé à son prochain appel. Une fonction classique termine son exécution lors d'un appel à "return". Dans le cas d'une coroutine, si elle return, alors oui c'est fini. Mais elle peut aussi rendre la main à l'appelant en plein milieu de son exécution, pour reprendre ensuite (lors de son prochain appel) là où elle s'était arrêté (au lieu de tout recommencer au début). La coroutine est en quelque sorte au thread ce que le thread est au processus.

L'intérêt concerne la programmation asynchrone. Au lieu de découper la logique du code en deux parties (par exemple : lecture des données sur une socket, puis traitement des données reçues), on simule une exécution synchrone classique. Sauf que au lieu de rester bloqué sur un opération d'E/S (lecture de la socket), on rend la main à l'appelant qui peut faire autre chose pendant ce temps. Ca évite de créer des threads à tout bout de champ (l'idée est d'avoir des milliers de coroutines) ou d'avoir un code asynchrone difficile à lire (éclaté en plein de callbacks).
1  0 
Avatar de Jonyjack
Membre averti https://www.developpez.com
Le 06/04/2016 à 14:25
Citation Envoyé par Aurelien.Regat-Barrel Voir le message
Je n'ai pas trouvé ce passage très clair, aussi je partage ma propre explication Une coroutine c'est une fonction qui peut être interrompue dans son exécution qu'elle reprendra là où elle l'avait laissé à son prochain appel. Une fonction classique termine son exécution lors d'un appel à "return". Dans le cas d'une coroutine, si elle return, alors oui c'est fini. Mais elle peut aussi rendre la main à l'appelant en plein milieu de son exécution, pour reprendre ensuite (lors de son prochain appel) là où elle s'était arrêté (au lieu de tout recommencer au début). La coroutine est en quelque sorte au thread ce que le thread est au processus.
Merci c'est plus clair en effet ! Ca me fait penser au "yield" de C#
1  0 
Avatar de Aurelien.Regat-Barrel
Expert éminent sénior https://www.developpez.com
Le 06/04/2016 à 14:46
Citation Envoyé par Jonyjack Voir le message
Merci c'est plus clair en effet ! Ca me fait penser au "yield" de C#
Et pour cause, c'est exactement ça ! Sauf qu'en C++ les mots-clés retenus sont finalement co_await, co_return et co_yield (afin d'éviter d'entrer en collision avec ces symboles dans du code existant).
1  0 
Avatar de kilroyFR
Membre éprouvé https://www.developpez.com
Le 06/04/2016 à 15:18
J'avoue que concernant les MODULES en C++ je n'ai pas bien compris la reelle utilité par rapport a un .h/.lib habituel...

faire
IMPORT myModule;
ou
#include <myModule.h>

Je suis preneur de toute explication qui me donnerait une vision sur le reel benefice de ce qui s'apparente plus a une nouvelle syntaxe (inutile ?) qu'autre chose.
1  0 
Avatar de Aurelien.Regat-Barrel
Expert éminent sénior https://www.developpez.com
Le 06/04/2016 à 16:58
Citation Envoyé par kilroyFR Voir le message
J'avoue que concernant les MODULES en C++ je n'ai pas bien compris la reelle utilité par rapport a un .h/.lib habituel...

faire
IMPORT myModule;
ou
#include <myModule.h>

Je suis preneur de toute explication qui me donnerait une vision sur le reel benefice de ce qui s'apparente plus a une nouvelle syntaxe (inutile ?) qu'autre chose.
Le premier intérêt est au niveau du temps de compilation : ton header est parsé une seule fois lorsque tu build ton projet au lieu de l'être à chaque inclusion (utilisation d'un fichier pré-parsé binaire à la place, un peu comme un PCH).

Il y a d'autres intérêts, présentés dans le papier de Microsoft (lire l'intro):
  1. componentization;
  2. isolation from macros;
  3. scalable build;
  4. support for modern semantics-aware developer tools.
  5. Furthermore, the proposal reduces opportunities for violations of the One Definition Rule (ODR), and increases practical type-safe linking. An implementation of these suggestions is ongoing in the Microsoft C++ compiler.

et aussi du côté de clang:
http://clang.llvm.org/docs/Modules.h...-current-model

Une autre façon d'aborder le sujet est qu'un langage moderne ne peut pas reposer sur un mécanisme aussi primaire que l'inclusion textuelle (qui déstabilise beaucoup de débutants).
1  0 
Avatar de kilroyFR
Membre éprouvé https://www.developpez.com
Le 06/04/2016 à 19:04
ouep je suis pas vraiment convaincu - c'est compliqué pour un debutant de comprendre les inclusions de .h ?
Ca me fait penser a ceux qui ne veulent pas faire du SQL parce que c'est jugé trop compliqué mais par contre utilisent des BDD noSql type MongoDb avec des syntaxes barbares completement illisibles, non normées etc.

Pour l'optimisation des temps de compil il y a les entetes pre-compilées. Visiblement quelque chose qui va en plus encore bouger

1. componentization = comme une librairie donc ? (librairie ca fait pas moderne certainement)
2. isolation from macros = en quoi les macros posent pb en debut de fichier - ca permet d'eviter de traiter N fois le meme fichier d'entete au contraire !
3. scalable build => entetes precompilées ca sert a ca pourtant
4. support for modern semantics-aware developer tools => là on est plutot dans des "concepts" qui me paraissent tres abstraits
Furthermore, the proposal reduces opportunities for violations of the One Definition Rule (ODR), and increases practical type-safe linking => idem 4

"qu'un langage moderne ne peut pas reposer sur un mécanisme aussi primaire que l'inclusion textuelle (qui déstabilise beaucoup de débutants)."
=> alors pour ne pas comprendre les principes d'inclusion textuelles on invente autre chose encore plus illisible.
J'ai l'impression qu'il aurait ete utile de rapprocher le C++ des autres langages "modernes" L4G style C#, Java (ajouter les proprietés etc.)

J'ai plus l'impression qu'ils ont essayé de placer les mots clés a la mode du moment 'scalable', 'isolation', 'component', 'modern' ...qu'un reel gain de productivité ou d'architecture logiciel.
Par ailleurs dans le document : http://clang.llvm.org/docs/Modules.h...-current-model
il y a plus de problemes non resolus que de REELS problemes resolus (pas de gestion de namespace donc conflits potentiels, pas de versioning, description des fonctions non lisibles dans les fichiers binaires de 'package').
Autant faire des nugets de librairies + entetes precompilées et on a tous les avantages sans les inconvenients.

Merci pour le lien vers site microsoft je vais quand meme le relire dans les details.
1  0 
Avatar de kilroyFR
Membre éprouvé https://www.developpez.com
Le 06/04/2016 à 22:17
Merci de tes reponses claires !

Perso je vais attendre encore quelques années que ca se stabilise tout en surveillant regulierement comment ca evolue.
1  0 
Avatar de Aurelien.Regat-Barrel
Expert éminent sénior https://www.developpez.com
Le 07/04/2016 à 18:15
Citation Envoyé par kilroyFR Voir le message
ouep je suis pas vraiment convaincu - c'est compliqué pour un debutant de comprendre les inclusions de .h ?
Il faut croire que oui. Le débutant en C++ n'est pas forcément un débutant en programmation. Il semble - d'après les retours que j'ai eu et que Loïc semble confirmer aussi - que ce système est complètement incompréhensible pour les développeur C#/Java par exemple. L'autre impact négatif du préprocesseur c'est qu'au niveau des outils basés sur le parsing de code, il contribue à rendre les choses encore plus complexes à faire correctement. Cela expliquerait en partie les lacunes de C++ à ce niveau.

La remarque sur l'ODR n'est malheureusement pas un "concept très abstrait", mais une réalité douloureuse. Sous VC++ par exemple, il est facile (moins qu'avant grâce à quelques précautions prises par MS) d'avoir des problèmes avec la STL si tu désactives les checked iterators sur certains projets et pas d'autres via un define (indirect) différent de _ITERATOR_DEBUG_LEVEL. Et la conséquence, ce sont des crashs incompréhensibles à l'exécution... C'est très complexe à identifier même pour un développeur confirmé !

Citation Envoyé par kilroyFR Voir le message
Autant faire des nugets de librairies + entetes precompilées et on a tous les avantages sans les inconvenients.
Note que les PCH (VC++ en tous cas) ne peuvent pas être livrés car ils sont spécifiques à la machine de build (et même à la version mineure du compilo).

Mais ce n'est pas le sujet : il n'est en effet pas question de générer des modules qui soit livrables / redistribuables sous forme binaire. Le but est d'amorcer le mouvement vers un meilleur système. Le système actuel fonctionne on est d'accord, mais montre vite ses limites sur des gros projets. Les PCH ont été rapidement inventés pour améliorer les choses, mais il s'agit plus d'un hack que d'une vraie solution (Loïc l'a très bien exposé). Donc si tu veux, on peut voir cette proposition comme la normalisation d'un meilleur système de PCH Encore une fois, cela intervient juste lors de la compilation. On ne redistribue pas le fichier IFC généré.

Citation Envoyé par JolyLoic Voir le message
Ce qui va être plus dur est d'avoir un format compatible entre différents vendeurs (Microsoft a proposé d'open-sourcer le sien, Clang a dit qu'il était hors de question qu'ils l'utilisent)
Ce qui pousse Microsoft à documenter son format c'est aussi de ne pas se faire taxer de solution fermée / propriétaire. Ce que clang (Google en fait) craint, c'est que l'approche MS s'impose par rapport à la leur. Car in fine c'est un peu les besoins de Microsoft vs les besoins de Google cette histoire (Google fait beaucoup de distribution de compilation...).
1  0 
Avatar de JolyLoic
Rédacteur/Modérateur https://www.developpez.com
Le 09/04/2016 à 13:27
Citation Envoyé par Aurelien.Regat-Barrel Voir le message

Mais ce n'est pas le sujet : il n'est en effet pas question de générer des modules qui soit livrables / redistribuables sous forme binaire. Le but est d'amorcer le mouvement vers un meilleur système.
Sur ce point, je suis loin d'être convaincu. Je pense que les gens qui livrent déjà leurs bibliothèques sous forme binaire vont regarder ça de près...
Citation Envoyé par Aurelien.Regat-Barrel Voir le message

Ce qui pousse Microsoft à documenter son format c'est aussi de ne pas se faire taxer de solution fermée / propriétaire. Ce que clang (Google en fait) craint, c'est que l'approche MS s'impose par rapport à la leur. Car in fine c'est un peu les besoins de Microsoft vs les besoins de Google cette histoire (Google fait beaucoup de distribution de compilation...).
Ce que je voudrais éviter, c'est que ça se fasse au détriment des utilisateurs et des outils autour du C++, surtout si le point précédent devient avéré...
1  0