Well, it’s Friday night and BUILD is now officially over, yet I can’t help but feel most, if not all, attendees walked away with a deep sense of excitement over Microsoft’s vision, direction and announcements from this week. This week was not just about further extending the “Cloud and Mobile” vision, but it was also about further embracing the broader developer ecosystem and technology landscape—and then some.

Across the Day 1 Keynote and Day 2 Keynote, there were roughly 55 new announcements, some more surprising than others but all contributing to this enthusiasm. You can also view the keynotes online here:

• Day 1
• Day 2

For me personally, I can only say that this week was hugely impactful; it provoked a number of very positive emotions and optimism on where we’re heading as a company and as a technical community. There is a significant evolution underway, and it’s amazing to not have just been here to experience a piece of it this week, but also to be thinking about the open road ahead. 

How about the sessions?

So, what about the sessions, you ask? Well, there was a ton of great sessions, most of which are now on C9. In an earlier post, I mentioned a few areas of interest I was targeting this week. Between meetings with customers, colleagues and vendors, I managed to take in a few sessions. In this post, I’ve included a few of my favorites. I will, however, follow up with a few more favorites as I work through the offline videos.

Session Videos already posted…

What’s New for ASP.NET and Web in Visual Studio 2013 Update 2 and Beyond – Scott Hanselman and Scott Hunter

You may have heard the saying: “I went to a fight and a hockey game broke out” If not, when the “lesser Scotts,” as they self-referenced, get on stage together you always feel something dangerous or angry could bust out. Nice. The Scotts covered off on a few areas, such as:

• One ASP.NET – e.g. one web template with the options built into the template, as opposed to multiple project templates within VS 2013
• Web Essentials: http://www.vswebessentials.com
• New features such as Bootstrap, which comes default within the MVC 5 templates (awesome), improved Web API and Azure support, evolved EF, attribute routing, tracing and logging, and so much more.

You can catch a recap of “the match” here:

https://channel9.msdn.com/Events/Build/2014/3-602 

Windows and the Internet of Things – Steve Teixeira

Steve is the Director of PM in the “Internet of Things” team at Microsoft. A solid session with some really interesting scenarios highlighted—which will make you think about Windows in quite a different way.

You can catch the session online here:

https://channel9.msdn.com/Events/Build/2014/2-511 

Azure Media Services: An Around-the-World Tour of Customer Case Studies – Martin Wahl

Martin works in the Media Services team at Microsoft and outlined a number of great customer stories that are using Media. This is a big and growing area, so it was very cool to see the different applications taking shape from both a customer and partner perspective.

You can catch his online here:

https://channel9.msdn.com/Events/Build/2014/2-611 

Take Your Solution Worldwide from the Start with Bing Translator – Chris Wendt and Jan Nelson

Bing often feels like the “sleeper cell” of services—it’s incredibly powerful and is showing up in a number of places (such as the newly announced “Cortana”). What appealed to me about this session is the fact that we live in an increasingly global-from-the-start development philosophy, and multi-language support is key. Having spent some time in natural language years ago, this proposition is tough—language is nuanced with colloquialisms, dialectical utterances, and the like that make disambiguation challenging. Things have come a long way. Wendt and Nelson covered off on how to build rich client and web translators—through client libraries or rich services using the Microsoft Translator libraries and the Bing Translator, which you can try out live.

You can check out this session online here:

https://channel9.msdn.com/Events/Build/2014/2-656

Session Videos not yet posted…

What’s New in IAAS for Developers – Corey Sanders

If you were following the news and keynotes this week, there is a ton of new Dev/Test features built into the Azure Infrastructure Services. And Corey is a great and fun speaker. His session is not yet posted, but you can check the link below to get it.

https://channel9.msdn.com/Events/Build/2014/3-614

Building End-to-End Video Experiences with Azure Media Services - Mingfei Yan

Mingfei is a PM in the Media Services team at Microsoft and a rock-star speaker—always informative and entertaining. As of today, her session was not yet posted, but here is a link to where you can go and check to download it.

https://channel9.msdn.com/Events/Build/2014/3-610

What’s New for Azure Developers in Visual Studio and Azure SDK – Dan Fernandez and Paul Yuknewicz

Dan and Paul focused their attention on the 2.3 version of the SDK talking about a number of the new features such as tracing, logging, in-template subscription integration, deeper views/property setting in the Server Explorer view, and much, much more. You can download the SDK 2.3 from http://azure.microsoft.com/en-us/downloads/. Dan and Paul are always fun and entertaining to watch, and while at the time of writing their session was not posted, you can find it here:

https://channel9.msdn.com/Events/Build/2014/2-585

Well, I have a few more that I’m working through so will post on those in Part 2 of this post.

In the mean-time, for those that attended this year’s BUILD, I hope you enjoyed it as much as I did. I also hope you walked away as invigorated as much as those I had the opportunity to talk with throughout the week.

Cheers,

Steve

Now that we’re here in Day 2, I’m eagerly awaiting the beginning of the Day 2 Keynote. If yesterday was any indication of what’s to come, today should be another great keynote. Alright, here we go!!!

Scott Guthrie opened the platform emphasizing the “Cloud and Mobile” first approach.

He also mentioned that there 44 new announcements with Services that are being announced for Azure today! (I’ve tried to capture most of them here.) He also mentioned that we’ve opened up major data centers in Shanghai and Beijing, which are now GA. Some key stats from Microsoft Azure that Scott walked through are represented in the following slide:

Impressive!

Scott showed a video of TitanFall that outlined how it uses Azure and how the server-powered gaming experience heavily leverages Azure. They had more than 100,000 virtual machines that were deployed on launch day. He also mentioned the Sochi Olympics, and how Azure delivered content and media throughout the major games. And my favorite sport, hockey, marked a Cloud-streaming record where there were record-number people watching the US vs. Canada hockey match.

Scott then brought Rick Cordella from NBC on-stage to talk about the experience of using Azure.

Rick mentioned that NBC took a $1B bet on Azure with the Olympics. “Azure played a critical role in this happening.”

Scott then dived into the specifics of what works with Azure. Some enhancements Scott walked through:

• Azure enables Windows and Linux, and now you can create, manage and debug VMs from within VS 2013.
• Azure now has support for capturing images, such that you can replicate the images fast and easy.
• Easily configure Azure through Puppet, Chef and PowerShell.

Mark Russinovich then came on to do a few demos, including creating VMs from within Visual Studio, debugging the VM (very cool because this means you can debug remotely into the app running on the VM using an Azure agent running on the remote machine), PowerShell management of VMs, and Puppet integrator (Puppet Labs now has an image inside the gallery).

Mark also invited Luke Kanies on stage from Puppet Labs to talk through and show how Puppet Enterprise works. He showed dynamically updating the Task Manager in a remote machine through the Puppet Enterprise console—a very easy update.

Mark then invited Daniel Spurling from Getty Images on stage to discuss how they’re using Azure, emphasizing the fact that they want their images/videos to be available to the world in real-time using Azure. Daniel emphasize the need for massive scale and storage required for Getty and Azure.

Scott then came back on stage to summarize the IAAS Services and make some new announcements. See the slide below.

He then segued into a discussion on PAAS, reinforcing the efficiencies and productivity of the platform. He then discussed the Azure Web Sites functionality. He talked about some of the efficiency gains through “swaps” when balancing staging versus production, as well as covering off on a number of other cool new features in Web Sites such as cross-language and platform support—shown in the slide below.

An aside: Azure Web Sites is awesome. I’ve used it in a number of ways, from new to migrated web sites to integration with SharePoint apps. The direct integration with the developer story is second-to-none, scalability, App insights, and many of the other built-in features, this PAAS choice from the within the Azure platform makes it one of many significant competitive differentiators for Azure.

Scott then invited Mads Kristensen on stage to walk through a few of the features that Scott discussed at a higher level. Specifically, he walked through the new ASP.NET templates emphasizing the creation of the DB layer and then showing PowerShell integration to manage your web site. He then showed Angular integration with Azure Web sites, emphasizing easy and dynamic ways to update your site showing  deep browser and Visual Studio integration (Browser Link), showing updates that are made in the browser show up in the code in Visual Studio. Very cool!!

He also showed how you can manage staging and production sites by using the “swap” functionality built into the Azure Web sites service. He also showed Web Jobs to show how you can also run background jobs and Traffic Manager functionality to ensure your customers have the best performing web site in their regions.

Scott then came back out and made some announcements, as per the slide below:

He also talked about a new cert/SSL offer (that provides 1 free cert) within Web site and then segued into talking about the mobile space, specifically talking to Azure Mobile Services, emphasizing the Active Directory integration with Mobile Services—which is great because this allows you to build enterprise-grade mobile applications that target multiple platforms in a very easy way!

Yavor Georgiev then came on stage to walk through a Mobile Services demo. He showed off a new Mobile Services Visual Studio template, test pages with API docs, local and remote debugging capabilities, and a LOB app that enables Facilities departments to manage service requests—this showed off a lot of the core ASP.NET/MVC features along with a quick publish service to your Mobile Services service in Azure. Through this app, he showed how to use Active Directory to build the app—which prompts you to log into the app with your corp/AD credentials to use the app. He then showed how the app integrates with SharePoint/O365 such that the request leverages the SharePoint REST APIs to publish a doc to a Facilities doc repository. He also showed how you can re-use the core code through Xamarin to repurpose the code for iOS.

The app is shown here native in Visual Studio.

This app view is the cross-platform build using Xamarin.

Kudos to Yavor! This was an awesome demo that showcases how far Mobile Services has come in a short period of time—love the extensibility and the cross-platform capabilities. Very nice!

Scott came back on after Yavor emphasizing the importance of Active Directory, walking through some of the key features of Active Directory such as Sync and broader app integration.

He then invited Grant Peterson from DocuSign on stage to discuss how they are using Azure, who demoed AD integration with DocuSign’s iOS app. Nice!

This is really huge for those of you building apps that are cross-platform but have big investments in AD and also provides you as developers a way to reach enterprise audiences.

Scott then came back to discuss some of the new announcements for Mobile, as per the slide below. 

Scott then turned to discussing data, noting that there are 1M+ SQL Databases being used and a 500GB increase for SQL Database and that you now have automatic back-ups built into the SQL Database service (this is a built-in feature). He also discussed Active Geo-Replication, such that the DBs can be set up to asynchronously replicate across regions. He also made a number of announcements, which are listed as follows:

Scott then moved into discussing the tools, emphasizing language, and invited Anders Hejlsberg to discuss project “Roslyn.” Anders announced an end-user preview for Roslyn and demoed some efficiencies gained through this preview at the programming language level. He also announced that they are open-sourcing the entire Roslyn project (which you’ll find on Codeplex). Anders published the Roslyn project live to Codeplex!

Anders walked through using the new “Roslyn” preview to build a new version of VS that accepted new language features (support for French quotes). Very, very cool!

Miguel de Icaza then came on stage to demo building an iOS app using Anders new language model.

Scott then came back on stage and then talked about tooling and support for Open Source, specifically talking about the .NET Founding contributions.

Bill Staples then came on stage to show off the new Azure portal design and features. Bill walked through a number of the new innovations in the portal, such as improved UX, app insights, “blade” views, etc. A screen shot of the new portal is shown below.

Bill also walked through the comprehensive analytics (such as compute and billing) that are now available on the portal. He also walked through “Application Insights,” which is a great way to instrument your code in both the portal and in your code with easy-to-use, pre-defined code snippets. He completed his demo walkthrough by showing the Azure portal as a “NOC” view on a big-screen TV.

Scott then came back on stage to reinforce the “transformative” nature of Azure and then introduced Steve (“Guggs”) Guggenheimer. He discussed partner and developer ecosystems and conversations, emphasizing three key conversations:

1. Support existing technology investments
2. Cloud and mobile development
3. Maximize business opportunities across platforms

He then invited John Shewchuk on stage to walk through a demo, which illustrates a transformation from a WPF app into a more modern app—moving the WPF app into a data-layer that sits in the Cloud and an identity layer that leverages Cloud-based Active Directory. John also showed an older WinForm app into a more modern MVVM app, with C# running on the server and the UI living as HTML5. Guggs also showed the same app on a device as well.

Steve then discussed the area of “Internet of things” where he addressed devices without UI—specifically talking about Windows Embedded and carrying this forward.

Steve and John then also talked about Surface devices in the cockpit, where 700 pilots are now using Surface Pros. They walked through Jeppesen Flight Deck Pro on the device to show how pilots would use the Surface Pro. They then discussed AutoDesk and FlipBoard as other examples of apps that either are using services that may be deployed to the Cloud or have been modernized for the Windows and mobile experience—showing the performance of FlipBoard on a Nokia 520 device. John also walked through migration of a FourSquare app to evolve the tile display using a geofence configuration in the code.

Guggs also walked through a SenSoria demo to showcase how fitness integrates with Cloud. A couple of screen-shots from Guggs walking around stage—where the app prompted to move more quickly to hit a more optimal fitness/calorie-burn rate.

Guggs also showed a video from Vespor, who leverage Azure as a back-end service for their note-taking iOS app, and another video showcasing Gobbler, a tool (or communications layer) for artists that helps manage project files and storage.

Guggs then showed how the Cloud optimizes gaming with enhanced performance. They also showed how you can use JavaScript (through Babylon) to very easily extend and show enhanced Virtual Reality.

The last area Guggs focused on was cross-platform for maximum mobile reach. The showed off a partner called GoPro and Java integration and support on Azure (through some minimal configuration)—see below.

They also discussed Accela, where they showed integrated services that bring different information sources into one view with a common identity layer across the app.

They also showed how you can use tooling to take a web site and create a Mobile app, using a URL to migrate a web site and then using “offline” mode that caches the site for offline use in the Mobile app. Very cool.

Guggs then took the sports app from the Day 1 keynote using Xamarin, which they showed on a Surface, Android and iPAD. They reinforced all of the different non-MSFT SDKs that are available to developers.

All-in-all, there was a lot that was shown in the Day 2 keynote; lots of Cloud advancements, app migration/modernization, and cross-mobile discussions with a good bunch of partner call-outs.

I have to say these two keynotes have been really significant. The charge was “Cloud and Mobile,” and all of the demos/areas discussed leaved up to the playbill. From these two days, you can see the importance of Windows (and all of the permutations where we’ll find it) and the dedicated tooling and language support that enable cross-platform, -language and –device support.

Overall, really exciting stuff!

Summary of Key Announcements

A round-up of some of the key announcements I heard today were as follows:

• GA of Azure in Beijing and Shanghai
• Capture/deploy of VM
• Puppet and Chef Support
• GA of Auto-scale service
• Create/Manage VMs from within VS
• Integrated remote debugging
• Virtual Network Point-to-Site VPN, Dynamics routing, subnet migration and static internal IP
• New Azure Management portal preview (live today)
• Integration of Visual Studio Online into Azure for seamless experience
• Azure Web sites Autoscale, Traffic Manager support, Webjobs, Backup, and Java support
• .NET Updates that include MVC 5.1, Web API 2.1, Identity 2.0, and Webpages 3.1
• Visual Studio Tooling such as New Project integration, PowerShell automation, Node.js Project support
• GA for CDN
• Mobile Services, including .NET back-end support, SSO and AD support, Offline Data sync, Visual Studio tooling, and Remote Debugging
• Azure AD, including iOS and Android SDK, Office 365 API integration and Azure AD Premium
• Notification Hub, including Mobile Services integration, Kindle support, and VS tooling
• SQL Database, including SQL DBs up to 500GB, 99.9% SLA, Self-service recovery, Active geo-replication
• HDInsight, including Hadoop 2.2, .NET 4.5 support, Audit and Operation history, Hive query enhancements, and VARN support
• Storage, icnluding read-access geo-redundance storage
• GA of Visual Studio Online (in the preview and existing portal)
• Azure Resource Manager preview
• AppStudio tool for packaging apps for store

Lots here, so enjoy!

Steve

Coffee in hand, cool air and a zeal in my step, I made my way to BUILD this morning, and now here we are. In San Francisco, at the Moscone Center, at BUILD. It’s Day 1, and the energy is palpable. I’m even a bit nostalgic seeing old friends and colleagues in the Convention Center hallways and thinking about the new friends I’ll make this week. But now it’s time for the keynote to begin…so let’s sit back and let the show begin!

Terry Myerson opened the keynote with emphasizing that Microsoft is about developers and all about “making your creativity come to life.” He emphasized that using public translation APIs, all that will be presented across the world to a multitude of audiences and in a number of languages. Through a great opening video, it noted that “1.5 Billion people use Windows every day!”

Joe Belfiore then took the stage and stated that there are two key announcements that will happen today: Windows Phone 8.1 and Update for Windows 8.1. He also showed a couple of new phones: MicroMax and Prestigio.

Joe stated that Windows Phone 8.1 is about “better expressing your personality and making you more efficient and productive.” He also showed a few demos including the new “Action Center”

He also showed some new features around the “Lock screen” that come with a set of APIs developers can use to exert deeper levels of control over the lock screen. He showed a number of interesting ways to change the lock screen such as vertically positioned images, specific themes, and so on.

He also discussed how to customize the Start Screen, to more fully customize your own phone experience. Below you can see the Start Screen customized with your own image.

He also introduced “Cortana,” which is the personal digital assistant for Windows Phone 8.1. Cortana is powered by Bing, thus “absorbs” the Internet and is able to personalize the phone experience specifically for you. Cortana augments the search function on your phone.

Joe walked through a number of things that Cortana can do such as scheduling appointments, learning, do searches, understand the places you frequent, tracks your interests, setting alarms, understanding personal and business calendars, etc. Cortana can also be extended through 3rd party apps.

The interesting thing about Cortana is that “she” learns about you the more you use your phone—the ultimate in personalization. One core feature of Cortana is a notebook that the assistant uses to manage information, suggestions, and other data about you. Joe walked through a number of demo scenarios from booking restaurant reservations, checking out sports scores, making personal appointments (and resolving conflicts across personal and business appointments), helping with dietary choices, etc. All of these demos were enabled through speech technology—i.e. Joe asking Cortana questions and interacting with the personal assistant in a speech-enabled way. He also showed textual interaction as well. Very cool stuff!

Joe also brought Nick Heddermen on stage to discuss Windows Phone in the context of business. Nick walked through a number of business scenarios using the phone. For example, he demoed “enterprise VPN” connectivity on the phone—so you’re able to connect to “behind-the-firewall” resources directly from your phone in a secure way! He also showed SMIME on the phone to digitally sign mail. He also showed how you can disable specific apps and information from being saved to the phone to optimize use and security on the phone.

Joe then walked through a range of features on Windows Phone 8.1, which are listed as following:

• Enhancements to the App Store experience; that is, making it easier for you to find the app that you need and providing personalized suggestions for users that include quick links.
• New Calendar, which makes swiping/navigating views easier, quick-view on weather, “at-a-glance” views of your week, all using a public API so all 3rd party developers can easily implement and update in similar ways.
• New Sense app for Wi-Fi (called Wi-Fi Sense), which helps you take advantage of Wi-Fi resources and automatically sign you into Wi-Fi without the need for user intervention. This is both for public networks and for home networks—where you can share your home network securely without giving access to all of your home network through giving out you password.
• Elevated Communications, where you can move from a normal phone call to a Skype call.
• Enhancements to Word-Flow Keyboard,  which makes typing much easier and quicker.

The enhancements to Word-Flow keyboard are record-breaking…literally!

Joe then switched to discuss Windows 8.1,and he demoed a few things:

• Boot to resume straight to desktop.
• Shared “interests” across Bing and Cortana on Windows 8.1.
• Enteprise-mode in IE 11, to show legacy compatibility and right-rendering with older web sites and apps.
• Windows taskbar enhancements to work with Windows Store apps along with some UI enhancements for Windows Store apps (e.g. minimize functionality).
• Number of other tiles and features added to the Start Screen to enable quick launch of Control Panel/Settings, Off, etc., and also the ability to manage your Start Screen view and move/resize tiles.
• Store will also become more mouse and keyboard friendly.
• Finding an app easier through search from the Start Screen, and new apps are now highlighted upon installation.

David Treadwell then came out to discuss the developer story. He focused on three areas:

• Accessing across PC, Phone and Browser.
• Investments in your apps and code
• Cross-platform capabilities

David introduced Universal Windows Apps, which brings the Windows run-time to the phone. This is huge because it enables you to design and build apps that projects across all form factors. As a developer, you do this in a common and predictable way—through the framework that you’ve come to understand, the tools you use on top of the Windows Runtime.

Kevin Gallo then showed an update to Visual Studio 2013 that enables you to build Windows Universal Apps, which introduces a number of templates and a “shared project” artifact that enables you, for example, to move Windows 8.1 apps to Windows Universal Apps. Kevin migrated a Sports-themed Windows 8.1 app to the Universal App and then opened this in the Windows Phone emulator. Below you can see the original app and then the “migrated” app in the emulator.

Kevin also showed a number of enhancements through Visual Studio such as logging, auditing the performance of the app, etc. Real nice debugging and diagnosing capabilities! He also showed how you can swap the views to see how XAML looks different on different form factors—as shown in the screenshots below.

David then discussed how you can leverage the Universal apps once across multiple devices from the Store, so you have a more consistent app experience through submission, purchase and identity.

Kirk Koenigsbauer then came out to demo some of the advancements in Office within the context of “Universal Windows.” He discussed a number of areas including:

• Connecting the services experiences of O365 with native Office.
• Maintaining and supporting the productivity experience when moving from Win32 to the Windows 8.1 platform.
• Highlighted performance, fidelity of graphics and editing, and showcased the touch experience using galleries for formatting.
• Unlimited “Un-do” and direct save to OneDrive.
• Presentation mode in Windows, inclusive of “pinch and zoon” and editing and mark-up during presentation mode.

David then came back and discussed the “continuum” to ensure developers have maximum choice across the Windows platform and device ecosystem. A nice demo here was showing how you could then leverage older, legacy code and with some UI updates and wrapper code could re-purpose legacy database access layers from older Win32 to Windows 8.1. The screenshot of the app is below.

David then discussed the power of the web on all devices through HTML5 and IE 11. He mentioned a number of areas of support, including 3 key call-outs:

• Web GL
• Cutting Edge Video Playback
• Great Developer Tooling

The following slide shows a number of IE11 web platform enhancements (in bold):

Terry then came back out to discuss “roadmap areas” to close out the last hour of the keynote, and discussed a few things that are coming:

• Windows Universal Apps will work on XBox. Here you can see the Universal Windows App running on Windows 8.1, Xbox and Windows Phone 8.1.

• Bringing Kinect to Windows, where he showed a few examples of how Kinect is being used on Windows.
• Graphics on XBox, and then integrating DirectX graphics capability across platform through DirectX 12. This brings the high-quality graphics native to XBox to the PC/Tablet/Phone experience.

• Internet of Things, where he discussed small-scale chips that run “full” versions of Windows and showed a “device” that was connected to the cloud that collected and displayed data.
• Start menu will be enriched in a forthcoming Windows 8.1 update.

• When the new Windows Internet of Things is available, it will be free. With Phones and Tablets, this new version of Windows will be free now.

Everybody at BUILD gets a new XBox One and a $500 gift-card to buy a new device at the MSFT store. Nice!!!

Terry then handed the stage over to Stephen Elop, who discussed the integration of the Nokia family with Microsoft. Here’s a line-up. (I have a 1520 and love it.)

Stephen walked through a couple of things:

• Nokia devices (and 1520 in particular) will come in more colors.
• Release of the Nokia 930, with wireless charging, high “megapixelation” images/videos, 4 high-performance digital microphones for incredible cinematic experiences, improved filters, living images through the Storyteller app, etc.

• Introduced the Lumia 630 and 635 (as a lower-priced option), including dual-sim and 3G. Note the image below shows the tiles at the top shown in two different colors, representing the different sims. Designed for hyper-social and gaming enthusiasts even at the more affordable price. First devices that will sell Windows 8.1, with hundreds of operators supporting this device.

• Discussed “SensorCore” where your device can act in much the same way other fitness devices act, so you get the data feed (e.g. your steps) along with the apps that you can use to analyze the data. This works hand-in-glove with the Bing Health app.
• New imaging SDK 1.2 and SensorCore SDK

Satya Nadella closed the Day 1 keynote out by doing a wrap of the keynote topics and then taking some pre-recorded questions. He provided some great answers across a number of areas, in some cases reflecting on what the keynote speakers had discussed and in others introducing areas such as compete, natural user interface, natural language, Microsoft’s focus on tooling and Cloud evolution, improved consistency across APIs, cross-platform support, and of course the improvements in Windows across the board. Overall, a great close-out with the inclusion of various, and different, voices from the developer community.

All in all, a great Day 1 Keynote!

Summary of Key Announcements

A round-up of some of the key announcements I heard today were as follows:

• Windows Phone 8.1 (will start to ship late April)
• Update for Windows 8.1 (coming April 8th or today on MSDN)
• “Cortana” Personal Assistant (Beta)
• Windows Universal Apps
• WinJS as an Open Source project (available today)
• VS 2013 Update 2RC (available today)
• Windows Universal Apps running on XBox
• Kinect V2 for Windows
• “Internet of Things” version of Windows
• Nokia 930 (selling globally starting in June)
• Imaging SDK 1.2 and SensorCore SDK

Well, that’s it for the Day 1 keynote. And wow, there was a lot of stuff happening and some great giveaways today at BUILD!

I’ll continue to blog on the sessions tomorrow’s keynote and throughout the week as interesting information and learnings arise throughout the week.

Cheers,

Steve

If you want to check out the week’s agenda, you can also go direct to the C9 site, where you can sign in and add your sessions there as well. If you click the List tab, you can then see all of the sessions listed; you can then click the +My Schedule link to add the sessions to your schedule. You can also filter the view with tags, speakers, level, and so on along the right-hand side of the page.

At first glance of the agenda, there are some really interesting sessions at BUILD. I’m seeing a ton of Mobile and Cloud sessions, and particularly interesting are ones that cover the following areas:

1. Azure Media Services
2. HDInsight
3. Cross-Platform Mobile Development with C#
4. XAML Futures
5. ASP.NET Futures
6. VS 2013 and VS Online
7. Internet of Things
8. Building apps with Bing

What’ll be interesting to see is how the above come together. With the increased focus on Mobile and Cloud (and more broadly Devices and Services), each of the above can be integrated in a number of ways to create Modern Apps.

And since C9 props most of the recordings post-conference, you’ll be able to catch a lot of the above at your own leisure—so nothing will be missed!

More to come!

Cheers,

Steve

Well, since I’m heading down to BUILD tomorrow, I’m going to give you guys all of the juicy gossip, the news as it hits the keynote, and all of the exciting session details as I hear them. I’m going to take pictures, live-blog from sessions, and generally document the cool stuff that is happening at BUILD.

So, why should you care, you ask? This BUILD’s going to be great. And it’s SOLD OUT!!! I couldn’t believe it; the conference sold out in a matter of a couple of days. While it’s unfortunate some of you won’t be there in person, the awesome thing is you’ll be able to catch many of the sessions online either during or after the conference.

To check out the sessions, be sure to go here. To watch sessions and the event activities live, go here—or just go to the BUILD home page: http://www.buildwindows.com/.

For those attending, I hope to see you there. For those watching from home, enjoy the show…it’s going to be great!

Steve

In the second part, I wanted to add some code to flesh out the app to interact with SharePoint. In this blog, we’ll create a read event that uses a context and access token to interact with a SharePoint list. In essence, you’ll deploy a Provider-hosted app to Windows Azure, and then you’ll deploy the .APP to SharePoint.

So, let’s get started.

If you take the principles you learned in Part 1, you’ll do the same thing in this blog. So, let’s go ahead and create a new Provider-hosted app. To do this:

• Open Visual Studio 2012
• Click File, New Project
• Select Office/SharePoint, Apps, and App for SharePoint 2013
• Provide a name for the project, and click OK.
• Double-check the name of the project, the URL to your SharePoint site, and select Provider-hosted in the drop down list
• Click Finish

All of the above should be review for you at this point—assuming you followed along with Part 1. The project comprises two parts: the APP, which contains the AppManifest.xml file (config file for SharePoint), and the Web file, which you’ll deploy to Windows Azure. You can see in the image below the different elements of each part of the project.

I mentioned this in the first post, but will review in a little more detail here. When you create a new Provider-hosted app, you’ll see some code-spit by default. Without doing anything, you could hit F5 and your app would run and you’d see the title of your site appear at the top of the web page. The code below is the default code that is created when you create a new project. The two bolded lines use the new TokenHelper class, which contains a set of methods that enable you to manage requests for auth tokens in your app. The first bolded line retrieves a context token from the page request, and the second wraps the CSOM API with an auth token. It’s important to note that you can’t interact with SharePoint unless you have a context token, and you can’t access resources within SharePoint without an access token—and of course you need to set permissions within the AppManifest.xml file. Point being, you really need to be thinking more about the permissions and authorization within your app.

Note: There’s a great MSDN article on app authorization here: http://msdn.microsoft.com/en-us/library/office/apps/fp142384.

    …

            using (var clientContext = TokenHelper.GetClientContextWithContextToken(hostWeb, contextToken, Request.Url.Authority))
            {
                clientContext.Load(clientContext.Web, web => web.Title);
                clientContext.ExecuteQuery();
                Response.Write(clientContext.Web.Title);
            }

        }

    …

Let’s go ahead and make some changes to the default code-spit to make this app a tiny bit more interesting.

In the spirit of keeping things simple for illustration, right-click Default.aspx and select View Designer. Drag a GridView object onto the Designer surface.

If you click the Source tab, you should see something similar to the bolded code below:

…

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <asp:GridView ID="grdviewSPData" runat="server"></asp:GridView>
    </div>
    </form>
</body>
</html>

Double-click the Default.aspx.cs file and then replace the default code discussed above with the code below. You can again see the TokenHelper class here being leveraged to set the context for the app and then getting an access token to interact with SharePoint resources. Key to the use of the access token is the fact that it is passed in the ReadListItem method and then used to set auth properties on the request object. You may recognize the code inside the ReadListItem method, which I ‘borrowed’ from one of the SDK samples.

What’s important to note here is that any time you have an event or object that triggers an event, you must have an access token attached to it so it can interact with the SharePoint resources—e.g. read or write to a list. Also, you should note that there are different ways in which you can manage the context token—e.g. through the page request, page or session cache, accessing the headers, or through a response.redirect call:

Response.Redirect(TokenHelper.GetAppContextTokenRequestUrl(sharePointUrl, Server.UrlEncode(Request.Url.ToString())));

There are a good set of tips and tricks for developers around auth, which you can find here: http://msdn.microsoft.com/en-us/library/office/apps/fp179932.

Getting back to the code, the below in essence gets the appropriate context tokens with SharePoint, gets the access tokens, and then uses the access tokens to read a default list within SharePoint.

using Microsoft.SharePoint.Client;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Xml.Linq;

namespace Test_Provider_Hosted_App_2_20_2013Web.Pages
{
    public partial class Default : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            var contextToken = TokenHelper.GetContextTokenFromRequest(Page.Request);

            SharePointContextToken spContextToken = TokenHelper.ReadAndValidateContextToken(contextToken, Request.Url.Authority);

            var appWeb = new Uri(Page.Request["SPAppWebUrl"]);

            string myAccessToken = TokenHelper.GetAccessToken(spContextToken, appWeb.Authority).AccessToken;

            ReadListItems(appWeb.ToString(), myAccessToken); 
        }

        private void ReadListItems(string webUrl, string myAccessToken)
        {
            string oDataUrl = "/_api/Web/lists/getbytitle('Composed Looks')/items?$select=Title,AuthorId,Name";

            HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(webUrl.ToString() + oDataUrl);
            request.Method = "GET";
            request.Accept = "application/atom+xml";
            request.ContentType = "application/atom+xml;type=entry";
            request.Headers.Add("Authorization", "Bearer " + myAccessToken);
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();

            XDocument oDataXML = XDocument.Load(response.GetResponseStream(), LoadOptions.None);
            XNamespace atom = "http://www.w3.org/2005/Atom";
            XNamespace d = "http://schemas.microsoft.com/ado/2007/08/dataservices";
            XNamespace m = "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata";

            List<XElement> entries = oDataXML.Descendants(atom + "entry")
                                     .Elements(atom + "content")
                                     .Elements(m + "properties")
                                     .ToList();

            var entryFieldValues = from entry in entries
                                   select new
                                   {
                                       Title = entry.Element(d + "Title").Value,
                                       AuthorId = entry.Element(d + "AuthorId").Value,
                                       Name = entry.Element(d + "Name").Value
                                   };

            grdviewSPData.DataSource = entryFieldValues;
            grdviewSPData.DataBind();
        }

    }
}

At this point, you can hit F5 and debug, and your code should execute just fine. As you can see from the below, you’re running the SharePoint app in localhost, so you should have no trust issues with your app.

If you copy and paste the URL of your app into Notepad, you’ll see something similar to the below:

https://localhost:44303/Pages/Default.aspx?SPHostUrl=https%3A%2F%2Fmydemosite2013%2Esharepoint%2Ecom%2Fsites%2Fspc&SPLanguage=en%2DUS&SPClientTag=0&SPProductNumber=15%2E0%2E4454%2E1011&SPAppWebUrl=https%3A%2F%2Fspcdemo2013%2Db802311f297b7f%2Esharepoint%2Ecom%2Fsites%2Fspc%2FTest%5FProvider%5FHosted%5FApp%5F2%5F20%5F2013

It’s not just about making sure the auth is managed in your code; remember that you also need to create a ClientID and ClientSecret and add to your project files. Specifically, as you did in Part 1, make sure you create a new ClientID and ClientSecret and then add those to the AppManifest.xml and Web.Config files.

Now, you can go ahead and follow the same pattern as in Part 1 and create a new Azure Web site, to which you will deploy the Web project. To do this:

• Navigate to your Windows Azure portal
• Click Web Sites
• Click New
• Select Compute, Web Site, Quick Create, provide a URL, and then select the region in which you want to deploy the site
• Click Create Web Site

Make sure you click the Download publish profile link to save your publish profile locally, so you can configure the publish process to Azure in Visual Studio.

If you click Configure, you’ll see that you can also add your ClientID and ClientSecret on the Azure site. Go ahead and add the settings here as well.

Back in Visual Studio, right-click the Web project and select Publish. This will prompt you to import your publish profile and provide a wizard for you to publish your Windows Azure app.

Once you’ve deployed your Windows Azure app, you can right-click the APP project and select Publish. This does not deploy your files to SharePoint; it only creates the package of files for you to either deploy into an on-premises environment or to upload the APP file to SharePoint. You can do this by navigating to your SharePoint site, clicking new app to deploy, and then browsing, uploading, and trusting the app.

Once you’ve deployed the app to SharePoint, you can then click the newly deployed app and you can see that now it is deployed to Azure, integrated with SharePoint and using the appropriate tokens to read a list from the SharePoint site.

Again, take note of the long URL that contains the cross-domain reference along with the SharePoint tokens.

https://spappinazure.azurewebsites.net/Pages/Default.aspx?SPHostUrl=https%3A%2F%2Fmyspsite2013%2Esharepoint%2Ecom%2Fsites%2Fspc&SPLanguage=en%2DUS&SPClientTag=0&SPProductNumber=15%2E0%2E4454%2E3006&SPAppWebUrl=https%3A%2F%2Fspcdemo2013%2Db802311f297b82%2Esharepoint%2Ecom%2Fsites%2Fspc%2FTest%5FProvider%5FHosted%5FApp%5F2%5F20%5F2013

A tip for you…

One thing I kept coming across was the “null context token” error. Drove me crazy to say the least. However, I discovered that there are a couple of things that could cause this to happen:

• The ClientID in your AppManifest.xml and in your Web.Config do not match.
• Your domain reference to Azure is HTTP instead of HTTPS in the AppManifest.xml file.

The second one tripped me up for quite some time—makes sense right since we need an auth handshake. The code worked fine, but then when deployed it kept spitting up the null token error. I’ve bolded the culprit line below

…
<App xmlns="http://schemas.microsoft.com/sharepoint/2012/app/manifest"
     Name="Test_Provider_Hosted_App_2_20_2013"
     ProductID="{d8eda873-90b8-4d34-b75b-0bb56a0718ea}"
     Version="1.0.0.0"
     SharePointMinVersion="15.0.0.0"
>
  <Properties>
    <Title>Test_Provider_Hosted_App_2_20_2013</Title>
    <StartPage>https://spappinazure.azurewebsites.net/Pages/Default.aspx?{StandardTokens}</StartPage>
  </Properties>

  <AppPrincipal>
    <RemoteWebApplication ClientId="e432a156-56c9-46a4-a296-13ca4618fd86" />
  </AppPrincipal>
  <AppPermissionRequests>
    <AppPermissionRequest Scope="http://sharepoint/content/sitecollection/web" Right="FullControl" />
    <AppPermissionRequest Scope="http://sharepoint/content/sitecollection/web/list" Right="FullControl" />
    <AppPermissionRequest Scope="http://sharepoint/content/sitecollection" Right="FullControl" />
  </AppPermissionRequests>
</App>

The OAuth pattern for SharePoint 2013 is new, and it takes some getting used to. My advice to you would be to build out small apps and get them working in a simple way, and then use a common approach to managing your token requests across your app. It is tricky, and it does take some prep and reading time. Invest some time to practice this, and you’ll find it a pretty powerful tool to begin to connect your Windows Azure apps with your SharePoint Apps.

Enjoy!

Steve

Within Autohosted Apps, SharePoint has its “own” Azure environment where you can build and deploy your Cloud-Hosted App, and using this model is quick, agile and enables you to natively tap into the ability to deploy Cloud-Hosted Apps to SharePoint without too much fuss. Provider-Hosted Apps are a slightly different beast. As the name implies, the Cloud services are not automatically hosted for you. You are the “provider” so you need to build, deploy and host your Cloud app in your own domain; though, SharePoint provides plumbing (e.g. APIs, Authentication services, etc.) to enable the connection between a Cloud-hosted App that is deployed to your own domain. Also, it’s worth noting that just because a Provider-hosted app is a type of Cloud-hosted app, it doesn’t mean that the domain to which you deploy could not be an on-premises Web server. So, think of the “hosted domain” part as flexible; you can deploy on-premises, or you can deploy to the Cloud.

For more information on Provider-Hosted Apps, see the following MSDN article: http://msdn.microsoft.com/en-us/library/fp179887.aspx.

In this blog, I wanted to walk you through how to create a deploy a simple Provider-Hosted App. This will be Part 1. (In Part 2, we’ll cover more about the glue that binds your Provider-Hosted App to SharePoint.)

So, let’s get started.

Setting up your Development Environment

If you’re just starting out with building Provider-Hosted Apps in the Cloud, then you’ll first want to check out this blog post: http://blogs.msdn.com/b/steve_fox/archive/2013/02/03/setting-up-your-development-environment-for-o365-amp-azure-development.aspx. I’ve documented the fundamentals to setting up your own development environment, inclusive of the Windows Azure part.

Key takeaway here is that while you’re getting started, you can use the new Windows Azure Web Sites service to create a simple Web site that’s free and that’s hosted in Windows Azure. This gives you a chance to try before you buy.

Creating a New Azure Web Site

Assuming you’ve got your development environment set up, you can now go ahead and create a new Azure Web Site. To do this:

• Navigate to www.microsoft.com/windowsazure
• Click the PORTAL link in the upper right-hand corner of the page
• Sign in using your LiveID
• Click the Web Sites link along the left-hand side of the page
• Click the New button at the bottom of the page
• Click QUICK CREATE, provide a valid URL, select a REGION (which is the data center in which your Azure app will be deployed) – see image below
• Click CREATE WEB SITE

The provision process should take less than a minute to create, and when it does you’ll be able to click the new link in your portal and navigate to your newly created site. Now don’t be surprised when you see a default page with some graphics on it; this is just a starter page that you can customize. The important thing is that you’ve got a live Web site up and running, and it’s hosted in your own Windows Azure domain—see image below. An interesting note is that Windows Azure Web Sites are HTTPS compliant by default, so the site below can be accessed via http://mycrazycool.azurewebsites.net or https://mycrazycool.azurewebsites.net. Further, the trusted root certs used in Azure are conversant with Office 365/SharePoint, so you don’t have to go off and create a whole new trusted cert to get HTTPS working for you.

With your Web site now created, the question is what’s next? Well, let’s assume you want to customize your new Azure Web site a little—maybe even has some limited interaction with SharePoint. You’ve created and deployed a Web site, but how do you customize it?

Customizing your Azure Web Site

The Azure Web site you created has a Dashboard view, where you can see a number of key metrics. Towards the bottom right, you can see a set of commands under the quick glance category. One of the these commands is the Download publish profile link, which surprisingly downloads the publish profile for your Azure Web site. This publish profile is in essence an XML file that contains information about your subscription, methods of deployment, deployment URL, and so on. You can open the file in Notepad if you’re curious and want to explore it.

Save the publish profile to a convenient folder, because you’ll need it in the next step.

To customize your site, we’re going to open up Visual Studio and create a new Provider-Hosted Application, which contains a simple ASP.NET Web app by default.

• Open Visual Studio 2012 (as Administrator)
• Click New Project
• Select Office/SharePoint, Apps, App for SharePoint 2013, and provide a name (e.g. GetSPInfoApp)
• Click OK

When prompted by the New app for SharePoint dialog, add the O365 SharePoint site you’re using, and select Provider-hosted in the drop-down list as per the image below.

You’re now prompted to either use a client secret or a certificate. Select the “Use a client secret” option and click Finish.

Visual Studio creates the project structure (with two projects, one for the SharePoint App and the other for the ASP.NET App we’ll deploy to Azure) for you and by default creates an ASP.NET app with some code-spit in place. On first pass, let’s keep things really simple. Add some text on the Default.aspx page as per the snippet below.

…

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
   <h2>Simple Azure Test Page.</h2>
    </div>
    </form>
</body>
</html>

If you were to deploy your app now, you’d get an error similar to the below.

And this is because you have OAuth code specific to SharePoint (see below) that raises an error if loaded only in the context of Azure. This code uses a class called the TokenHelper class, which manages the app and event authentication. So, comment this out for now; you can return to it later.

…

protected void Page_Load(object sender, EventArgs e)
        {

            var contextToken = TokenHelper.GetContextTokenFromRequest(Page.Request);
            var hostWeb = Page.Request["SPHostUrl"];

            using (var clientContext = TokenHelper.GetClientContextWithContextToken(hostWeb, contextToken, Request.Url.Authority))
            {
                clientContext.Load(clientContext.Web, web => web.Title);
                clientContext.ExecuteQuery();
                Response.Write(clientContext.Web.Title);
            }
        }

…

Now let’s deploy the Web app to Azure by right-clicking the Web project and selecting Publish. Here is where you’ll import your Azure publish profile by clicking the Import button, browsing to your publish profile and then clicking OK. You should see something similar to the below after this point, so click Publish to publish the simple web site to Azure.

When your Web app finishes deploying, you should see something similar to the below.

At this point, you have a working app that’s been deployed to Azure, but you need to deploy this as a Provider-hosted app to SharePoint. And you’ve already got the project structure in place, so what’s next?

Deploying Provider-Hosted App to SharePoint

If you remember, you opted to use the client secret to configure your Provider-hosted app. This is a key that both the SharePoint app and the app deployed to Azure need to be aware of, so we need to first get a client secret and then add it to the appropriate spots in our project to ensure our Provider-hosted app will work properly. To do this:

• Navigate to your SharePoint Online site (where you’ll be deploying your app)
• Navigate to /_layouts/15/appregnew.aspx">https://<your site>/_layouts/15/appregnew.aspx
• Click Generate for the ID and for the Secret
• Add a Title for your Provider-hosted App
• Add the domain (this is the Azure domain)
• Add the Redirect URI (again, using the Azure URI)
• Click Create

Now copy the App Id into your AppManifest.xml file in your Visual Studio project. To do this, right-click the AppManifest.xml file and select View Code. Add the App Id into the ClientId property as per the bolded snippet below. Also, you can amend the StartPage property to point to your Azure Web site.

<?xml version="1.0" encoding="utf-8" ?>
…
  <Properties>
    <Title>GetSPInfoApp</Title>
    <StartPage>http://mycrazycool.azurewebsites.net/Pages/Default.aspx?{StandardTokens}</StartPage>
  </Properties>

  <AppPrincipal>
    <RemoteWebApplication ClientId="a3bdddd6-85a1-4f89-abd3-754dddddd94a" />
  </AppPrincipal>
</App>

In the Web.config file for your Web app, you’ll also need to add both the App Id and App Secret (also called the ClientID and ClientSecret) as per below.

…

<appSettings>
  <add key="ClientId" value="a3bdddd6-85a1-4f89-abd3-754dddddd94a" />
  <add key="ClientSecret" value="Jkme+Svgx3K999999999999999zmmGmI1C7WPiiKbGU=" />
</appSettings>

…

Before we deploy, we need to ensure we’ve set the permissions on the App so it can interact with SharePoint. Right-click AppManifest.xml and select View Designer. In the Permissions tab, select Web as the Scope and FullControl as the Permission.

Hit F6 to build.

At this point, you can either publish (which packages up the files for manual deployment) or you can hit F5 to debug.

To publish the Provider-hosted app, right-click the App project and select Publish. Add a name for your profile. Click Next.

Add your Azure web site, the Client ID and the Client Secret to your app.

Click Next, and inspect the summary dialog to ensure all of the information is accurate. Click Finish to complete the process, and you’ll see all of your packaged files.

To debug, simply hit F5. Click Yes if prompted to accept and install a certificate, and then when prompted click Trust It to trust your new Provider-hosted App.

When you trust the app, it will then load for you as per the below image.

If you explore the URL, you’ll see that it points off to your Azure web site, but loads that into your SharePoint site as a Provider-hosted App.

http://mycrazycool.azurewebsites.net/Pages/Default.aspx?SPHostUrl=https%3A%2F%2Fmydemosite%2Esharepoint%2Ecom%2Fsites%2Fspc&SPLanguage=en%2DUS&SPClientTag=0&SPProductNumber=15%2E0%2E4454%2E1011

This was the first step. In Part 2, I’ll swap out some of the simple code-behind, and we’ll see how we can interact with SharePoint remotely from Azure.

Happy Coding!

Steve

http://www.amazon.com/Beginning-SharePoint-2013-Development-Steve/dp/1118495845

The cover page has been designed with a view I know well: looking out over the wing of a plane.

As the title suggests, it’s all about starting development on SharePoint 2013.  As you may have read or heard there is quite a bit of new stuff for developers in 2013 and this book aims to serve as a guide for those looking to grapple with those changes. Topics include the new Cloud-hosted app model, developer tools, Windows Azure, building and packaging apps, publishing in the Office Store, OAuth, OData/REST APIs, Office Apps, event receivers, Business Connectivity Services, Office Services & Workflow, and more.

Well, we hope you enjoy and look out for me to extend the book by writing more Cloud-hosted app blog posts here and at Donovan’s and Chris’s blogs.

Happy Coding!

Steve

As a summary, there are six main things that need to be created for you to get started.

1. Create a new Office 365 Account (http://msdn.microsoft.com/en-US/office/apps);
2. Download and install Visual Studio 2012 Professional or above (http://www.microsoft.com/visualstudio/eng/downloads#d-professional);
3. Download and install Office and SharePoint Developer Preview Tools for Visual Studio 2012 (http://msdn.microsoft.com/en-US/office/apps/fp123627);
4. Create a new Azure account (www.microsoft.com/windowsazure);
5. Download and install the Windows Azure SDK and Tools for Visual Studio (http://www.windowsazure.com/en-us/develop/net/); and
6. Create a new Developer Site within your Office 365 Account.

After you’ve done all of these, you’ll be ready to build either SharePoint Autohosted apps or Provider-hosted apps—the two new types of Cloud-hosted apps for SharePoint 2013 (specifically SharePoint Online as autohosted apps are not supported in SharePoint 2013 on-premises). Of note is that setting up your own Azure account and SDK/Tools for Azure is primarily for Provider-hosted apps. I would recommend installing it, though, even if you think you’ll just be testing out Autohosted apps; there’s lots to explore there. (If you have questions about the Apps for Office and SharePoint, go here: http://msdn.microsoft.com/en-us/library/office/apps/jj613790.aspx.)

To follow are some details on the above six things.

1. Sign up for an Office 365 Account

Before you can develop for Office 365 (O365), you need to ensure you have an account against which you can build, remotely debug and deploy your apps. To get started, go to dev.office.com (which redirects to http://msdn.microsoft.com/en-US/office/apps). You can see by the landing page below that you can click the Start tile to sign up for a trial Office 365 account.

After you click the Start tile, you’ll be taken to a page with a number of options. Click the Sign up for an Office 365 Developer Site “Sign Up” button. This invokes a wizard that you can walk through to generate your new Office 365 site. The Developer Site is key for you to build Cloud-hosted apps because this site is equipped with the ability for you to quickly deploy and remotely debug Cloud-hosted apps.

After you click the Sign up button and fill in all of the fields, click the “Create my account” button at the bottom of the page.

At this point, the provisioning process begins and your Office 365 tenancy is created for you. Some parts of the tenancy (e.g. Identity Service and Portal) are provisioned very quickly, and others take a little time. While this is happening, you can go to Step 2.

2. Install Visual Studio 2012 Professional or Above

You’ll need to install the Visual Studio 2012 Professional or above tools. You can download a trial version (http://www.microsoft.com/visualstudio/eng/downloads#d-professional) or buy a new version. You can click the Visual Studio Professional 2012 90-day trial – English “Install now” link to get that process started. This is a standard VS set-up, so I won’t go into detail here.

3. Install Office and SharePoint Developer Tools

Once you’ve installed VS, you’ll now need to install the SharePoint Developer Tools so you can build Cloud-hosted apps for Office 365. Now it’s not that the Professional SKU doesn’t come with SharePoint tooling; it’s that you need to download the “Apps” templates (i.e. Apps for Office and Apps for SharePoint) templates separately. To do this, go here: http://msdn.microsoft.com/en-US/office/apps/fp123627. And then click the “Download the tools” link. This will invoke an EXE, which you can choose to “Run” or “Save As” for local execution. The application that is invoked is the Web Platform Installer (which enables you to select and install multiple applications), which should prompt you to Install the Office and SharePoint Preview Developer Tools. Click Install and follow the wizard to accept the license and install.

4 & 5. Sign up for an Azure Account & Download the Azure SDK/Tools

At this point, you’ve installed VS and the Office and SharePoint Developer tools, but you still need to sign up for an Azure account and install the Azure Developer Tools and SDK. You can go to www.microsoft.com/windowsazure for both of these. To sign up for a trial account, click the “try it free” button. Complete the wizard to get an Azure instance up and running. Note that when you’re complete, you can go back to www.microsoft.com/windowsazure and then click PORTAL to take you to your Windows Azure developer portal. To install the SDK, go here: http://www.windowsazure.com/en-us/develop/net/. Click the “install the sdk” link. The SDK will install the VS project templates and SDK for your use.

6. Create a Developer Site

At this point, you can go back to Step 1 to see if your O365 tenancy is set up yet. If it is, you should see “No Issues” beside each of the parts of your O365 site (see below).

Awesomeness. You can now go to your O365 tenancy and create a new SharePoint developer site. While in your new O365 tenancy, click the Admin drop-down list and then select SharePoint.

In the SharePoint Admin Center, in the Site Collection tab, click New and then select Private Site Collection. Complete the fields, and be sure to select the Developer Site.

After your Developer Site has been created, it’ll show up in the list of your site collections. Click the link to invoke the Properties dialog for that site, and then click the link to open it in a new browser tab. As you can see from the site below, my new Developer Site (called New Dev Site) is ready to go.

I have and will continue to build out a number of blogs on Autohosted and Provider-hosted apps, so for next steps (e.g. building a simple Autohosted app), go here: http://blogs.msdn.com/b/steve_fox/. Also, if you’re looking for some sample code apps built by the product group, then go here: http://code.msdn.microsoft.com/officeapps. Filter on SharePoint 2013, and you’ll find a small set of apps that will get you started.

Happy Coding!

Steve

Wow, a whirlwind week in Vegas meeting with customers, colleagues, the community and of course conference-goers. If you didn’t catch the conference, last week was the SharePoint Conference 2012. It was a great week full of new areas for the SharePoint community to explore. For me, it was especially interesting as this conference brought together two keen areas of focus for me into focus: SharePoint and Windows Azure. This intersection manifested through the introduction of the new SharePoint cloud-hosted app model to the SharePoint community, and it is here where you really find these two platforms intersecting.

It started with the keynote, which was headlined by Jeff Teper, top brass in Office, who with the help of the SharePoint gang showed off some of the new Social, Mobile and Cloud-centric aspects of SharePoint 2013. To the theme above, it was also good to see Scott Guthrie there as well—introducing the 10,000-ish people to the cloud developer story. The discussion and buzz around this new app model continued throughout the week with many questions focusing on the what and how of these new apps. 

Discussing Autohosted and Provider-Hosted…

Having spent some time in this area, I had the chance to present a session on the topic as well as deliver a post-con workshop to a group of very enthusiastic developers with tons of questions about the new cloud app model. I’ve posted my deck below here so for those that couldn’t attend, you can peruse the deck and at least get a sense for what we were discussing—which focused on the Autohosted app and the Provider-Hosted app. These are in essence the two new app models introduced in SharePoint 2013 having strong integration with Windows Azure.

The Autohosted app model natively leverages Windows Azure when you deploy the app to SharePoint, and the Provider-Hosted app enables you to use Windows Azure or other Web technologies (such as PhP). Now one of the questions that kept coming up this week was as follows: “if they both use Windows Azure, then what is the difference between the two?” And this is where things get interesting.

Both hosting models are intended to move code off of the server; this is part of the reason for the move to a new cloud-hosted model. For you SharePoint admins out there, this should make you happy—this abstraction of code away from the server should mitigate ill-performing or malicious code from running on the server. However, this is only part of the reason. The other part is in the new world of Cloud computing, services are rolled out in a more frequent cadence. And at the same time you’re introducing value to the customer through the ability to leverage services that constantly improve and evolve over time (and in a much shorter cycle), you don’t want those updates to cross-sect with your customizations. Updates should be seamless, and abstracting the code from the server helps support this process.

Okay, so we’ve moved off of the server into these two models. You still haven’t answered how they’re different? And the Autohosted and Provider-hosted models are different in a number of ways:

1. The Autohosted app model leverages Windows Azure natively, so when you create the app and deploy it to Office 365 the Web app components and database are using the Windows Azure Web role and Windows Azure SQL Database under the covers. This is good because it’s automatic and managed for you—although you do need to ensure you programmatically manage the cross-domain OAuth when hooking up events or data queries/calls into SharePoint. So, top-level points of differentiation: 1) the Autohosted app model uses the Web Sites and SQL Database services of Windows Azure, and 2) it is deployed to Windows Azure (and of course to the SharePoint site that is hosting the app). If you’re building departmental apps or light data-driven apps, the Autohosted option is good. And there are patterns to use if you want to replace the default ASP.NET Web project with, say, an ASP.NET MVC4 Web project to take advantage of the MVVM application programming.
2. The Provider-hosted app model supports programming against a much broader set of Windows Azure features—mainly because you are managing the hosting of this type of app so you can tap into, say, Cloud Services, Web Sites, Media Services, BLOB Storage, and so on. (And if these concepts are new to you, then check out the Windows Azure home page here.) Also, while the Autohosted app model tightly couples Windows Azure and SharePoint within a project and an APP that is built from it, the Provider-hosted app provides for a much more loosely-coupled experience. And as I mentioned earlier, this broader experience of self-hosting means that you can also use other Web technologies within the Provider-hosted app.

So, let’s spend a little time in this post on the Autohosted app model, and then I’ll return in a follow-up post with the Provider-hosted app model.

Building your first Autohosted App…

First, open up Visual Studio 2012 and click File, New Project. Select Office/SharePoint, and then select Apps and then App for SharePoint 2013. Provide a name for the app and click OK.

When prompted in the New app for SharePoint dialog, leave the default name for the app, select your O365 tenancy and then select Autohosted as the project type. Click Finish when done.

Visual Studio creates two projects for you: a SharePoint app project and a Web project. Right-click the project and select Add, Class. Call the class Sales, and then add the bolded code below. This is a simple class with three properties: an ID, a Quarter (which represents a fiscal quarter), and TotalSales (representing the total sales for that quarter).

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace MyFirstAutohostedAppWeb
{
    public class Sales
    {
        public int ID { get; set; }
        public string Quarter { get; set; }
        public string TotalSales { get; set; }
    }
}

Then double-click the Default.aspx page and replace the <form> element contents with the following bolded code. This provides you with a GridView object, to which you will bind some in-memory data, and a LinkButton, which will trigger the binding.

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="MyFirstAutohostedAppWeb.Pages.Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<body>
    <form id="form1" runat="server">
        <div>
            <p style="font-family: calibri">Simple Autohosted Sales App</p>
            <asp:GridView ID="salesGridView" runat="server" CellPadding="4" Font-Names="Calibri" Font-Size="Small" ForeColor="#333333" GridLines="None">
                <AlternatingRowStyle BackColor="White" ForeColor="#284775" />
                <EditRowStyle BackColor="#999999" />
                <FooterStyle BackColor="#5D7B9D" Font-Bold="True" ForeColor="White" />
                <HeaderStyle BackColor="#5D7B9D" Font-Bold="True" ForeColor="White" />
                <PagerStyle BackColor="#284775" ForeColor="White" HorizontalAlign="Center" />
                <RowStyle BackColor="#F7F6F3" ForeColor="#333333" />
                <SelectedRowStyle BackColor="#E2DED6" Font-Bold="True" ForeColor="#333333" />
                <SortedAscendingCellStyle BackColor="#E9E7E2" />
                <SortedAscendingHeaderStyle BackColor="#506C8C" />
                <SortedDescendingCellStyle BackColor="#FFFDF8" />
                <SortedDescendingHeaderStyle BackColor="#6F8DAE" />
            </asp:GridView>
            <br />
            <asp:LinkButton ID="lnkGetSalesData" runat="server" Font-Names="Calibri" Font-Size="Small" OnClick="lnkGetSalesData_Click">Get Sales</asp:LinkButton>
        </div>
    </form>
</body>
</html>

Right-click the Default.aspx page and in the code-behind file (Default.aspx.cs), amend the file as per the bolded code below. You’ll see a List collection here, the object you’ll use for the binding, a number of key objects that are used by OAuth to generate the access token for the app and some simple logic to create an in-memory data object and bind it to the GridView.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace MyFirstAutohostedAppWeb.Pages
{
    public partial class Default : System.Web.UI.Page
    {
       List<Sales> mySalesData = new List<Sales>();
        SharePointContextToken contextToken;
        string accessToken;
        Uri sharepointUrl;

        protected void Page_Load(object sender, EventArgs e)
        {
            TokenHelper.TrustAllCertificates();
            string contextTokenString = TokenHelper.GetContextTokenFromRequest(Request);

            if (contextTokenString != null)
            {
                contextToken = TokenHelper.ReadAndValidateContextToken(contextTokenString, Request.Url.Authority);
                sharepointUrl = new Uri(Request.QueryString["SPHostUrl"]);
                accessToken = TokenHelper.GetAccessToken(contextToken, sharepointUrl.Authority).AccessToken;
                lnkGetSalesData.CommandArgument = accessToken;
            }

        }

        protected void lnkGetSalesData_Click(object sender, EventArgs e)
        {
            string accessToken = ((LinkButton)sender).CommandArgument;

            if (IsPostBack)
            {
                sharepointUrl = new Uri(Request.QueryString["SPHostUrl"]);
            }

            Sales FY11 = new Sales();
            Sales FY12 = new Sales();
            Sales FY13 = new Sales();

            FY11.ID = 1;
            FY11.Quarter = "FY11";
            FY11.TotalSales = "$2,002,102.00";
            mySalesData.Add(FY11);

            FY12.ID = 2;
            FY12.Quarter = "FY12";
            FY12.TotalSales = "$2,500,201.00";
            mySalesData.Add(FY12);

            FY13.ID = 3;
            FY13.Quarter = "FY13";
            FY13.TotalSales = "$2,902,211.00";
            mySalesData.Add(FY13);

            salesGridView.DataSource = mySalesData;
            salesGridView.DataBind();
        }
    }
}

When you’re done, hit F6 and build the app. Then, double-click the AppManifest.xml file to open the designer, click the Permissions tab and set the Web scope to have Read permissions.

At this point, you can right-click and Deploy (and sign into your tenancy to deploy) or right-click and Publish, navigate to your SharePoint site, click new app to deploy, and then upload, click Deploy and then trust your app.

The result should be a deployed app, and when you click it and hit the Get Sales link button, the result should be something fantabulous like the following:

Now if you inspect the URL for this new app, you’ll see something interesting. As per the URL below, you’ll see the GUID for the app, the fact that it’s being hosted in the o365apps.net domain (in Windows Azure), and then you have token(s) and data that are embedded within the URL such as the SPHostUrl, the Language, and so on.

 https://8d81feb6-7cbc-4fd8-b4ef-ade72cb80958.o365apps.net/Pages/Default.aspx?SPHostUrl=https%3A%2F%2Fmyspsite%2Esharepoint%2Ecom%2Fsites%2Fspc&SPLanguage=en%2DUS&SPClientTag=0&SPProductNumber=15%2E0%2E4433%2E1003

So, congrats if this was your first Autohosted app you built. It was a relatively simple one, but in time you’ll build some interesting apps that leverage more complex patterns. You can download the code from here. (Open the project, click the App project and then change the SharePoint Site URL to point to your SharePoint Online site before you build and deploy.)

For those that want to do more, there’s also a great sample from the SDK that illustrates OAuth and OData, which you can find here. Nice walkthrough that actually works without any rework save for changing the site property because it uses an existing hidden list.

Well, that’s it for today. More to come on the Provider-hosted app model soon.

Happy coding!

Steve