//Build 2018 – day 1 – Keynote part 1

Not for the first time (and hopefully not the last Smile) I was a happy participant at Microsoft’s annual Build conference – you know, the conference called “Christmas in May for Microsoft developers”. I started the participation on these conferences a long time ago – to be specific, I was there when .NET was announced, or was there when WPF was christened – yes, they weren’t touted as ‘Build’, rather ‘Professional Developer Conference’, but close enough. Later, was part of ‘TechReady’, the internal Microsoft conferences tailored for the ‘field’ part of Microsoft, but nevertheless similar to Build/PDC, and been participating/presenting on TechEd as well.

After this short intro, what do I think about the 2018 Build? It’s different and it’s the same. The same energy was there – save for the keynote, but more about that later – many of the same presenters (sometimes about a completely new topic), same and new friends to meet. Why it’s different? Because it’s no longer the same company, not even the same company compared to a year ago. With some more execs leaving from the ‘old’, ‘Ballmer’ era, now the company can completely tear off the old wounds, and can change trajectory; although they are little like the Titanic (hopefully not by hitting the iceberg, rather than the way how it’s hard to change direction), so there are areas which are slower to understand – everything has changed.

It started for MVPs and RDs a day earlier – I’m neither of that –, but this meant good news for Oren Novotny, my old friend and ex-mate – not only his project (RX.NET) got moved to the .NET Foundation (becoming https://github.com/dotnet/reactive), was he appointed to join the Microsoft Regional Director program, but he was also honored to become the Ninja Cat of the Year! Btw, do you know where Ninja Cat is coming from? Originally it was featured in an internal powerpoint deck about Windows 10, and quickly became the logo to celebrate and symbolize the passion and energy of the people behind code. Unofficially, it represents the spirit of Microsoft employees. Officially, the award, one of the 2018 Windows Developer Awards decided by voting, recognizes the Developer (with capital D), who demonstrates the core values of Microsoft the best and made one or more significant contributions to Windows development in the past year. So, Oren ‘NinjaCat’ Novotny – congratulations! Well Done!

So, on day 1, as I was standing in the registration line (one of the first in line), I tried to summarize my expectations for the conference and for the announcements. As Morgan Stanley is heavily involved in the early discussions for many of the products (whether that is the next version of .NET, .NET Core, Azure, Azure Stack, etc.), many of the announcements coming up I was already aware, or in some cases, already played with. So I was more to look forward meeting with some of the industry leaders, meeting with the product groups, meeting with the decision makers and to learn more broader term next steps the industry and Microsoft is going to take. It also gave me a thrill – for the first time ever, I wasn’t only to enter the Build conference – I was to also visit ‘MRJam’, a ‘semi secret’ Mixed Reality subconference, also by Microsoft, on the same premise. What did I expect from MRJam? As being the first one of the kind, did not had any special expectations, just being able to see other people doing development for mixed reality headsets and the HoloLens (I’m the latter) and to listen some sessions seemed to be adequate – however it turned out to be something significantly better. More about that later Smile

Freshly registered we lined up for the keynote – I had to admit the registration experience was significantly more organized than last time (that was a mess in a small room, now it was a 5x as big room with 3x as many registration stations AND the swag handling (t-shirts only) was done in a separate section), we could walk next to the expo and a newly designed, much bigger, better Channel9 area.

While walking down the fenced corridors, could not avoid spotting Seth Juarez preparing for his opening Channel9 remarks – not a small feat to do to cold open a 3 day conference AND prepare for 3 straight day of talking to people – haven’t seen the Channel9 stage empty during the days Smile Btw, could not avoid spotting, beard became now the new norm Smile 

We definitely weren’t alone. I haven’t seen an official tally yet, but based on what I saw on the various sessions, in the lunch room, etc., I guess 7.000 people – don’t quote me on that, I might be absolutely crazily completely off with that.


The line of announcements started meanwhile standing outside, if you had an open ear to the Channel9 recording booth, started with – Windows 10 1803 ISOs showed up on the Microsoft Volume License Center’s website (with its hopping 4382 MB to download)! Also, we all knew for sure that we would be Hanselmanned sooner or later, but he did actually show up shortly before the keynote with many ‘aaah’ and ‘oooh’ Smile


Than the show began! Same as last time, I was sitting next to the Press area, just to slightly right from it, Mary Jo, Thurrott sitting just a few feet from me – this has to be a good seat Smile with tongue out


The opening words were new in so many ways. Yes, we have had opening words delivered at Connect 2016 by no other than Stephen Hawking, and many other amazing scientists, but this time, it came from Charlotte Yarkoni about Project Emma, a wearable device which we saw as a prototype a year ago. It’s to help those patients, who are suffering from Parkinson’s – Emma herself got the disease at age 29, and being someone talented with wonderful ideas (being a designed and a creative director) she was afraid the diagnosis might end her career. With the new Emma watch, she is able to live a full life, and can have her wonderful ideas being fleshed out by herself.

And here starts the list of endless announcements! Visual Studio 2017 15.7 (actually now we have 15.7.1 due to a last minute security bugfix, so make sure you grabbed the newer version) with C# 7.3 with enum/delegate constraints, ref reassignment, stackalloc, unpinned fixed buffer indexing, custom fixed, and many more; and with asp.net core to noncontainer app service Linux publishing, codelens unit testing, responsive testing icons, step back for .net core, github auth for sourcelink, javascript debugging for Edge (this is big!), XF editor intellisence (also big!), VSM for UWP (another biggy!), signed Nuget support, and many more. Many of these are thanks to the Developer Advocates – Donovan Brown, Seth Juarez and many more. And, Visual Studio for Mac 7.5 (why they cannot share versioning, sigh?) with Razor for ASP.Net, TypeScript and JavaScript for web, wifi debugging for iOS, Android SDK manager for Android, .editorconfig support, and more! Lastly, on this topic, Microsoft brings its Visual Studio App Center lifecycle management tool for iOS, Android, Windows, macOS developers to the GitHub marketplace.

The actual opening notes from Satya Nadella made me googling/binging quickly – why does Bill Gates speak about Apple stock prices? Yes, I wasn’t following what exactly Warren Buffet said about stock prices, and wasn’t sure others were following him either – lost me a little bit there. And if your cold open is not hitting the right vibes, you start to feel out of blues… Back to announcement mode, two new mixed reality business applications announced, layout and remote assist. As the name implies, it is showing two common usecase – layouting physical objects over real world, and providing real 3D, context sensitive help when needed using a mixture of devices – I actually have had the ability to try out an earlier implementation of the latter by a company called Kazendi where they showcased their holomeeting product. We got another reason for using Visual Studio Code – Sort JSON Objects addin for sorting both your objects and your settings. Announcement of Microsoft’s own content delivery network (CDN) – this time again Microsoft is trying to get into a rather busy field, although with the promise of a rather big number of EDGE sites this might be more promising than it sounds (50ms on average in 60 countries with 54 edge pops in 33 countries + 16 cache pops); although I don’t see this as an imminent threat to akamai, cloudfront, cloudflare, level 3, etc.

We went a little hardware and IoT Edge from here (so many edges Microsoft have now Winking smile), so when you were thinking (for a good reason actually) that Microsoft XBox Kinect is dead – here is Kinect for Azure. A hardware solution not insimilar to the one in the next HoloLens in 2019, with depth sensor resolution bumped up to 1024×1024 from 640×480. As Microsoft did give a Kinect to each developer at a previous Build, many developers who weren’t really into gaming figured out, that with the ‘Kinect for Windows’ SDK, many amazing industrial solutions can be made – this is what lead to the fourth reinvention of Kinect into this small devices that can be fit along with other IoT solutions. To be honest, I can already see some amazing mixed reality projects forming in my mind. News about IoT is not ended: IoT Edge itself got opensourced, along with an AI Developer Kit for Cameras from Qualcomm and a Drone SDK from DJI, demonstrated by flying an actual drone in the keynote recognizing flaws on the pipes on stage. This is actually enabled by many updated cognitive services, some of them are part of Azure IoT Edge, enabling you to train in the cloud but run on the device enabling blazingly fast decisions while being superiorly precise at the same time. Already at Azure, did you know about the new Terraform resource provider? This would enable you to write an ARM template that creates a Kubernetes Cluster on Azure Container Services (AKS), and then, via the Terraform OSS provider, Kubernetes resources such as pods, services and secrets can be created as dependent resources. Also, geo replication for Azure Container Registry with ACR Build, to enable easier OS and framework patching with Docker. Also – actually pretty slick way to enable/disable – Azure SignalR with literally half line of code change (AddSignalR –> AddAzureSignalR), moving SignalR connectivity to Azure Edge using a fully managed service.

This next one is big: Microsoft is changing the revenue mix. App developers now going to get 85% instead of 70%, and going to get 95% if you get redirected from the developer website to the store. Would this be enough to be a gamechanger? Would this result in a landslide? Very hard to tell, when looking at this number I don’t feel little, but I feel late. Back to User Interfaces – XAML Islands are coming up (enabling the use of Edge WebView in the earlier tech)! These enable you to host UWP content in your Winforms or WPF applications – who said that Winforms/WPF is dead? Actually, everyone said it.

But if, we are already at WPF/Winforms – next to announcing .NET Core 2.1 RC1 (which contains a performance related PR and a Linux compatibility PR from me!), an important announcement of .NET Core 3.0 is also there – with the ability to run Winforms and WPF on top of .NET Core 3.0, giving it side-by-side ability and probably opening the way of them becoming opensource. And actually, clippy can help you code it. Not kidding, IntelliCode is trying to become the clippy of development and provide AI assisted capabilities by not just better contextual intellisense and focused PR reviews, but in the future actually trying to compare your source code to other source codes and trying to point out if you used the wrong variable in a line.

When it came to AI again, Microsoft showed all the breakthrough we had in AI in the short past – Vision test with object recognition parity in 2016, Speech recognition test parity in 2017, Reading comprehension parity in 2018 January, and Machine translation parity in 2018 March. But where it becomes scary, is at things like Project Brainwave, an Intel FPGA solution enabling superior and never before seen acceleration for real time AI while being cost effective and efficient.



When it comes to AI, one of the topics always brought up are bots & intelligent assistants. We got used to frozen hells by now – and looks like the previously announced Cortana-Alexa partnership is actually going to happen, although I found it quite awkward that I explicitly had to sign in/out of them. One of the biggest applause of the keynote was a rather unexplainable moment – one of the canned responses of Alexa about Cortana. Another very  good example for the kind of thinking about AI came up than, as part of a mega Microsoft 365 demo with an ASL interpreter included – we had a sense what is coming up, but it was still groundbreaking how easily the machine was able to transcribe not only what was spoken but also who spoke and what was the call-to-action. We saw integration with HoloLens, integration with LUIS, integration with Surface Hub, etc. – if only my workspace would look like this Open-mouthed smile 


I’ll continue after the break – we actually had a break with a little gym exercise included Smile Open-mouthed smile Smile with tongue out


DevOps 2.0 – Beyond the Buzzword

A few days ago, I participated in the DevOps 2.0 – Beyond the Buzzword session hosted in the Microsoft building. The event was sponsored by Neudesic, Microsoft, and Docker. It differed from the DevOps 1.0 session, which was sponsored by Neudesic and Amazon in the sense that it focused little (actually not that much) on Microsoft technologies (like Azure). The presentations contained a lot of interactive forums and Q&A, and was presented by Mike Graff, Kunaal Kapoor, Chad Cook, Eric Stoltze and Chad Thomas, all from Neudesic.


The agenda consisted of four major sections; “DevOps in Review”, “Building the Continuous Delivery Culture”, “Automating the Secure Enterprise” and “Modernizing Legacy Apps”.


Starting with basic questions – Is your org implementing DevOps, Is your org using the cloud, What did you come to learn today – we quickly set the stage, and the sessions started. There was one axiom I really did not agree with, especially as someone in a team dealing with R&D and participating in Morgan Stanley's Innovation program – “You cannot innovate and standardize at the same time”. I’m happy to challenge this 🙂


In the digital age, it will not be the big who eat the small, it will be the fast that eat the slow!


The questions and discussions in the session mostly focused on why and how we do continuous delivery and DevOps. We looked at Finance 101 – Net Present Value (NPV) = cashflowin/(1+r)^t-cashflowout (where r is the cost of money and t is time), and discussed how DevOps can help change each of these variables. We alsp looked into basic Return On Investment (ROI) calculations, to see how DevOps can change it to the benefits. We discussed how we see opportunity costs (the benefit that could have been realized, but was given up, by choosing another course of action) and the cost of delay (a twist on opportunity cost that combines urgency and value).


By the way, did you know that in the average industry, 60-90% of required features for a product produce zero or negative value (like non-automatic hygiene)? This even applies to giants like Google or Microsoft, so they are not specific to company size or industry.


So, why do we practice continuous delivery and DevOps? The keywords are:

  • Faster Delivery – High Performing teams deliver software 20 times more often with 200% better lead time; this nicely binds into the Continious Delivery and Deployment agenda
  • Safer Delivery – High Performing teams have 48 times lower MTTR and 3 times lower change failure rate; this is something that binds into the blue/green agenda
  • More Efficient – High performing teams spend half as much time on rework and three times as much time on new work
  • Better Security – High performing teams have a 50% reduction in security related incidents
  • Improved Satisfaction – Teams adopting CD / DevOps doubled their internal net promoter score and had tripled their customer net promoter score
  • Increased Profitability – Organizations practicing CD / DevOps are 26% more profitable than traditional divisions


The three ways to achieve the DevOps nirvana according to the discussions are: flow, feedback and experiment.


How to work with Flow?


  • Make Work Visible
  • Limit Work-in-Process/Progress
  • Reduce Batch Size
  • Reduce Handoffs
  • Identify and Elevate Constraints
  • Eliminate Hardships and Waste


The first two items are part of most teams’ Kanban implementations, so I won’t spend extra characters on them. Making problems more bite size does help maintaining a healthier throughput, and helps ironing out the bumps in the road when an item has a wrong T-shirt size assigned. Handoffs – each time you are doing a handoff, you are literally losing track of it and automatically building a queue. Try to limit the number of handoffs through automation, by using commodity components. The last two items are in some way obvious ones; although sometimes we tend to be delivering features faster than having time to recognize that we are delivering under constraints or that we create unnecessary waste.


When it comes to Feedback, we can look into ways to:


  • Work Safely in a Complex System
  • See Problems as They Occur
  • Swarm and Solve Problems to Build Knowledge
  • Keep Pushing Quality Close to the Source
  • Enable Optimization for Downstream


How many times have you felt unsafe in a system or system’s admin UI you had to interact with, and didn’t know what the next click or swipe would result? Whether there is going to be another ‘are you sure?’ question, or have you just been able to render your environment unusable? Or checking out this question from the other side – are you monitoring the right thing? Do you understand what needs to be done when the alert comes? Is it coming through a system that is able to target them correctly? No one wants to be the target of a blastmail to 500+ people with a multi megabyte attachment trying to figure out which items are relevant; neither had you wanted to get notifications tailored to you but not mentioning any of the action items to be taken. And when an issue happens, what should be the steps followed? Yes, in short term, it’s “cheaper” to have a follow the sun support model and have the support person dealing with it, as for sure the support person would “document the steps needed for later reuse” – I never see the latter happening. Whereas, if available people do swarm, the issue might be solved at a higher realized price when it comes to manpower, but the crosspollination happening during the solution is priceless. And – it shouldn’t be a big deal to help the downstream system optimize them instead of building another layer/façade/presystem around it; as the latter would just lead to another piece to maintain in the long term.


Lastly, when it comes to Experiment, we speak of the followings:


  • Enable Continuous Learning
  • Create a Safety Culture
  • Institutionalize Continuous Improvement
  • Transform Local Discoveries to Global Knowledge
  • Inject Resilience into Daily Work
  • Leaders Reinforce Learning Culture


We learn as long as we live. With Pluralsight, Lynda, Harvard reviews and more training tools available there is no real excuse on not taking the proverb to heart. We need to support people taking a leap – looking at Morgan Stanley's Innovation Program for the second time in this one article; this may be one of the best approaches to this problem so far. Continuous improvements shouldn’t stop at writing the software. It should be part of the fabric of the team itself; implementing so called ‘kata’s to improve the process and to seek improvements of day-to-day work is more than desirable. As teams span across multiple locations, it is imperative to host knowledge share sessions, brown bags, post write-ups, and more. We should aim to record as many of these as possible and make available tagged, even sometimes transcribed/minutes written up. And when people should listen to this? Building ‘slack’ time or possibility for slack time into a system, using Pomodoro Technique and gifting yourself experimenting time for successful Pomodoros, etc. might have a bigger benefit than you think. Lastly, such change (if there are changes needed) are most successful if they are reinforced or started by management; or you experience them through mentorship – try to seek for the latter if you don’t feel the former.


Because, yes, DevOps2.0 needs more cultural change then technological ones – for some of the problems in the DevOps space there are off-the-shelf solutions; but to make them successful, the 20% of the technological change needs to be met with the 80% of the cultural change needed. You cannot just introduce a DevOps team between your Dev and Ops teams – that would result in another set of handovers (see above ), and no real benefits.


In a later session, when it came to the question of Security as part of DevOps,


Fewer than 20% of enterprise security architects actively and systematically incorporated information security into their DevOps initiatives (Gartner)


As part of looking into the importance of the enterprise DevOps process, you can look into:


  • Automating Security
  • Empowering Engineering Teams
  • Maintaining Continuous Assurance
  • Setting Up Operational Hygiene
  • Increasing Engineering Autonomy
  • Increasing Availability of Dev Technologies
  • Ensuring Constant Change is the New Norm
  • Leveraging Wide-ranging Operational Responsibilities of DevOps


We have had a long discussion of this, but I think our requirements when it comes to security and the maturity of these solutions might not be aligned to where we are now and where we would like to be in the future.


Lastly, as part of Application Modernization Strategies, we went into discussion of the “6 Re”:


  • Retire – Remove the application or platform completely
  • Replace – Replace the application of platform with new version or competing solution
  • Remediate – Invest in extending the lifeline of the application or platform
  • Re-architect – Redesign the application or platform to meet demands
  • Re-platform – Redesign the application to run on different infrastructure
  • Re-build – Rewrite the application to remove technical debt or change the implementation


The whole day was full of demos, everything from Security Kits through Kubernetes Orchestration to Mobile Crash Analysis, and useful discussions with industry peers. And the best discussion of the day? “How you get around SOX and Segregation of Duties when using DevOps?” – You don’t. Instead of that you educate the audit/regulator and show that the relevant controls and the segregation are still there.

finJS.IO 2017 Fall conference


disclaimer: Morgan Stanley was invited to the event by OpenFin. 


This year I have had the pleasure to represent Morgan Stanley on the finJS.IO NYC conference in midtown. We had an awesome crowd, many friends and former colleges showing up – who could resist such a line up of presenters?


We had OpenFin's own Mazy Dar providing the opening words and giving a heads up on the sessions: Graham Odds from Scott Logic, Fergus Keenan from Adaptive, Terry Thorsen from ChartIQ, Jason Dennis from FactSet, John David Dalton from Microsoft and Mazy himself to present and amuse us.




First we have had FactSet taking the stage, speaking about unbundling, interoperability and data concordance. He showed us what FactSet is and what they do provide – with 14 datacenters, 650 3rd party data sets, 25 of their own content sets, with over 300 exchanges, over 130 news sources, etc the amount of data they have on their fingertips are astonishing. They built their application stack on four pillars – workflows, apps/components, content and technology, with the following bingo board in technology (that being the most relevant for us): HTML5, Node, websockets, angular, vue, http/2, elastic, hadoop, spark, C++, C#, Java, Python, Go, memcached, vmware, nsx, linux, windows, hpc, cdn. Their focus is at 3 steps – survey, pick, implement. Resulting in process on how to normalize content, how to implement workflow. We have to admit – concordance and interoperability is hard. They are excelling in the former – spent 30 years building concordance model on securities, they do understand directives and object symbology needed, etc. They are (next to Morgan Stanley) part of the Financial Desktop Connectivity and Collaboration Consortium (FDC3) to enable financial participants to build solutions that link components and data. When it comes to interoperability on the desktop, they depend on OpenFin and Symphony for local and global messaging bus, and leveraging the power of fins:// for live collaboration in contexts.


Next they talked about how they moved from their WPF only UI to the web and hosting the website built using Angular later React in the WPF container; than stepping another step and moving their application out of the host container and running as a native web app. However seeing the limitations of such approach, they turned backwards again and started using a thick container to host their application, so to enable some of the otherwise unexploited desktop features to their application – like this enabled them proper out of band notifications out of their machine learning platform.




Next presenter was from Adaptive, who spoke about mostly the evolution of trading in the world, starting from 300 BC up till today, touching the 17th, 18th century in the meanwhile. He did speak about where the IT budget of the financial companies are going – from the $127bn annual budget, in 2017 we have had $2.5bn on advanced analytics with a +15% growth, on artificial intelligence $1.5bn with a +14% growth, on robotic process automation $0.5bn with a +10% growth and on cloud computing a $1bn with a +19% growth – all significant numbers and the he made us think about the implications as well.




Next came ChartIQ which spoke about their finsemble application platform, showing frameless browser windows, and showing the analogy we have: windows are the nodes, the communication bus is the network and the microservices are the services when it comes to compare it to distributed systems. Applications are and "ensemble" effort, components that are visible and services that are hidden. What they came up with is a solution based on openfin and their custom architecture. When it comes to synchronizing state, the fact that components can start in various orders needs to be supported by a pub/sub mechanism. When it comes to performance, you have to invest into Chromium's process splintering to avoid unnecessary overhard from Chromium instances; and you have to introduce dependency ordering to avoid startup race condition errors. When it comes to debugging, you need to introduce central mgmt and logging, when it comes to user experience you cannot just have a loose interface (you need to introduce window management like snapping, docking, etc). Lastly, when it comes to aesthetics, and having a heterogeneous set of component interfaces, there isn't a better solution than having a hard word and introducing something along the lines of 'Font Finance' similar to 'Font Awesome', a set of web components that is mandated to be used.


And than there is the tough tail to be fixed – monitor plug/unplug/resolution change, orientation changes, event storms & throttling, working around issues on max server connections to enable features like webpack hot reload, to support hotkeys, to support CORS, to enable proper timer sync (needed for central logging as well!), to support fitting to the DOM when it comes to dynamic height content, to avoid missing mouseout events at the window edges, etc, etc., the list is nearly endless.




Next presenting was Mazy Dar from OpenFin, who talked about the 'bank of the future' and what banks can learn from DropBox. We did see the achievements and development of mobile applications for banks in the last decade, but where is the similar change for the desktop apps? We should get out of band notifications, offline synced information, etc like we had in the '90s, but with today's technology stack and with integration into the builtin desktop services.


Scott Logic


Following was Scott Logic who talked about how to create reactive desktop applications through an example that involved someone doing a two in a refrigerator and immediately regretting this decision  But the presentation was serious, and talked about what we can achieve when trying to do more than just switching between a 'desktop' and a 'mobile' web mode, and did involve some very eye catchy demos of interaction models that adapted themselves based on not just screen size, but rather smaller differences like "how is my container being aligned on the screen". The magic behind is moving a level further than reactive media queries, and – you can do that today, of course with a polyfill ( https://github.com/ausi/cq-prolyfill ) for container queries ( Container Queries ).




The last session was from Microsoft, which was focusing on ecmascript modules ( https://nodejs.org/api/esm.html ) , and the current issues with them – whether it comes to debugging, error reporting, builtin variables, babel, etc all do suffer if you try –experimental-modules today. What was shown by the John wearing a BladeRunnerJS tshirt how https://www.npmjs.com/package/@std/esm is solving all the problems in Node 4+, by not only providing support for mixing common js and mjs, but also to be available in the node REPL (see https://medium.com/web-on-the-edge/es-modules-in-node-today-32cff914e4b for much more details):

$ node

> require("@std/esm")

@std/esm enabled

> import p from "path"


> p.join("hello", "world")



It also enabled to unlock features like dynamic import, live bindings (yes, actual live bindings cross module boundaries), file uri scheme, etc. It also have unambiguous module support, named exports, top level main await, gzipped modules, etc. You could ask what is the performance hit you have to pay? Loading CJS ~0.28 ms/m, built-in ESM ~0.51 ms/m, first @std/esm with no warm cache ~1.56 ms/m, but with warm caches @std/esm cached runs were ~0.54 ms/m. Which means it is nearly the built in performance but with a lot more flexibility, better error reporting, path protocol resolution, environment variables, etc.



To summarize, the whole event with the mingling at the beginning and at the end, also the various presentations were just fantastic 


I was strongly looking forward for Techstravaganza NYC – not just because it’s a New York bound conference, not just because the different tracks focusing on different materials (PowerShell, Windows, Exchange and Azure Cloud), but also because our very own Tome was (as always) one of the organizers and presenters. His session (Anarchists guide to PowerShell – What you’re mom told you not to do with PowerShell and how to do it!) not only won the competition on best title, but I think close to winning the best content award too.

From the 4 available tracks I went with PowerShell – mostly because my knowledge is the lacking there most. From the lineup of strong sessions I picked: “Anarchists guide to PowerShell – What you’re mom told you not to do with PowerShell and how to do it!” by Tome, “Rewriting history: extending and enhancing PowerShell features with fantastic results.” by Kirk Munro and a panel discussion featuring all of the days’ PowerShell speakers.

But not to run forward too much, for me the day was kicked off by Kirk’s rewriting history session. Next to learning where PowerShell’s builtin capabilities trail off and when you need to start touching compiled cmdlets (like proper parameter usage, deriving commands, proxy cmdlets, performance!) we should not forget that PowerShell is now cross platform and opensource – if someone wants to add one of the extensions, they are usually should feel free to do that using github, PRs, etc. To write such a custom cmdlet, you only need your favorite editor (Sapien, VS2017, VSCode – your choice), the Microsoft.PowerShell.*.ReferenceAssemblies for the matching PowerShell version, and some patience 🙂 So with PowerShell 6 just in alpha, being cross platform, what is the better time to learn writing cmdlets than now?

One of the first magic we seen and resonated with me was about something eerily similar to https://github.com/nvbn/thefuck (if you are not aware of that tool, it adds missing sudos, it adds missing –set-upstream to your git command, tries to find out what command you mistyped, and like 50 more – see https://github.com/nvbn/thefuck/blob/master/README.md#how-it-works for details). Using some lesser known command-not-found-handling extension point, it enabled nice shorthands to replace “verb -verbs” constructs with “verb-verb” constructs, and much more.

The next item that caught my attention was LanguagePX – a demonstration of ExcelPX by building a DSL that enabled moving from:

Get-Process | Export-Excel Path "$([Environment]::GetFolderPath('MyDocuments'))\test.xlsx" Force Show AutoFitColumns IncludePivotTable IncludePivotChart PivotRows Name PivotData WorkingSet64



ExcelDocMagic "$([Environment]::GetFolderPath('MyDocuments'))\test.xlsx" {

    Properties {

        Overwrite = $true

        Show = $true

        AutoSize = $true


    PivotData {

        RowPropertyName = 'Name'

        RowAggregateValue = 'WorkingSet64'

        IncludeChart = $true




Turns out this not only caught my eyes – this is on the way to become part of PowerShell 6 to support custom DSL languages thanks to an RFC. This way the option to achieve something that would have been crazy idea before, like generating a Visio document an object oriented way and have PowerShell fill out the data there, all with proper type safety – I’m sold.

Next to tackling capability to fix mistakes and provide nice syntactic sugars, next to provide a way to define DSLs, the 3rd item that surprised me from Kirk was HistoryPX – providing an extended set of history information AND last output support in PowerShell. Not only does it capture output, exception criterias, command duration, but also the number of returned objects! Makes it so much easier to work with history. Add to this the $__ variable capturing last output, with configuration when it should be captured – e.g. I can say I don’t want sort operation to be captured if I don’t want to.

As part of the sponsorship section, I seen Sapien’s IDE for the nth time – but this was actually the first time I spotted the fact that there is support for a splatting refactor in the context menu. Now, how did I live without it??

The next interesting tidbit was coming from Stephen Owen – before his session I was not that much involved (let me rephrase: I had absolutely no overview nor details) in the Enterprise Mobility Management suite’s integration with VMWare AirWatch and PowerShell, but he showed some interesting tidbits on how these component work toghether: either AirWatch sends command to EAS to authenticate, and with the established secure trusted relationship AirWatch can send cmdlets to PowerShell in accordance with the email policies (and it gets executed) (this does not require a server per se), or using the AirWatch Enterprise Integration Service to deliver the PowerShell commands to the server. It was eye opening to see PowerShell used together with VMWare – not two tech/companies I’d put in the same sentence otherwise.

Then came the session I was waiting for since the morning: the anarchist guide on how not to use PowerShell with Tome. Starting with the nice library of ShowUI which enables you to *easily* build graphical user interfaces using PowerShell scripts – to the level of using ‘New-Button -Content "Hello World" -Show’ or:

$User = [ordered]@{

   FirstName = "John"

   LastName = "Doe"

   BirthDate = [DateTime]

   UserName = "JDoe"



Get-Input $User -Show

Next demo was about Azure Functions, PowerShell – with removing the comma between them – small powershell snippets you can use in a serverless scenario provided by Azure Functions to provide stateless microservices. And if microservices, we saw a way using Apache Zookeeper to spin up PowerShell worker processes on incoming data feeds – think about like a distributed zookeeper powershell cluster. And this was the best place I think for a Treadmill shoutout J

And the thing we (I?) weren’t really prepared for – http://www.leeholmes.com/projects/ps_html5/Invoke-PSHtml5.ps1 – I’ll leave you to try it out. And the list continued – a very interesting demo of using Unity (the 3D game engine) and PowerShell together to display data (some of them on a spinning globe) using PSUnity, another crazy language experiment by allowing to write native .NET IL in PowerShell using PSILAsm

The list is endless 🙂




Electron, Win10, UWP

I have been following Microsoft's adventure on HTML5/Javascript based desktop UIs for a while – actually, did participate on the journey while working for Microsoft back in 2003 on a Microsoft POC project codenamed IceFace which was doing something akin of websockets (using a proprietary ActiveX and doing low level TCP from it) and something akin of an HTA application. In the recent years, I was watching when they announced WinRT and one of the programming models being HTML5/Javascript; also watched with awe as they failed to penetrate the world with WinJS Tutorial ; than when UWP enabled using HTML5/Javascript as one of the technologies to use. So when I heard last year they tackle this area again, I didn't have high hopes.


I was wrong. They actually listened to the people – yes, they misinterpreted what they want the first few (?) times, and lost their expected leadership in the desktop app segment (which were quickly eaten into by the HTML5 hybrid applications), but at last they stopped fighting the inevitable.


Why do I say this? Next to the bridges Microsoft announced and later opensourced (centennial for desktop app, the later cancelled bridge for Android applications, the bridges for hosted web applications, for iOS applications and for Silverlight applications) Microsoft sneaked in an announcement: Electron applications for the Windows Store . Using Centennial technologies (so no registry or file system is used, and the application is running on full speed, but still running in a sandbox) you are able to 'compile' your Electron application to a Windows Store AppX (either for the external application store or the internal one). Moreover – using NodeRT (which can be downloaded through npm, and does some crazy magic of generating node.js native addon's C++ code using C# reflection over WinMD manifest files) you are able to access the same WinRT/UWP APIs like any other native application would do – see Showing Native Windows Notifications from Electron Using NodeRT for details.


This easily enabled applications do interaction with the native Windows experience, like setting the lockscreen image from JavaScript (TypeScript):


const {KnownFolders} = require('windows.storage')

const {LockScreen} = require('windows.system.userprofile')

myFolder.getFileAsync('image.jpg', (err, file) => {

  LockScreen.setImageFileAsync(file, (err) => { })



Or popping up a toast using https://github.com/felixrieseberg/electron-windows-notifications :


const appId = 'electron-windows-notifications'

const {ToastNotification} = require('electron-windows-notifications')


let notification = new ToastNotification({

    appId: appId,

    template: `<toast><visual><binding template="ToastText01"><text id="1">%s</text></binding></visual></toast>`,

    strings: ['Hi!']



notification.on('dismissed', () => console.log('Dismissed!'))



So yes, Windows 10 migration for some of the applications and firms might be far ahead, but I think we would be prepared. We are still to see how they will tackle the issues regards Electron security sandbox, but I feel like this time Microsoft might be just naturally doing what was expected from them for a long time, and we can see others stepping into the same direction with getting on the Electron bandwagon.

Sphinx, Pygment, and more

New year, new petprojects. One of them is moving existing documentation in an easier to manage, easier to use format. I looked around what is being used right now internally, and seen many tools from doxygen to sandcastle. One of the tools that caught my attention was sphinx. Being a Python tool, it enables to run on both on Windows and Linux, and looking little more around I found support for VSCode editing – I'm in.


So, what is sphinx? Sphinx is a tool that makes it easy to create intelligent and beautiful documentation, written by Georg Brandl and licensed under the BSD license. It was originally created for the Python documentation, and it has excellent facilities for the documentation of software projects in a range of languages.


So I gave it a try and I ended up setting up something similar to github pages – I send a PR to a particular internal repo, and when it gets merged, it kicks off a build which automatically uploads it as the new content.


Locally I did set up the following in my tasks.json:



    "version": "0.1.0",

    "command": "python",

    "isShellCommand": true,

    "args": [ "sphinx-build", "-b", "html", "-d", "build/doctrees", ".\\src\\sphinx\\source", ".\\doc"],

    "showOutput": "always"



Next thing was to set up my conf.py, I picked a few plugins I was thinking I'd use:


extensions = [




#    'sphinx.ext.autosectionlabel', — this depends on a newer sphinx that I have








I started playing than around with the RST syntax, and very quickly figured out that there is good support for python (not a surprise) in code coloring, but even if I did set .. code:: csharp it wasn't recognizing it.


So time to write my first sphinx plugin, in _ext/csharplexer.py:


def setup(app):

    import pygments

    from pygments.lexers import CSharpLexer

    app.add_lexer('csharp', CSharpLexer())


than I can add 'csharplexer' as an extension.


Next, I started looking making the rendering little nicer – I'll likely have longer listings as part of the code, and I wanted to have a syntax for toggles working. So time for the next extension – toggle. Taking the following source:


.. container:: toggle

    .. container:: header

        **Example to show how to add unitycontainer**

    .. code-block:: csharp


        Assert(true);  // OK

        var i = 1;

        Console.WriteLine("Hello World!");


I could just add _static/custom.css:


.toggle .header {

    display: block;

    clear: both;

    cursor: pointer;




.toggle .header:after {

    content: " ▼";




.toggle .header.open:after {

    content: " ▲";



and _templates/page.html:


{% extends "!page.html" %}


{% set css_files = css_files + ["_static/custom.css"] %}


{% block footer %}

<script type="text/javascript">

    $(document).ready(function() {

        $(".toggle > *").hide();

        $(".toggle .header").show();

        $(".toggle .header").click(function() {






{% endblock %}


Which resulted in something I liked 🙂


Will be continued – next time I'll try to get viewcode working.

32 bit vs 64, revisited (again)

I did post previously about 32 bit vs 64 bit through the magnifying glass of .NET – good news is, that it’s now high time to scrap all those results, and revisit the question. The reason behind is one of the changes between .NET 4.5.2 and 4.6 (and therefore 4.6.1) is the introduction of a new JITter (ryujit) which should result each of us carefully revisiting this question.


But, let’s not go that quick; what the problem is we are trying to solve.


32 bit vs 64 bit


“I’m in .NET, why should I be interested in 32 bit vs 64 bit? Isn’t .NET bit agnostic?”


Yes, .NET itself is agnostic; however some of the libraries and technologies you might use might be not. Think about technologies like: P/Invoke, COM Interop, Unsafe Code, Marshaling, Serialization, Managed CPP, … So, yes, if you happen to have 100% type safe managed code, you can just copy your application from a 32 bit system to a 64 bit system, and it would “just run” successfully under the 64 bit CLR. However, likely you are using some of the technologies just mentioned, so you should do your homework to investigate whether your code is depending on the bit length. Be aware, that unlike C++, .NET only changes size of the pointers (IntPtr) and not the builtin value types (e.g. int is going to stay the same). So moving between 32 and 64 bit world either result in no changes or a set of changes related to pointers, changes related to 3rd party libraries, marshaling, serialization, and more; and you can use System.IntPtr.Size and System.Reflection.Module.GetPEKind to determine the current bitlength and/or querying a deployment assembly for platform affinity.


Why 64 bit? Actually, why 32 bit?


What does 64 bit allows you to? Addressing (not necessary accessing) a bigger chunk of memory. 32 bit applications inherently (because of the pointers they use) are limited into a 2Gb section of the memory, 64 bit applications don’t have this limitation.


So, that means I should just specify I want to have 64 bit, and that’s it? I’d have more memory and would be faster? Actually, not necessarily. 64 bit pointers do occupy more memory. Cache lines in the processor gets evicted more likely. Stack becomes bigger. Your application will likely (mileage might vary) occupy more memory, and there is a chance (mileage will vary) it will perform worse – despite the fact that running on 32 bit results involved in the WOW64 subsystem that has its own performance hit.


So should I not update to 64 bit? You should measure; although because what explained above it might be not trivial, you might not want to put effort into it right now.


Why this is a topic now?


With .NET 4.6 a new JITter got introduced that is a significant rewrite of the existing JITter (and caused some uproar when just after .NET 4.6 release a problem in a tail call optimization caused issues). It’s actually optimized to bring 64 bit nirvana for the masses by incorporating more usecases to use SIMD and SSE for. Yes, I’m going to talk about synthetic microbenchmarks here. Synthetic microbenchmarking is evil and you shouldn’t trust any of the results below, rather test your code – mileage will vary.


There are many usecases, like: matrix multiplication, simple floating point arithmetic and more where there is a significant speedup – we speak 4-5x (due to better usage of registers, opcodes, due to better coalescing of arithmetic instructions and use of noeffect code reorder). However, there are many other usecases – just calling a static method, or calling a virtual method might slow down by the same 4-5x factors.




Don’t believe any of the results above – please do measure yourself, and feel free to leave in the comments below whether you did see any performance improvements using .NET 4.6.1 and 64 bit over your 32 bit application. Also, going over 2Gb of memory usage – is it possible your application should be restructured not to hold all the data on the client side? Probably revisit a different pattern for client-server interaction is timely?

Connect 2016 Keynote – oh boy

Any Application, Any Developer, Any PlatformThe tower of Bagel. Bagel high rise.And I was thinking that last years’ keynote was a hard act to summarize. I’ll try to avoid dumping bunch of links here – many other people done that. Let me still try to summarize how Connect was – it all started on the Tuesday for me when I have had the opportunity to sit down with Jay Schmelzer, Director of Program Management and Sam Guckenheimer, Product owner of Visual Studio Strategy to speak about the upcoming announcements without actually speaking about the upcoming announcements; and would like to thank Eric Maloney from Microsoft for making that possible. For the big day itself, I’ll try to follow the ‘any’ trifecta – Any Platform, Any Application, Any Developer here the same way as this triplet became the official mantra of the day. The trifecta actually came live as a physical token as well. But let’s not jump too much forward.

image15 minutes before startAny Developers’ (and DevOps’, security architect’s, etc) life was made easier by ditching the static KB security article page and moving to a shiny new https://portal.msrc.microsoft.com/en-us/security-guidance portal. And of course the new Flow Partner Program with 6 new services. Any Platform has seen a significant change by Samsung releasing support for .NET for Tizen (TVs, watches got shown), by Google (and Nancy and xUnit) joining the .NET foundation (and as it turns out they have been a contributor for .NET for a while, and now ASP.NET became a first class citizen on Google Cloud), and of course, nothing smaller than (wait, I need to check whether hell is feeling well in the freezer) the end of one and a half decade of cancer – Microsoft <3 Linux Foundation (actually Microsoft been a significant contributor for the Linux kernel for a while now). Btw, did you know that the first 25.000 dev essentials users get 3 month of Linux Academy free with ‘MCSA: Linux on Azure’ course preloaded? Also I suggest starting to browse http://docs.microsoft.com – new documentation on Azure, SQL Server for Linux, Visual Studio 2017 RC (btw, ever considering moving away from ReSharper in favor of native, I suggest https://aka.ms/vs2017productivityguide, also, I’m looking forward what NCrunch’s next step would be as test as you type is now part of the IDE), C++, EntityFramework and more, and all being editable through github PRs. So go ahead, and do extend missing documentation instead of just leaving comments on it.

#RedShirtRocks - new shirt?imageThrough the color of shirts, we saw that the love for Any Developer (red shirts) and Any Platforms (black ‘devops’ shirts) were undivided, still one of the best burns of the keynote was when Scott Guthrie got the question from Beth Massi: “New shirt?”. Any Developer (probably just ‘Anyone’) could see how the Visual Studio family got extended with two new members – next to Visual Studio Code, Visual Studio Team Services and Visual Studio (for Windows? Original? Vintage version? – Miguel de Icaza), now we do have Visual Studio for Mac (based on Xamarin Studio / Monodevelop, however many pieces has been replaced with actual Visual Studio code) and Visual Studio Mobile Center (your one stop mission center for your app, the integration of all Mobile related ALM and Azure functionality). We have seen demonstration for the Any Platform part by Chris Dias with a demo covering MongoDB, a Mac, docker, azure, nodejs, .NET – actually Linux Foundation membership started to make sense as this might have been a OSS conference just I missed the title somewhere? 🙂 Chris not only showed lightweight interaction – one of the more heavyweight pieces when injecting the MongoDB connection string into environment variable for the NodeJS application to pick up from Azure Portal UI (of course it would work using just the rest API and / or DSC application deployment templates).

Github founder Chris WanstrathimageIf you would think no other surprise guests on the stage, ‘ohmyyyy’, we are so wrong – Any Platform. Github founder and CEO Chris Wanstrath showed up briefly and demonstrated the unprecedented love of Microsoft towards anything opensource. You cannot be a CEO without numbers, so he brought some along around commits, committers, projects and so. Not only did we speak about the Linux Foundation membership, but also proved by a person no other than Jim Zemlin, Executive DirectorJim Zemlin, Executive Director of Linux Foundation of the foundation.

Next section was about Mobile, and when it’s about Mobile and Microsoft it’s about Xamarin – distinguished engineer Miguel de Icaza and Xamarin CEO Nat Friedman gave strong demonstration of the first hand experience with the new Mobile development capabilities around Visual Studio, around the new Mobile Center and it’s integration into Azure, and much more.image Xamarin getting lot of love from Developers, and we hear about the trust it gets from the enterprise.image Comes as a little surprise that Visual Studio 2017 RC (release notes) is being announced by Nat – actually a good example for even more ‘mobile first’ 🙂 James Montemagno started to raise the heat in the room showing off the iPhone emulator, the realtime forms preview, live edit, Xamarin inspector for Android and many more – so more that he ends up announcing Visual Studio for Mac (see above), with ASP.NET Core support in it. It gets included in each and every Visual Studio subscription – even the community edition. Nat and James gets the privilege to demo Visual Studio Mobile Center – seldom you do see kicking off builds, CI, pipelines, etc on a conference stage (although I still remember last year when we were dissecting the new experience of Visual Studio Installer – who would think watching an installer is gonna be interesting?).James Monemagno and Nat Friedman doing build and CI on stage

Growing family of Visual Studio


From the devops world, not only have we seen ‘overnight’ (I’m not sold on that one yet) migration from onprem to cloud, but also we have seen Mr. Demo himself – big applause for Donovan Brown 🙂

Mr. Demo

Did you know you can love that warm, fuzzy feeling when you do deploy to docker from Visual The hardware backstage for the demosStudio? And you only need to sing ‘Just riiiiiight click’ while you are doing that. Actually, I’d need to have Donovan’s right clicked shipped in my production code, can I do that? Even Scott Guthrie needs Donovan’s right click, on stage. I have to admit, that Donovan not just being awesome presenter, but again had a few ‘this is where you clap’ moments by showing off cross docker boundary work by rubbing some devops on it. Continuous delivery rulez! And before you would think the world is only about right click, we welcome the selfies as well: Beth Massi shows of taking a selfie and taking a live video feed, demoing cognitive services and Azure functions in an elegant and entertaining way.

Beth Massi proving that there is a reason 'selfie' was the word of the year

SQL Server SP1 delivers enterprise features for the masses

Than we had one of the surprise announcements for the day (at least for me) by closing the gap with SQL Server SP1 delivering most if not all of the SQL Server Enterprise features for all versions – yes, even for the free express version. OLTP and data warehouse, operational analytics, compression and partitioning, polybase, encryption, row level security and masking – are all there. I really liked the deepdive into SQL Server (me being a server side guy originally) with Lara Rubbelke, and installing SQL Server for Linux into Docker literally in seconds blown my mind.

#redshirtrocks speaks about SQL Server news

Lara Rubbelke adding indexes to SQL Server for Linux

Not only basic functionality got reproduced for Linux like querying, data load, sharding, partitions (actually not that basic), but also all the special indexes that makes SQL Server blazingly fast. (did you know there is a USQL extension for VSCode? of course next to the mssql extension) Related to performance – in case you were living under a rock, stackoverflow.com is a Microsoft shop – they actually do run the whole site on a hot-warm setup, e.g. 1 SQL Server bearing with the load.

From SQL Server to bots – we have seen the bot framework before, now it has new support for Slack, Facebook Messenger, Microsoft Teams (surprised?) next to skype, and with the possibility to debug into the bots, have them access internal and external services and more.

Show what makes things real with Scott Hanselman

Stacey Doerr and Scott Hanselmann demoing coded UI testing using Selenium for UWPI shouldn’t miss the set of basic announcements from here: Entity Framework Core 1.1, ASP.NET Core 1.1, and .NET Core 1.1 itself (did you know that over 60% of contributions to Core are coming from the community? I’m also to thank the community to making it so great and fast!). However this wasn’t the part of Scott’s presentation which left me speechless (rare occasion), and not the fact that he prefers zsh when running the shell inside VSCode – it was the demo using Selenium to automated, coded UI test applications written not just in UWP, but also in VB6. Kasey Uhlenhuth also showed up to ‘filter out those suckers right out’ by demoing the new navigation and intellisense capabilities of the IDE – ReSharper, your turn 🙂 .

Maria Naggaga demoing the new .csproj formatSo we all heard about the demise of the project.json which we started to love (who wants GUIDs in the project file?), so I wasn’t happy when it was announced a few months back that .NET Core 1.1 would prefer .csproj files again. Through the demo of Maria Naggaga I learned this is not actually the case! Yes, project.json got removed in favor of .csproj – but this is not my grandfather’s csproj! No GUIDs, clean structure, ability to use wildcards – actually it feels and seems like using grunt, gulp or similar. While Maria showed up amazing performance numbers on a 20 way server, the newest round 13 TechEmpower data came in – not only ASP.NET delivered 859x speed advance, but delivers unbelievable low latency numbers and ended up in the top 10 with ASP.NET for Linux!

With these words I finish the keynote blog post, watch this space for the next rounds of posts covering the afternoon sessions and the special #FINTech sessions that were delivered the day after.

//Build’16 Keynote – Day 2

Let's do some Azure this time. Did you know that they are bigger than Google and Amazon combined? Let's hear more from the Red Shirt ™ ! This post is more picture heavy than usual, so many things to show not just write about!



What are the main reasons people choose them? These are Choice and Flexibility (management, applications, application frameworks, databases, middleware, infrastructure), the Openedness (choice of device, framework, OS), their Enterprise readiness (certifications, compliance, ability to choose between service provider datacenter, azure datacenter, your own datacenter – same tools, APIs, UIs to manage), and Productivity (focus on developers – did you know 40% of Azure clients are startups and ISVs). There are the various Azure app services you can create – providing web, mobile, logic, api as building blocks.








And here comes Xamarin – it's FREE. FREE as in really FREE and OpenSource. You do get it for the community free edition as well. And if this wouldn't be enough – you don't need a Mac anymore. And the windows emulator have multitouch. And with android emulator. Using Xamarin Android Inspector, with markdown support. With Roslyn providing code completion. With live editing for Android. Xamarin Studio on the Mac – free!


With Visual Studio Team Services getting the Xamarin Test Cloud added, you have a complete mobile devops life cycle now. "I'll just rub a little devops on it and it will make it better". With not only picture playback, but also video playback with realtime memory, CPU and log correlation.

"The first time I installed Linux was after I joined Microsoft."

No devices to buy, no VMs to manage. All comes hand-in-hand.


And we switching gears ™ to IoT.Starting with Open Mobility Cloud for cars (BMW this time, not Volvo ). Noone is going to ask you to deliver IoT. People ask you to make them access data easier and better. Check outhttps://azure.microsoft.com/en-us/campaigns/mydriving/ if you interested.

Announcement time again: introducing Azure Functions (with an opensourced platform), enabling to host snippets in the cloud with only paying for the actual resources you use. With automatic alerting, cloud connectivity and more. And another announcement: Azure IoT Updates with Start Kits, Hub Device Management, Gateway SDK, and more.


And now over to one of my favorite topics: Microservices.

267 million messages per second with 50.000 concurrent user in the same battle. Age of Ascent MMO game round now, anyone?  Age of Ascent developers helped adding 2300% increase in speed to Kestrel – thanks to them going opensource. Who does not love opensource?



And our favorite one lesser Scott is there showing an opengl game, Visual Studio.NET and Service Fabric Explorer at the same time. Object Oriented design moved to the cloud. You already know this if you know how to code .NET. Little learning curve for IReliableDictionary and Queue – not your usual collections.


Can I submit a PR for fixing the typo? 

"When I test my code I test it in production." "F*ck, awkward" "This is the classic off-by-one error in a MMO game"

Actually next to learn about weather we see another game, using DocumentDB:


And now a new area (is it just me feeling we have been rushing through more areas than ever?): PowerBI (free till May 1st), with PowerBI SDK for creating ability in your application to add PowerBI capabilities and connectivity to your own application.

Next topic is productivity. Reinventing productivity. Developer productivity. Transition to the cloud. Delivering new productivity experiences on the mobile. Building a modern productivity ecosystem. The platform opportunities are already open today. You can build intelligent applications by connecting to Office services. You can make your solution part of the office applications. And you can engage the users through conversations – conversations as a platform. You need a productivity platform and working ecosystem for this. The four pillars around this are mobility of experiences, collaborative productivity, intelligence everywhere and being trusted all times.

You can use Microsoft Graph to reach the data – similarly how you did it using Microsoft Hailstorm ( https://en.wikipedia.org/wiki/.NET_My_Services , anyone remembers it?). The demo is using DocuSign to show how the new beta graph API enables you to use the data and intelligence from the Microsoft Graph. The office addin capabilities (announced today) now making it easy – using web technologies (html5, css, javascript; and technologies like OAuth). This enabled announcing Office addins for Office 2016 for Mac and Office 2016 for iPad/iPhone/Android. Also, having a common, modern distribution using enterprise or normal application store enables you to easily reach people.

Simple web technologies and a config file enables you to write, package and deliver your addins easier:

We speak of a Seattle company – Starbucks connectivity in your email available now 

Machine generated alternative text: Starbucks for Outlookchooi. Vow .GftThjnk You!IO O2JI s. *a>e’C.f f.. FavørI.s •—- oWeddingr. O___ , ‘ 7f(5_ —ee AI>

Machine generated alternative text: Sta rbucks for Outlook< Check Outrl Microso//build/-’siœo, O.ooe Y Om Aioia.QLu. riprjòtt cornCatd Arnotint $100Chooi.c Your Paent Mr-thod[vlsA 1111

Office 365 Group connectors – another productivity announcement, from now on you can add custom connect, already 60 providers having their information actively added to the threads:

Also enabling trusted, secure video and audio conversations by using a the common communication platform, embedded into the applications:

And probably the last gear change:

Having the Muzik platform iOS/android/windows phone addins – devices, IoT, next generation productivity. Showing demo for Highspot and machine learning – they are an AWS shop, but running PowerBI there. And – running azure website inside powerpoint as an addin, and use Vorlon.js to debug the application realtime. Also adding possibility to add the bot framework and platform using node.js and restify.


And introduced http://projectmurphy.net and the Skype bot you can use there for playing with 

We learned a lot about ongoing projects – open source projects Microsoft is involved in, user groups Microsoft is involved in, Enterprise customers and ISVs Microsoft is involved with, the involvement with students and universities, etc. Lastly – we learned about a new show called http://www.decodedshow.com/ as part of the closing words.


I think I have to repeat myself from yesterday: Empowering developers!

//Build’16 Keynote

What I figured out just by watching the pre-intro – they are more low-key about the event than usual. No wild build-up to the keynote, music is relaxing and downtempo. And they are very blue 



1600_5F00_phplnvfosp3300034.jpgSatya Nadella started by taking over the stage. Taking over – he is full of energy, everyone loves him (what is not to love on the guy who brought you SQL on Linux, Office for iPad, etc.) He quickly points out how dev conference is a dev conference: it's about networking and being inspired. This unique characteristic what he wants to build on and celebrate. He brought up topics in his opening speech that focused on society and how it can be a mainstream thing; how it can either hurt or help it; how it should empower you. He also was overly optimistic, and said, that optimism must be buoyed by making the right choices. And of course, the mantra of 'mobile first, cloud first'. "Cloud is not a single destination. It's a new form of computing" he said.


1600_5F00_phpxhnma9p3300038.jpg1600_5F00_4.pngCreating, building and reinventing is the 3 main pillars for cloud and is Microsoft's ambitions in this space. Windows 10 is off to a great start – he said. New platform for human voice, fingerprint, and more? "It's such a great time to be a Windows Developer." And there are 270 million Windows 10 installation (5 billion store visits); if we look at the 1 billion installation in 3 years, we are not that far from the forecast – and actually is the fastest ever adoption.

royen.pngTerry Myerson starts with "Hello Developers" – anyone wants to continue with "Developers! Developers!" and large amount of sweat?  Windows 10 anniversary update would still come free.It contains new ink experience (with ink workspaces for last used ink apps), biometrics for Microsoft Edge (got demo of it, using biometric scanner to log into the website), support for Windows 10 on XBOX, enabling general XBOX One development (e.g. any retail XBOX One can be used as a dev kit/machine, using the same UWP username/account). You get nice controller support for selection, focus, etc. But also you get speech recognition and more on the XBOX, and with full VS.NET debugging experience. Hololens gets also refresh during the summer. Bryan Roper stayed in character with his clothes and style, no surprise  They are bringing pen & paper even further into the focus. He demoed the new ink features – front and center; and he just started! He was able to write with ink and that got contextive focus from Cortana providing full integration for sticky notes ('Call mom tomorrow' gets translated into reminder). Can I get an 'Ohhh' – Ohhh!


1600_5F00_php49fr87p3300045.jpgWe saw demo of a virtual ruler using whiteboard/sketchboard as well, and just tweeted it from the application. Important to know how you get something new – ink and touch together, enables for example amazing features in PhotoShop. Also, we got demo of 3D maps and ink usage – points of interest, plotted routes, etc. Also we got demo of using ink in Office – Word to remove texts, for highlighting; Powerpoint to show how items can be lined up, etc. Generally Microsoft is creating a layer of contextual computer learning to make the stylus smart and useful in a way you want it to be. It's more of a real digital pen than ever.

As part of the keynote, Facebook was announcing that it's bringing it's ad network to Windows 10 universal apps, that will considerably help monetizing applications.

home.pngAnd at last (35 minutes in) "It's about time we looked at some code!"  Kevin Gallo is on stage! "We want Windows to be home for Developers" Part of UWP got AnimationFX platform introduced with hovers, blurring, flowing, shadows. All GPU accelerated! And also with deep ink integration. Here comes "Hello world" for ink, with InkCanvas and InkToolbar. The new design language seems to merge Material, Jellybean and existing metro; flat & robotic, but layering and animations.

linux.pngVisual Studio 2015 Update 2 and Anniversary SDK preview was announced, that enables use the features above. Next topics was web apps, e.g. how to make a desktop application using only web technologies. And yes, BASH shell is coming to Windows. Not VM, not cross compiled. New Linux subsystem supports this. This enables people stay in BASH, emacs, etc., e.g. with their known tools but still use Windows.

And officially announced was Centennial – Win32 app converter, to continue running your desktop application; they will get built into WISE, Installshield, etc. And with doubleclick support for .appx, with support for accessing live tiles, toasts, etc. You only need to add the extra functionality as a separate DLL and load that on demand when you are. This will help move the 16.000.000+ applications to the store.


devmode.png1600_5F00_w10.jpgAnd the expected demo from Xamarin – nice addition was a remote XLB editor from Visual Studio next to rest of nice, immersive features. Ok, Terry Myerson just said Bash and DOS in the same sentence. If you are doing a drinking game, this is the time to drink the whole bottle. They just mentioned we will focus on gaming now – Phil Spencer first, Kipman on Hololens next. Phil will surely have a hard time convincing people that UWP is the best platform for writing games. Killer Instinct, Quantum Break, Tomb Raider, Gears of War, etc all being UWP. In May they add GSync and FreeSync instead of VSync. DX12 is coming full speed, for full screen games, with overlays, and more. They actually demoed Age of Empires (directly from steam!), Witcher 3, running as an UWP, full frame rate, full screen.

This ins't a hobby. It's a commitment – said Microsoft about Xbox One Universal apps. and the preview of dev mode is available from today. And DX12, which makes it all possible is the fastest adoption of API so far.


And yes, shipping for Hololens is happening today. And they are opensourcing Galaxy Explorer. We got a good demo on how medical students can use Hololens. "To think and see beyond the possible" Also demo of Destination Mars, in Kennedy Space center and onto the Build conference. At last people can try doing everything Matt Damon did in Martian was wrong. Hololens do transform your world.


cortana.pngAnd Nadella is back to 'switch gears'. We will help computers learn so that they can help in everyday tasks. It's not about man versus machines. It's about man with machines! By augmenting human abilities and with experiences, being inclusive and with earning trust. Human language is the new UI. Bots are the new apps, digital assistants are meta apps. Intelligence gets infused into all interactions. As a result of this idea, Cortana is building to be an actual assistant, not an assistant that's limited to platform/device. Right now Cortana answers one million spoken questions per day, 1000+ application connected. New version of Cortana will work on lock screen, having a full screen experience; also having an integration with Outlook. "Sent Chuck to powerpoint I worked on yesterday"; by sending text message it automatically sets up meeting and moves other meetings around. Also will figure out it's during lunch time, so it will try to suggest eating out; all based on the connected applications. This happens based on a connected application which looks into calendar and decides to toast based on that. Based on receipt in email, Cortana suggested submitting expenses. "what toy store did I got to last year at build?" Cortana Developer Preview invites are available!

domino.pngGrowing number of conversation canvases are there – slack, kik, groupme, wechat, line, skype, email, sms, etc. They look into making these into rich conversational canvases. Where does this lead? Into working Cortana into the applications via using bots. Like transcribing video messages, having rich bing powered cards, brokering conversation with 3rd parties, knowing context from previous conversations, and sharing context between brokers. Like not only booking calendar, but booking hotel, suggesting to contact people, etc., this working for typed text, voice but also for realtime video and for hololens. Cortana really behaves like a real assistant – though making available the newly announced skype bot sdk; with a hackathon to kick it off; and is available in the applications from today; based on Microsoft Bot Framework (with bot builder sdk for nodejs and C# available from github), Cognitive Services (new website with 22 services at start at https://www.microsoft.com/cognitive-services, and with a demo ofhttp://captionbot.ai/ and CRIS recognition of voice) and Machine Learning (with many tools to teach the system on the fly and involve humans to help when machine is stuck). The idea is to have cognitive micro-services that you could use from each of the conversation canvases, not only from Skype. Also a very nice (actually, I'd say, amazing) demo for people for disabilities on how to use these services in action.


The summary of the day: Empower developers!