We have gotten good feedback from customers and partners starting to adopt Azure Analysis Services in production. Based on this feedback, this week we are releasing improvements around pricing options, support for backup and restore, and improved Azure Active Directory support. Please try them out and let us know how they work for you.

New Basic Tier

The new Basic Tier is designed to support smaller workloads with simpler refresh and processing needs. While you can put multiple models in one Standard instance, this new tier enables you to create models that are more targeted at less cost. The key differences between Standard and Basic is that the Basic tier does not support some specific enterprise features. Standard supports larger sizes and higher QPUs for concurrent queries and adds data partitioning for improved processing, translations, perspectives, and Direct Query. If your solution doesn’t need these capabilities, you can start with Basic. You can also scale up from Basic to Standard at any time. However, once you scale up to the higher tier you can’t scale back down to Basic. As an example, you can scale from B1 to S0 and then from S0 to S1 and back to S0, but you cannot scale from S0 to either the Basic or Develop tier.

Backup & Restore

We have added backup and restore. At a high level, you configure a backup storage location from your subscription for use with your Azure Analysis Services instance. If you do not have a storage account, you will need to create one. You can do this from the Azure Analysis Services blade for backup configuration or you can create it separately. Once you have associated a storage location, you can backup and restore from that location using TMSL commands or a tool like SQL Server Management Studio (SSMS) which will support this shortly. The documentation has more details on Backing Up and Restoring Azure Analysis Services models. One note, to restore a 1200 tabular model you have created with an on-premises version of SQL Server Analysis Services, you will need to copy it up to the storage account before it can be restored to Azure Analysis Services. The Microsoft Azure Storage Explorer or the AzCopy command-line utility are useful tools for moving large files in to Azure. In addition, if you restore a model from an on-premises server, the on-premises domain users will not have access to the model.  You will need to remove all of the on-premises users from the model roles and then you can add Azure Active Directory users to roles. The roles will be the same. Azure Analysis Services Server Admins will still have access as these are AAD based members. The setting on restore for “SkipMembership” will honored in a future service update to make managing cloud based role membership easier.

Improved Azure Active Directory integration

We have also done some work to improve the way Azure Analysis Services works with Azure Active Directory. Starting now, any newly created Azure AS server will be tied to the Azure AD tenant for which your Azure subscription is associated with and only users within that directory will be able to use your Azure AS server if granted access. This means that if a server is created in a subscription that is owned by Contoso.com than only users within the Contoso.com directory will be able to use those servers. In order to use that server, users must still be granted access to a role within the model. Azure AD supports a few options for allowing users outside of your organization to get access to resources within your tenant. One of these upcoming options will be Azure AD B2B. With B2B, you will be able to add guest access to users outside of your organization to your models through Azure Active Directory. We are hard at work enabling B2B for Azure Analysis Services end-to-end and will post an update when it is fully available in SSMS in SSDT as well as client tools.

Depending on a few characteristics of your C++ project, this document will guide you through the recommended steps to get started with Visual Studio. Read on each chapter to see if it fits the description of your project. This post is part of a Getting Started series aimed at C++ users that are new to Visual Studio.

Cross-platform C++ applications and libraries

Building with CMake

If your project targets multiple platforms, you are likely to use CMake to specify your build. The steps needed to move to Visual Studio are very simple in this case – just open the folder containing your CMakeLists.txt files and let Visual Studio do the rest. To learn more about using CMake in Visual Studio, read the CMake support in Visual Studio page.

Targeting Qt Framework or building with QMake

Qt framework is a cross-platform C++ framework; it is ideal for building desktop, mobile and even embedded solutions. While you can use CMake to target Qt (in which case you should review the above topic), Qt also offers its own Qt-optimized build system called qmake that supports non-Qt C++ projects as well. If you are using qmake, learn how to import your .pro projects into Visual Studio.

Building with a cross-platform C++ build system (make, ninja, gyp, scons, gradle, etc.)

There are many build systems that support C++ today for cross-platform scenarios. It is outside the scope of this document to recommend one over another. But regardless of which build system your project uses today, you can open it inside Visual Studio and with minimal configuration you can become productive. With any of these build systems, you can enable all or any of the following Visual Studio capabilities:

• C++ editing (e.g. IntelliSense, code navigation)
• Building
• C++ debugging (e.g. Windows process debugging, attaching, remote debug, etc.)

To learn how to move to Visual Studio, read more about Open Folder support in Visual Studio 2017.

Linux C++ applications (including targeting server, cloud, IoT)

Are you developing a server-side component or a containerized binary running on Linux or maybe a critical component for an IoT device? Visual Studio provides support for targeting Linux out-of-the-box. You can edit, build and debug your C++ projects either by using a remote Linux machine or using the built-in Windows 10 Linux subsystem support. For a step-by-step guide to porting your projects to Visual Studio read Bring your existing C++ Linux projects to Visual Studio.

Android C++/Java applications

Using Eclipse

You can use Visual Studio to develop both your C++-only projects as well as C++/Java JNI-based projects targeting Android. If you’re currently using Eclipse, you can move to Visual Studio via our Eclipse Android Project Import Wizard. Follow the link to learn more about migrating your Eclipse Android projects to Visual Studio.

Using Gradle

Whether you already have a gradle-based build for your Android project, or you are just getting started targeting Android, Visual C++ provides the support you need to build Gradle projects. Visual C++ also offers a great editing and debugging experience for both your C++ and Java source code. To learn more, read about building your Android applications in Visual Studio using Gradle.

iOS Objective-C/C++ applications

If you’re targeting iOS and writing a lot of C++ code, you should consider importing your XCode projects into Visual Studio. Visual Studio not only provides an easy way to import these projects, but also allows opening these projects back in XCode if you need to make non-C++ related edits (e.g. storyboarding, UI design). Follow this link to learn more about migrating your XCode iOS projects to Visual Studio.

Windows C++ application

If your project targets Windows, you should consider using MSBuild as your C++ build system. With MSBuild, you can target from a single codebase all the platforms that Visual Studio supports today. You also get access to the C++ Project System that provides file and project management functionality that makes it easy to manage your project as it grows. You can easily addi references between projects, configuring PCH file, and configur compiler and linker switches across multiple projects). Learn more about migrating your C++ project to MSBuild.

What’s next

If you’re new to Visual Studio, learn more by reading the Getting Started with Visual Studio for C and C++ Developer topic (Coming soon!) and the rest of the posts in this Getting Started series aimed at C++ users that are new to Visual Studio. Download Visual Studio 2017 today, try it out and share your feedback.

If your C++ development scenarios are not covered today by Visual Studio, don’t hesitate to reach out to us at visualcpp@microsoft.com. We would love to learn more about it

Using MSBuild has the benefit that from a single codebase you can easily target all the Windows platforms that VS supports today, and you can leverage the C++ Project System that provides file and project management functionality. This makes it easy to manage your project as it grows (easily adding project references between projects, configuring PCHs, configuring compiler and linker switches across multiple projects, etc.).

This article covers the high-level steps needed to migrate your existing C++ code targeting Windows to use MSBuild. You can read about other C++ project types in the guide for Bringing your C++ code to Visual Studio.

Step 1. Run the Project from Existing Code wizard: Launch “File > New > Project from existing code…” and follow the wizard steps to create a new VS project for your sources. On the “Specify Project Settings” step, make sure you select “Use Visual Studio” before configuring any other option that might apply (e.g. using MFC, ATL or CLR).

Step 2. Translate compile options to VS: For this step, it’s recommended to turn up the verbosity of MSBuild (from Tools > Options > Projects and Solutions > Build and Run, change “MSBuild project build output verbosity” to “Detailed”). This step will list the compiler command lines that MSBuild uses to run the build. You can compare this against a log of the previous build system you were using.

Differences can be reconciled in the Project Properties dialog (right-click on the project in Solution Explorer and select “Properties”) > Configuration Properties > C/C++ > All Options. In the search box, you can search for a specific switch to find the property that maps to that switch and operate changes to make sure that MSBuild ends up calling the compiler with the same command line that your previous build system was.

Step 3. Use Shared code projects: If you want to expand your project to target more platforms in addition to Windows, follow the instructions in the “Cross-platform code sharing with Visual C++” article to move your C++ code into a shared code project and share it among C++ projects targeting Windows, UWP, Android or iOS.

Step 4. Consume 3rd party C++ libraries. If your project is depending on any open-source C++ libraries today, chances are that you will find them in vcpkg’s catalog. Vcpkg can easily integrate with MSBuild projects and can simplify both the build process for these 3rd party open-source libraries as well as the consumption in your own projects. To learn more about vcpkg, check out the Getting started with vcpkg introductory post.

What’s next

If you’re new to Visual Studio, learn more by reading the Getting Started with Visual Studio for C and C++ Developer topic (Coming soon!) and the rest of the posts in this Getting Started series aimed at C++ users that are new to Visual Studio. Download Visual Studio 2017 today, try it out and share your feedback.

This article covers the high-level steps needed to import your existing iOS XCode projects into Visual Studio. You can read about other C++ project types in the guide for Bringing your C++ code to Visual Studio.

Step 1. Install iOS support: Make sure that during VS installation, you select the “Mobile development with C++” workload. In the customization pane, make sure you select the “C++ iOS development tools” option as well.

Step 2. Install the remote Mac tools and connect from VS: Install vcremote on the Mac machine following the instructions in “Install and Configure Tools to Build iOS projects”. Then, in VS, from Tools > Options > Cross Platform > C++ > iOS, pair VS with your Mac machine

Step 3. Launch the XCode import wizard. Go to File > New > Import > Import from XCode and follow the steps of the wizard. To learn more about the wizard, read “Import a XCode project” in MSDN

Each XCode target will create a new Visual Studio project and your iOS source code will be available for further editing, building and debugging.

Step 4 (optional). Open Visual Studio project in XCode: When you need to make non-C++ changes to your iOS projects (e.g. storyboard editing), Visual Studio can automatically open your projects inside XCode running on your Mac. Once you’re done making changes, you can ask VS to copy these changes back to the Windows machine. Follow this link to learn more about syncing changes between XCode and Visual Studio.

What’s next

To learn more about the iOS support in Visual Studio read “Developing cross-platform iOS applications using Visual Studio”.

If you’re new to Visual Studio, learn more by reading the Getting Started with Visual Studio for C and C++ Developer topic (Coming soon!) and the rest of the posts in this Getting Started series aimed at C++ users that are new to Visual Studio. Download Visual Studio 2017 today, try it out and share your feedback.

If you’re currently using Eclipse and considering moving to Visual Studio, you can do that via our Eclipse Android Project Import Wizard. You can read about other C++ project types in the guide for Bringing your C++ code to Visual Studio.

Step 1. Install Android Support: Make sure that during VS installation, you select the “Mobile development with C++” workload. By default, it already includes all the prerequisites needed to build C++ Android projects.

Step 2. Install the Eclipse Import Wizard extension: From the Marketplace, install the Java Language Service for Android and Eclipse Android Project Import extension.

Step 3. Run the import wizard: Launch the wizard from File > New > Android Projects from Eclipse and follow the instructions

When the wizard completes, you will have projects for both the C++ parts and the Java parts of your Android Eclipse project. You can develop your Android project by editing, building and debugging both C++ and Java code.

What’s next

If you’re new to Visual Studio, learn more by reading the Getting Started with Visual Studio for C and C++ Developer topic (Coming soon!) and the rest of the posts in this Getting Started series aimed at C++ users that are new to Visual Studio. Download Visual Studio 2017 today, try it out and share your feedback.

This article covers the high-level steps to bring your existing Linux projects to Visual Studio. You can read about other C++ project types in the guide for Bringing your C++ code to Visual Studio.

Step 1. Install: Just make sure that you select the C++ Linux workload as part of the VS installation.

Step 2. Generate VS project: The next step is to create a VS Linux makefile project

$ ./genvcxproj.sh ~/repos/preciouscode/ preciouscode.vcxproj Z:

Step 3. Configure VS project properties: You will need to specify in Project Properties (right click on project in Solution Explorer) > Remote Build > Build Command Line the exact command you use on your Linux machine to build the sources. In addition, you will want to specify the additional include path that VS IntelliSense can use to properly aid when editing the code.

After these steps, you will be able to edit and browse your C++ code, build and debug remotely.

What’s next

Follow the links to learn more about Visual C++ for Linux development and Targeting the Windows Subsystem for Linux from Visual Studio.

If you’re new to Visual Studio, learn more by reading the Getting Started with Visual Studio for C and C++ Developer topic (Coming soon!) and the rest of the posts in this Getting Started series aimed at C++ users that are new to Visual Studio. Download Visual Studio 2017 today, try it out and share your feedback.

COM Server and OLE Document support for the Desktop Bridge

The Windows 10 Creators Update adds out-of-process (OOP) COM and OLE support for apps on the Desktop Bridge – a.k.a Packaged COM. Read more here to find out how it works.

New! Get out-of-process COM and OLE support for apps on the Desktop Bridge. https://t.co/3A7EADocI5

— Windows Developer (@windowsdev) April 13, 2017

Visual Studio 2017 – Now Ready for Your Windows Application Development Needs

Visual Studio 2017 is the most powerful Universal Windows Platform development environment. It brings unparalleled productivity improvements, a streamlined acquisition experience and enhanced debugging tools for UWP devs. Check it out.

The new version of Visual Studio has been out for a month! Read about it here: https://t.co/Yp3P4qXPVN

— Windows Developer (@windowsdev) April 12, 2017

Monetizing your app: Advertisement placement

App developers are free to place their ads in any part of their apps and many have done so to blend the ad experience into their app. We have seen that devs who take the time to do this get the best performance for their ads and earn more revenue. Want to learn how they do it?

Learn where to place ads in your app for the best possible performance. https://t.co/qJKfs64Stb

— Windows Developer (@windowsdev) April 10, 2017

The new Djay Pro App for Windows

Pretty cool work from the devs at @Algoriddim! https://t.co/sjWqqCxGap

— Windows Developer (@windowsdev) April 10, 2017

Download Visual Studio to get started.

The Windows team would love to hear your feedback. Please keep the feedback coming using our Windows Developer UserVoice site. If you have a direct bug, please use the Windows Feedback tool built directly into Windows 10.

The post ICYMI – Your weekly TL;DR appeared first on Building Apps for Windows.

The same applies to education: rather than focusing on probability and calculus, students can simply see what happens when you flip a coin or roll dice, and how the statistics converge in the long run. That's the premise behind Seeing Theory, a visual introduction to probability and statistics created by Daniel Kunin, a senior at Brown University. It starts with probability: for example, rolling a fair die to show the long-term average is 3.5. There's also a neat method of estimating the value of pi by counting random points falling in (or out) of a circle, or this demonstration of the Central Limit Theorem that drops random samples out of a skew distribution and showing that their mean has a Normal distribution.

There's lots more to explore (though some of the units are still being developed), and it's a great calculus-free way to get a budding statistician interested in the topic.

That's all from us for this week. Enjoy your weekend, and we'll see you back here on Monday!

We’re committed to giving you the best, fastest, and most efficient browser possible. In this post, I’ll share some of the new energy efficiency improvements available with the Windows 10 Creators Update.

Comparing the latest versions of major browsers on Windows, the trends are similar to what we’ve seen with previous releases. According to our tests on the Windows 10 Creators Update – based on an open-source test which simulates typical browsing activities across multiple tabs – Microsoft Edge uses up to 31% less power than Google Chrome, and up to 44% less than Mozilla Firefox.

Direct measurements of average power consumption during typical browsing activities (source code).

Let’s dive in to some details of how we measure power consumption to optimize for battery life, and how we’re engineering Microsoft Edge to be the most efficient browser on Windows 10.

Our approach: open, transparent, and reproducible

Measuring and improving battery life are both complicated problems, and while we want to show off our leadership here, we also want to be a part of a constructive dialog that improves the entire web. That’s why we always share our measurements alongside filmed rundown tests, or through open source tests freely available on GitHub. These tests are repeatable by other browsers or curious users, backed by methodology documents and open source code.

One of the most important tools for our energy efficiency engineering is BrowserEfficiencyTest. It automates the most important tasks that people do with their browser, and runs through those tasks while measuring how much power a device is consuming, as well as how hard the CPU is working, how much traffic is being sent over the network, and more. It can be used to look at specific sites and patterns, or measure complex workloads composed of many different sites in multiple tabs. This test supports Microsoft Edge as well as Google Chrome and Mozilla Firefox, so we can compare results across browsers over time.

Surface Books instrumented for direct power measurement, running a looping browser test in a performance lab.

Using an open test has also enabled us to work closer with partners to deliver a better experience to you. As we built the Windows 10 Creators Update, we collaborated with hardware teams like Surface and Intel to understand what’s going on at the hardware level when you’re on the web. By designing the software and the hardware to work with each other, we can make your device run even faster and last even longer.

Battery life improvements in the Windows 10 Creators Update

Our improvements in EdgeHTML 15 are focused not only on improving the average power consumption in Microsoft Edge, but also making it more consistent. The below chart shows the 90^th percentile power consumption during a multi-tab workload that went through email, social media, video, news, and more.

As you can see, the 90^th percentile has improved by 17% from the previous version of Microsoft Edge to the latest version. What does this mean for you? You can be more confident about getting consistent, all-day battery life with Microsoft Edge.

Let’s look at the specific things we’ve improved:

iframes are more efficient

Today, lots of web content is delivered using iframes, which allow web authors to embed documents (even from different origins) within their own webpages. This is a flexible, powerful, and secure tool used on many popular sites, often in the context of advertisements or embedded content. Iframes are essentially small webpages contained inside another web page.

Until now, these mini-webpages have been able to run JavaScript timers and code without restriction, even when you can’t see them. An iframe down at the bottom of an article could be running code, measuring if it’s visible, or performing animations while you’re still reading the headline at the top. With this release, we’ve made Microsoft Edge much more intelligent, throttling the JavaScript timers for iframes that aren’t visible, and stopping them from calculating animations that will never be seen. Users won’t notice any difference: the iframes still load and behave normally when you can see them. We’re simply reducing the resources they consume when they’re not visible.

Hit testing is more efficient

A common pattern we’ve found on sites is that pieces of a webpage want to know if they’re visible to the user or not, referred as hit testing. This is necessary for advertisers to judge the effectiveness of ads, as well as for creating infinite scrolling lists and other advanced layouts. In the past, this has been computationally expensive, especially since it’s done a lot. Sometimes, elements on a page will check to see if they’re visible on every frame, 60 times per second.

With the Creator’s Update, we’ve reworked what happens when the webpage needs to know if iframes or other elements are visible. We’ve added an additional layer of caching and optimizations to perform this common operation with less CPU and less power. Web developers don’t need to do anything different to take advantage of these improvements, and users won’t notice any difference, other than a faster experience and more battery life.

Intersection Observer

On top of these improvements, we’ve implemented a standards-based framework for webpages to accomplish the same thing without needing to constantly check for visibility themselves. This framework is called Intersection Observer; it’s supported by other major browsers and is documented with a working draft through the W3C.

When websites and ads take advantage of Intersection Observer, Microsoft Edge will do the work for them, calculating if they intersect with the main viewport or any other element. The page will be notified when any element’s intersection with the viewport changes, so constantly checking on every frame is no longer required. This is a much more efficient pattern, and will make the web better for everybody.

Encouraging HTML5 over Flash

In the Creator’s Update, we’re giving users even more control over their experience and helping transition the web to more secure, standards-based, and energy-efficient content by encouraging HTML5 over Flash and giving users control over where Flash is allowed to run. Not only is this good for battery life, but it will help improve security, speed, and stability.

Countless efficiency improvements based on telemetry

As with any release, we’re tweaking and improving what’s happening under the hood in Microsoft Edge. Recently, we’ve been using telemetry from real devices to measure how much time we’re spending responding to different APIs in JavaScript. This view tells us which functions we spend the most total time responding to across all devices, so we can improve those first and get the most bang for our buck.

An interesting note: the top 10 functions account for about 50% of the total time that JavaScript spends waiting for Microsoft Edge to respond. Using this data, we’re improving not only battery life, but making webpages feel faster and snappier as well.

What’s next?

As always, this work is a step in our ongoing journey to improve your experience on the web and maximize what you can get out of your browser and your device. When it comes to making Microsoft Edge faster and more efficient, we’re never done! We look forward to continuing to push the limits of efficiency, speed, and battery life in upcoming releases.

– Brandon Heenan, Program Manager, Microsoft Edge

The post Better battery life with Microsoft Edge appeared first on Microsoft Edge Dev Blog.

The Society of American Archaeology (SAA) is one of the largest professional organisations for archaeologists in the world, and just concluded its annual meeting in Vancouver, BC at the end of March. The R language has been a part of this meeting for more than a decade, with occasional citations of R Core in the posters, and more recently, the distinctive ggplot2 graphics appearing infrequently on posters and slides. However, among the few archaeologists that have heard of R, it has a reputation for being difficult to learn and use, idiosyncratic, and only suitable for highly specialized analyses. Generally, archaeology students are raised on Excel and SPSS. This year, a few of us thought it was time to administer some first aid to R's reputation among archaeologists and generally broaden awareness of this wonderful tool. We developed a plan for this year's SAA meeting to show our colleagues that R is not too hard to learn, it is useful for almost anything that involves numbers, and it has lots of fun and cool people that use it to get their research done quicker and easier.

Our plan had three main elements. The first element was the début of two new SAA Interest Groups. The Open Science Interest Group (OSIG) was directly inspired by Andrew MacDonald's work founding the ESA Open Science section, with the OSIG being approved by the SAA Board this year. It aims to promote the use of preprints (e.g. SocArXiv), open data (e.g. tDAR, Open Context), and open methods (e.g. R and GitHub). The OSIG recently released a manifesto describing these aims in more detail. At this SAA meeting we also saw the first appearance of the Quantitative Archaeology Interest Group, which has a strong focus on supporting the use R for archaeological research. The appearance of these two groups shows the rest of the archaeological community that there is now a substantial group of R users among academic and professional archaeologists, and they are keen to get organised so they can more effectively help others who are learning R. Some of us in these interest groups were also participants in fora and discussants in sessions throughout the conference, and so had opportunities to tell our colleagues, for example, that it would be ideal if R scripts were available for for certain interesting new analytical methods, or that R code should be submitted when manuscripts are submitted for publication.

The second element of our plan was a normal conference session titled 'Archaeological Science Using R'. This was a two hour session of nine presentations by academic and professional archaeologists that were live code demonstrations of innovative uses of R to solve archaeological research problems. We collected R markdown files and data files from the presenters before the conference, and tested them extensively to ensure they'd work perfectly during the presentations. We also made a few editorial changes to speed things up a bit, for example using readr::read_csv instead of read.csv. We were told in advance by the conference organisers that we couldn't count on good internet access, so we also had to ensure that the code demos worked offline. On the day, the live-coding presentations went very well, with no-one crashing and burning, and some presenters even doing some off-script code improvisation to answer questions from the audience. At the start of the session we announced the release of our online book containing the full text of all contributions, including code, data and narrative text, which is online here. We could only do this thanks to the bookdown package, which allowed us to quickly combine the R markdown files into a single, easily readable website. I think this might be a new record for the time from an SAA conference session to a public release of an edited volume. The online book also uses Matthew Salganik's Open Review Toolkit to collect feedback while we're preparing this for publication as an edited volume by Springer (go ahead and leave us some feedback!). There was a lot of enthusiastic chatter later in the conference about a weird new kind of session where people were demoing R code instead of showing slides. We took this as an indicator of success, and received several requests for it to be a recurring event in future meetings.

The third element of our plan was a three hour training workshop during the conference to introduce archaeologists to R for data analysis and visualization. Using pedagogical techniques from Software Carpentry (i.e. sticky notes, live coding and lots of exercises), Matt Harris and I got people using RStudio (and discovering the miracle of tab-complete) and modern R packages such as readxl, dplyr, tidyr, ggplot2. At the end of three hours we found that our room wasn't booked for anything, so the students requested a further hour of Q&A, which lead to demonstrations of knitr, plotly, mapview, sf, some more advanced ggplot2, and a little git. Despite being located in the Vancouver Hilton, this was another low-bandwidth situation (which we were warned about in advance), so we loaded all the packages to the student's computers from USB sticks. In this case we downloaded package binaries for both Windows and OSX, put them on the USB sticks before the workshop, and had the students run a little bit of R code that used install.packages() to install the binaries to the .libpaths() location (for Windows) or untar'd the binaries to that location (for OSX). That worked perfectly, and seemed to be a very quick and lightweight method to get packages and their dependencies to all our students without using the internet. Getting the students started by running this bit of code was also a nice way to orient them to the RStudio layout, since they were seeing that for the first time.

This workshop was a first for the SAA, and was a huge success. Much of this is due to our sponsors who helped us pay for the venue hire (which was surprisingly expensive!). We got some major support from Microsoft Data Science User Group program (ed note: email msdsug@microsoft.com for info about the program) and Open Context, as well as cool stickers and swag for the students from RStudio, rOpenSci, and the Centre for Open Science. We used the stickers like tiny certificates of accomplishment, for example when our students produced their first plot, we handed out the ggplot2 stickers as a little reward.

Given the positive reception of our workshop, forum and interest groups, our feeling is that archaeologists are generally receptive to new tools for working with data, perhaps more so now than in the past (i.e. pre-tidyverse). Younger researchers seem especially motivated to learn R because they may have heard of it, but not had a chance to learn it because their degree program doesn't offer it. If you are a researcher in a field where R (or any programming language) is only rarely used by your colleagues, now might be a good time to organise a rehabilitation of R's reputation in your field. Our strategy of interest groups, code demos in a conference session, and a short training workshop during the meeting is one that we would recommend, and we imagine will transfer easily to many other disciplines. We're happy to share more details with anyone who wants to try!

Using the feedback we received from our first preview of the tools, we’ve decided that our next iteration of Azure Function tools will focus on creating precompiled Azure Function apps using .NET Standard 2.0 class libraries.

Why the pivot?

When we shipped the preview tools in Visual Studio 2015 last winter, two of the most common requests we received were for project to project references, and unit testing support (both locally and as part of a continuous integration pipeline). These feature requests along with many others made it clear that people desired a very standard Visual Studio experience for developing and working with Functions.

So rather than attempting to re-invent the wheel, we felt the right direction was to move to the standard C# artifact (class libraries) that has decades of investment and first class support for these capabilities. Additionally, as mentioned in the Publishing a .NET class library as a Function App blog post, precompiled functions also provide better cold start performance for Azure Functions.

What does this mean?

As with any change, there are both costs and benefits to the change. Overall we believe this will be a great thing for the future of Azure Functions for the following reasons:

• These will be C# class libraries, which means that the full tooling power of the Visual Studio eco-system will be available including project to project references, test support, code analysis tools, code coverage, 3^rd party extensions, etc.
• NET Standard 2.0 is designed to work across the .NET Framework and .NET Core 2.0 (coming soon). This means .NET Standard 2.0 Azure Function projects will run with no code changes on both the current Azure Functions runtime, as well as on the planned .NET Core 2.0 Functions runtime. At that point, you can build .NET function apps on Windows, Mac, and Linux using the tools of your choice.

So, to ease the transition we recommend that you start new Azure Functions projects as C# class libraries, rather than using the 2015 preview tooling.

Conclusion

We hope that this helps to clarify what our current plans are, and why we think that it is the right thing to do for the long-term future of Azure Functions tooling. We’d also like to say that we’re working on on building this experience, and will have more details to share within the next month. As always, we would love your feedback, so let us know what comments and questions you have below, or via twitter at @AndrewBrianHall and @AzureFunctions.

SignalR 2.2.2 is a servicing release, including some highly requested updates and bug fixes.

Here are the highlights of the release:

• Support for Service Bus 3 (https://github.com/SignalR/SignalR/issues/3548)
• NetStandard version of the client (https://github.com/SignalR/SignalR/issues/3851)
• A bunch of work making Redis Scaleout more reliable

Here is a full list of issues fixed in this update.

This update also includes a new version of the SignalR C++ client (beta-2), which includes the following features:

• UWP Support
• Allow to specify web proxy
• Update nuget package to use cpprest 2.9.1
• SignalR-Client-Cpp in release mode asks for cpprest140d_2_7.dll

Both SignalR 2.2.2 and the C++ client include community contributions – thanks!

Note: As mentioned, this is a servicing release for SignalR 2.2, not a new release for .NET Core. We’re hard at work on the SignalR port to .NET Core, with an expected release later this year.

While I was getting Ruby on Rails to work nicely under Ubuntu on Windows 10 I took the opportunity to set up my *nix bash environment, which was largely using defaults. Yes, I know I can use zsh or fish or other shells. Yes, I know I can use emacs and screen, but I am using Vim and tmux. Fight me. Anyway, once my post was done, I starting messing around with open source .NET Core on Linux (it runs on Windows, Mac, and Linux, but here I'm running on Linux on Windows. #Inception) and tweeted a pic of my desktop.

By the way, I feel totally vindicated by all the interest in "text mode" given my 2004 blog post "Windows is completely missing the TextMode boat." ;)'

Also, for those of you who are DEEPLY NOT INTERESTED in the command line, that's cool. You can stop reading now. Totally OK. I also use Visual Studio AND Visual Studio Code. Sometimes I click and mouse and sometimes I tap and type. There is room for us all.

WHAT IS ALL THIS LINUX ON WINDOWS STUFF? Here's a FAQ on the Bash/Windows Subsystem for Linux/Ubuntu on Windows/Snowball in Hell and some detailed Release Notes. Yes, it's real, and it's spectacular. Can't read that much text? Here's a video I did on Ubuntu on Windows 10.

A number of people asked me how they could set up their WSL (Windows Subsystem for Linux) installs to be something like this, so here's what I did. Note that will I've been using *nix on and off for 20+ years, I am by no means an expert. I am, and have been, Permanently Intermediate in my skills. I do not dream in RegEx, and I am offended that others can bust out an awk script without googling.

So there's a few things going on in this screenshot.

• Running .NET Core on Linux (on Windows 10)
• Cool VIM theme with >256 colors
• Norton Midnight Commander in the corner (thanks Miguel)
• Desqview-esque tmux splitter (with mouse support)
• Some hotkey remapping, git prompt, completion
• Ubuntu Mono font
• Nice directory colors (DIRCOLORS/LS_COLORS)

Let's break them down one at a time. And, again, your mileage may vary, no warranty express or implied, any of this may destroy your world, you read this on a blog. Linux is infinitely configurable and the only constant is that my configuration rocks and yours sucks. Until I see something in yours that I can steal.

Running .NET Core on Linux (on Windows 10)

Since Linux on Windows 10 is (today) Ubuntu, you can install .NET Core within it just like any Linux. Here's the Ubuntu instructions for .NET Core's SDK. You may have Ubuntu 14.04 or 16.04 (you can upgrade your Linux on Windows if you like). Make sure you know what you're running by doing a:

~ $ lsb_release -a

No LSB modules are available.

Distributor ID: Ubuntu

Description:    Ubuntu 16.04.2 LTS

Release:        16.04

Codename:       xenial

~ $

If you're not on 16.04 you can easily remove and reinstall the whole subsystem with these commands at cmd.exe (note the /full is serious and torches the Linux filesystem):

> lxrun /uninstall /full

> lxrun /install 

Or if you want you can run this within bash (will take longer but maintain settings):

sudo do-release-upgrade

Know what Ubuntu your Windows 10 has when you install .NET Core within it. The other thing to remember is that now you have two .NET Cores, one Windows and one Ubuntu, on the same (kinda) machine. Since the file systems are separated it's not a big deal. I do my development work within Ubuntu on /mnt/d/github (which is a Windows drive). It's OK for the Linux subsystem to edit files in Linux or Windows, but don't "reach into" the Linux file system from Windows.

Cool Vim theme with >256 colors

That Vim theme is gruvbox and I installed it like this. Thanks to Rich Turner for turning me on to this theme.

$ cd ~/

$ mkdir .vim

$ cd .vim

$ mkdir colors

$ cd colors

$ curl -O https://raw.githubusercontent.com/morhetz/gruvbox/master/colors/gruvbox.vim

$ cd ~/

$ vim .vimrc

Paste the following (hit ‘i’ for insert and then right click/paste)

set number

syntax enable

set background=dark

colorscheme gruvbox

set mouse=a


if &term =~ '256color'

  " disable Background Color Erase (BCE) so that color schemes

  " render properly when inside 256-color tmux and GNU screen.

  " see also http://snk.tuxfamily.org/log/vim-256color-bce.html

  set t_ut=

endif

Then save and exit with Esc, :wq (write and quit). There's a ton of themes out there, so try some for yourself!

Norton Midnight Commander in the corner (thanks Miguel)

Midnight Commander is a wonderful Norton Commander clone that Miguel de Icaza started, that's licensed as part of GNU. I installed it via apt, as I would any Ubuntu software.

$ sudo apt-get install mc

There's mouse support within the Windows conhost (console host) that bash runs within, so you'll even get mouse support within Midnight Commander!

Great stuff.

Desqview-esque tmux splitter (with mouse support)

Tmux is a terminal multiplexer. It's a text-mode windowing environment within which you can run multiple programs. Even better, you can "detach" from a running session and reattached from elsewhere. Because of this, folks love using tmux on servers where they can ssh in, set up an environment, detach, and reattach from elsewhere.

NOTE: The Windows Subsystem for Linux shuts down all background processes when the last console exits. So you can detach and attach tmux sessions happily, but just make sure you don't close every console on your machine.

Here's a nice animated gif of me moving the splitter on tmux on Windows. YES I KNOW YOU CAN USE THE KEYBOARD BUT THIS GIF IS COOL.

Some hotkey remapping, git prompt, completion

I am still learning tmux but here's my .tmux.conf. I've made a few common changes to make the hotkey creation of windows easier.

#remap prefix from 'C-b' to 'C-a'

unbind C-b

set-option -g prefix C-a

bind-key C-a send-prefix


# split panes using | and -

bind | split-window -h

bind _ split-window -v

unbind '"'

unbind %

bind k confirm kill-window

bind K confirm kill-server

bind < resize-pane -L 1

bind > resize-pane -R 1

bind - resize-pane -D 1

bind + resize-pane -U 1

bind r source-file ~/.tmux.conf


# switch panes using Alt-arrow without prefix

bind -n M-Left select-pane -L

bind -n M-Right select-pane -R

bind -n M-Up select-pane -U

bind -n M-Down select-pane -D


# Enable mouse control (clickable windows, panes, resizable panes)

set -g mouse on

set -g default-terminal "screen-256color"

I'm using the default Ubuntu .bashrc that includes a check for dircolors (more on this below) but I added this for git-completion.sh and a git prompt, as well as these two alias. I like being able to type "desktop" to jump to my Windows Desktop. And the -x on Midnight Commander helps the mouse support.

alias desktop="cd /mnt/c/Users/scott/Desktop"

alias mc="mc -x"


export CLICOLOR=1

source ~/.git-completion.sh

PS1='[33[37m]W[33[0m]$(__git_ps1 " ([33[35m]%s[33[0m])") $ '

GIT_PS1_SHOWDIRTYSTATE=1

GIT_PS1_SHOWSTASHSTATE=1

GIT_PS1_SHOWUNTRACKEDFILES=1

GIT_PS1_SHOWUPSTREAM="auto"

Git Completion can be installed with:

sudo apt-get install git bash-completion

Ubuntu Mono font

I really like the Ubuntu Mono font, and I like the way it looks when running Ubuntu under Windows. You can download the Ubuntu Font Family free.

Nice directory colors (DIRCOLORS/LS_COLORS)'

If you have a black command prompt background, then default colors for directories will be dark blue on black, which sucks. Fortunately you can get .dircolors files from all over the wep, or set the LS_COLORS (make sure to search for LS_COLORS for Linux, not the other, different LSCOLORS on Mac) environment variable.

I ended up with "dircolors-solarized" from here, downloaded it with wget or curl and put it in ~. Then confirm this is in your .bashrc (it likely is already)

# enable color support of ls and also add handy aliases

if [ -x /usr/bin/dircolors ]; then

    test -r ~/.dircolors && eval "$(dircolors -b ~/.dircolors)" || eval "$(dircolors -b)"

    alias ls='ls --color=auto'

    alias dir='dir --color=auto'

    #alias vdir='vdir --color=auto'


    alias grep='grep --color=auto'

    alias fgrep='fgrep --color=auto'

    alias egrep='egrep --color=auto'

fi

Make a big difference for me, and as I mention, it's totally, gloriously, maddeningly configurable.

Leave YOUR Linux on Windows tips in the comments!

Sponsor: Did you know VSTS can integrate closely with Octopus Deploy? Watch Damian Brady and Brian A. Randell as they show you how to automate deployments from VSTS to Octopus Deploy, and demo the new VSTS Octopus Deploy dashboard widget. Watch now

     

Here are some of the changes that will light up when you turn on the feature.

Inviting people to the account in one easy step

Administrators can now add users to an account, with the proper extensions, access level, and group memberships at the same time, enabling their users to hit the ground running. You can also invite up to 50 users at once through the new invitation experience.

User management with all the information where you need it

The Users page has been re-designed to show you more information to help you understand users in your account at a glance. The table of users also now includes a new column called “Extensions” that lists the extensions each user has access to.

Detailed view of individual users

Additionally, you can view and change the access level, extensions, and group memberships that a specific user has access to through the context menu provided for each selected user – a one-stop shop to understand and adjust everything a user has access to.

Feedback

Try it out on your account and tell us what you think by posting on Developer Community or sending us a smile. We look forward to hearing your feedback!

Thanks,

Ali Tai

VSTS & TFS Program Manager