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

305PARTAGES

4  0 
En janvier 2015, Microsoft a annoncé l’acquisition de Revolution Analytcs, l’entreprise axée sur le développement de solutions open source basées sur les versions libres et open source des logiciels R.

Après avoir ajouté cette entreprise à la liste des entreprises acquises, le géant du système d’exploitation a entamé sa refonte en rebaptisant les outils Revolution R Open en Microsoft R Open et Revolution R Enterprise pour Hadoop, Linux et Teradata a été renommé en Microsoft R Serveur. Microsoft R Server Developer Edition est une version gratuite proposée aux développeurs avec des fonctionnalités semblables à la version commerciale.

Lors de l’annonce du renommage de Revolution R Open, Joseph Sirosh, vice-président du groupe Microsoft Data, avait déclaré que « Microsoft R Server sera inclus dans SQL Server 2016 comme étant SQL Server R Services ». En attendant la version finale de SQL Server 2016, Microsoft vient de donner une information qui ne fera que ravir les utilisateurs de Visual Studio, l’environnement de développement intégré (EDI) de Microsoft.

« Je suis ravi d’annoncer que Visual Studio parle maintenant une autre langue : R », a déclaré Shahrokh Mortazavi sur le billet de blog de la firme. R est un langage utilisé dans le domaine de l’analyse des données scientifiques et pour la représentation graphique de celles-ci. Les professionnels utilisant ce langage de programmation peuvent dorénavant utiliser les outils R en combinaison avec Visual Studio pour traiter et analyser leurs données. Pour cela, il suffit d’installer Visual Studio et ensuite ajouter les outils R à l’environnement de développement.

Ces outils qui sont disponibles en préversion prennent en charge avec les éléments suivants dans l’EDI :

  • possibilité d’éditer les scripts R y compris les fenêtres et onglets détachables, la coloration syntaxique et bien plus encore ;
  • le code R est pris en charge par Intellisense afin de faire des appels de méthode et propriétés et compléter le code de manière suggestive ;
  • l’explorateur de variables prend également en charge les structures de données et examine aussi leurs valeurs ;
  • tout comme avec les autres langages, il est possible de déboguer le code R en ajoutant des points d’arrêt, des piles d’appels, etc. ;
  • plusieurs extensions couvrant différents aspects du langage R sont utilisables avec l’EDI ;
  • les utilisateurs du langage R peuvent également utiliser la fenêtre de l’historique pour parcourir, afficher, sélectionner les commandes antérieurement exécutées ;
  • la fenêtre interactive R fonctionne avec la console R directement dans Visual Studio. Les utilisateurs peuvent donc effectuer des boucles, évaluer, lire le code R directement dans la fenêtre ;
  • il est possible d’installer les packages Markdown/knitr afin d’afficher les données en aperçu au format Word ou HTML et les exporter dans les mêmes formats ;
  • les outils R pour Visual Studio supportent les packages des dépôts CRAN.

En plus de ces nouvelles fonctionnalités compatibles avec R, il faut également souligner qu’il est possible d'utiliser Visual Studio avec les packages disponibles sur les dépôts CRAN ou encore avec Microsoft R Open afin de disposer de certaines fonctionnalités telles que le support du traitement des processus sur des machines multiprocesseurs.

Enfin, les outils R pour Visual Studio sont également compatibles avec Microsoft R Server et les SDK R qui permettent d’accéder aux données et espaces de travail et également sont utilisés pour publier des modèles sur Azure Machine Learning.

En marge de l’annonce portant sur les outils R pour Visual Studio, Microsoft a également annoncé la disponibilité de la 7e mise à jour des outils Visual Studio pour Apache Cordova (TACO). Dans cette nouvelle mise à jour de TACO, la version 6.0.0 de Cordova est utilisée comme version par défaut.

Nous rappelons que Cordova est un framework open source permettant de créer des applications pour différentes plateformes (Android, Firefox OS, iOS, Ubuntu, Windows 8, etc.) en HTML, CSS et JavaScript.

Par ailleurs, il est maintenant possible de créer de nouveaux projets iconic pour des templates vierges, des templates pour onglets ou pour menus latéraux. À noter que plusieurs correctifs ont été introduits dans les outils Visual Studio pour Apache Cordova Update 7.

R Tools pour Visual Studio sur GitHub

Source : Blog plateforme de données (les outils R pour Visual Studio), Blog Visual Studio (les outils VS pour Apache Cordova Update 7)

Et vous ?

Avez-vous testé les outils R sur Visual Studio ? Êtes-vous satisfaits de cette implémentation ?

Que pensez-vous de la nouvelle mise à jour relative aux outils VS pour Apache Cordova ? Quels sont les éléments que vous souhaiteriez voir dans les prochaines versions ?

Voir aussi

Forum Visual Studio

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