//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_phpszxezymicrosoft_build_2016_header_image.jpg

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.

hololens.png

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!

Ubuntu on Windows – what does this mean

Seeing the recent set of announcements – starting from Office for iPad through buying up Accompli, Sunrise, Xamarin, etc., also announcing Microsoft SQL Server for Linux – it came less of a surprise that Microsoft is bringing Ubuntu on Windows – however comparing it to the Microsoft of the past (Steve Ballmer once considered Linux users a bunch of communist thieves and saw open source itself as a cancer) it still comes as a big surprise. We still lack some of the details there, but we are seeing various Linux subsystems integrated into Windows (does it mean that Bash would be coming for Windows? I think yes). So we are not talking about a Windows-Ubuntu hybrid OS. Neither we talk about a virtual machine. However, as a result of this, Ubuntu would be able to run on native Windows libraries, using the subsystems, and gives access to Ubuntu from within Windows without the overhead of a VM/dual-boot setup.

What else I expect? Some excitement around Ubuntu LXD and using together with containers and Windows would be nice.

Ionic just added support for UWP

Ionic just announced (http://blog.ionic.io/announcing-windows-support-in-ionic-2/) – as part of the other huge sets of Microsoft Build announcements – that their API and toolkit, along with a total UI looknfeel and component set is coming for UWP. Why is this important?

If we glance at the sessions of //Build'16 you can see they focus on two major target right now: game development for UWP and web development (or better to say, using web technologies) for UWP. You could ask, where is the desktop development? Next to having a session focusing on moving desktop apps to UWP (using project centennial, which enables bringing win32, .net, etc apps to become part of the UWP ecosystem and windows 10), there is no speak of desktop development at all. What does this mean? A move of focus? I have been watching the whole UWP story for a while, and by now I'm positive (even if not sure) that the web technologies is the way how desktop applications would be built. So, I'm more than thrilled to wait for the //Build'16 keynote and the breakout sessions where this would be hopefully dived into.

Connect2015 – FSI DevConnect, afternoon sessions

The next session on the FSI DevCon was focusing mostly on Machine Learning – how can you use many of the achievements recently came out of Microsoft (most of them open sourced!) to target creating a new kind of AI. We’ve seen some amazing demos of Project Oxford's (Microsoft's in-cloud solution for evaluating queries like 'Twins or not?' and much more serious questions as well) scalability, up to 150 billion evaluations per second. As I have been a Windows Hello user as well, obvious was the question – does the face recognition being the same in Windows Hello and Project Oxford? Turned out to be they do share some of the codebase, but Hello does depend on 3D camera points and much more to make it more robust.

·         Microsoft expands availability of Project Oxford intelligent services: http://blogs.technet.com/b/machinelearning/archive/2015/10/26/microsoft-expands-availability-of-project-oxford-intelligent-services.aspx

·         Microsoft open sources Distributed Machine Learning Toolkit for more efficient big data research: http://blogs.technet.com/b/inside_microsoft_research/archive/2015/11/12/microsoft-open-sources-distributed-machine-learning-toolkit-efficient-big-data-research.aspx

·         The Language-Integrated Quantum Operations (LIQUi|>) simulator: https://github.com/msr-quarc/liquid

 One of the best quotes of the days I think should be paired up with the next discussion topic: Universal Windows Apps and Platform, which was: "Windows RT OS? No we are not discussing that now." There is not much I'm allowed to share on the rest of the discussion.

The last big topic we dived into was bitcoin and block chain – to help figuring out what my/our strategy is supposed to be on it. If you still struggle separating the two: if block chain is Manhattan, bitcoin is just one building in it. Same way: if block chain is the iPod, Ethereum (more on that later) is iTunes. We discussed the basic on block chain and bitcoin – What are tokens and addresses. How it works as a P2P network. How it forms consensus. What is a block chain VM and how it works. Why resolving the truth is going to help you next to just storing the information. What are smart contracts and why they are smart – how you are incubating disruption here. We looked into what ÐApps are, how they are distributed applications built with the smart contract platform Ethereum. How the smart contracts enforce themselves as they live on the block chain, how they react to events, multiparty actions, how they can help you transfer assets. How you can create composite contracts. What clause chains are? And most importantly: how you end up with a giant worldwide distributed virtual machine. We looked more deeply how ÐApps work – how it's a combination of a contract and a JavaScript GUI to work with Ethereum and eth. And then popped up the reason why we were there – to learn about 'Azure Block chain as a Service'! We looked at how Ethereum block chain as a service serves a vision with service fabric and microservices, and I think I agreed on that block chain is can be a bigger thing than FIX if needed. The ability to fire up my own ubuntu/go based solution for playing with block chain in the cloud is appealing, and the support in VSCode is giving me a good development IDE to write the sols and configuration files for it.

 

As the last of this series, I'm saying this here the last time: It's a different Microsoft now! 🙂

Dev-Test Starts with IT (set of Azure webinars)

Move dev-test for business apps onto Azure

Upcoming: Wednesday, December 9, 2015 1:00 PM UTC-5)

In this webinar, you'll learn how IT pros, accustomed to using on-premises VMware environments, can move dev-test for business apps onto Azure.

 

Dev-test on Azure

Available now on demand.

In this webinar, you'll learn how to set up your dev-test infrastructure on Azure, configure a site-to-site VPN, and move virtual machines from your datacenter to Azure.

 

Create self-service environments with Azure Dev/Test Lab

Available now on demand.

In this webinar, you'll learn how to use Azure Dev/Test Lab to quickly self-provision test environments, set policies, share reusable templates, and integrate Dev/Test Lab into your DevOps pipeline.

Connect2015 – FSI DevConnect, morning sessions

So on the second day of Connect, Microsoft did held two additional events at their New York building – VisualStudio Connect and FSI DevConnect. Based on my interest, I have chosen the latter – here is a small subset of those topics I'm allowed to speak about. In the morning of the FSI DevConnect, I saw ScottGu again – but without his signature red shirt I hardly recognized him, he dodged it for a blue one, I think the cloud finally takes over 🙂

We started with setting up the topics for the day: How to do DevOps in a heterogenous environment. How to do testing in such environment. What is the tooling in such polyglot environment. What to take on from microservices and containers today and in the future. What does service fabric mean on premise. What interop strategy scenarios should be considered. What is the WPF story. What is the client story now with continuum. How to paraphrase mobile first for an enterprise.

As I pointed out in the previous writeups as well, next to having monolith IDEs we should focus on a different approach as well – same applies not only to an IDE, but also generally for the management, operation, development, etc work. As such, we have to consider moving from integrated set of tools to rather pick the best tools and just make them work together more. Considering the new openedness of the Visual Studio marketplace, the number of extensibility options for both Visual Studio, Visual Studio Code and Visual Studio Team Services, Microsoft seems to embace the idea in full. The amount and level of extension points allow us to hedge the path forward, especially in the cloud. With regards tooling, this enables everyone instead of chasing technology, rather to leap forward to new approaching quickly – the power of the community.

We discussed the lack of focus on Microservices both in the announcements, but also on our day-to-day work – as these tend to be not really visual, and it's rather hard to do a nice presentation when you are just showing up a bunch of nice linted JSON files; therefore (the lack of good) presentability is really a capping feat for them.

Coming with enterprise focus, we have had to move the elephant out of the room – it's very nice and we are super proud that Microsoft at last is bringing .NET from a Windows centric world to the wild – but as they haven't started this when the technology was born, therefore there are tons of existing application, knowledge, systems written with it. What should I, the developer, already on Windows take away from the current landscape? Part of that is the changed cadence and delivery by Microsoft – we are already receiving Windows 10 Update 1, we are looking forward to the end of the month when .NET 4.6.1 would be released along with Visual Studio 2015 Update 1. And we know all of these are inplace updates – that is a risk! We should embrace the tooling (APIPort and Analyzer) to mitigate it, and also embrace various smoke tests and UI testing capabilities to make sure we can keep up with the cadence, especially if our applications are used outside the enterprise managed zone.

With this new cadence came also an interesting question – if we look at let's say how HTML5 is evolving, there were many standard that came, changed a few times than vanished forever, and HTML5 developers were fine with this. How should a company like Microsoft do the same – the attack surface of an operating system or .NET is still considerably bigger than the browser. We should someone start differentiating between 'we are committed to doing it', 'we are planning to do it', 'oh, we are just experimenting, but you should still use it, just be prepared we might kill of or resuit this underneath you with little warning' – e.g. this is nice in theory, but how would you get people use the latter? How would you move people off of the 'no longer recommended' function and release, and not letting them stuck forever?

We could not walk next to the other question – should I pick a docker image (or probably rolling my own similar containment strategy) OR should I use full VMs? Is there a need for a new middle ground that hasn't been yet looked at? Same way, we do have those people who are command line enthusiasts, and those who are the GUI lovers – is there a middle ground, should these people come together more? Now that windows became managable with command line (and we have SSH as well), does docker suddenly need a GUI?

Next session was supposed to be how to do DevOps on and with mobile, but we really did go wild with the discussion instead. We did look into how portable libraries became available across technologies and devices without the use of Xamarin, with the upcoming Visual Studio 2015 Update 1. We also discussed the options: if you are a C# developer, Xamarin is the solution for you – native UI, portable technologies, idiomatic C#, calling the native platform. However, if you happen to be a JavaScript developer, Cordova is your tool – high level of code sharing, but not a native look & feel (can be faked with the right amount of JS/HTML/CSS, provided through many libraries; and you need to test your application against many of the browsers (or you have to package the browser along your applicaton with all the security updates on you, as you can do with Crosswalk for Android).

As we have seen on the previous day, Visual Studio is in progress on catching up with non .NET developers – Python is a good example for that. Generally, according to the surveys, Visual Studio is a good brand that resonates well within non Windows developer communities too, and now with Visual Studio Code, and with the free Visual Studio Dev, and with cloud subscription, and with Visual Studio Team Service, and with Community edition, etc. it's really opening towards being a not-just-Microsoft-tech IDE. On the same topic, we could see on day 1, how the Visual Studio installer is leaning now towards to work very much like how battle.net or Steam is working in the way of delivering the actual IDE(s) to your machine, having a better update mechanism, different channels, shared and replayable install experience, etc. cross many platforms and scenarios. We learned about how Visual Studio supports TextMate bundles (TextMate being a very powerful and widely used text editor for the Mac), which is currently focusing on more the visual parts of the editors and only if you add the relevant wrapper around them, but we are getting closer to a more open ecosystem here. Also, if we look at some of the recent open sourced extensions by Microsoft, we can see how simple writing extensions could be, and can learn best practices on how to make these extensions well behave and to isolate well from the others.

A question related cloud and development was next – if we want to be able to use the cloud services for compilation and more, can we (and if yes, how) to encrypt the cloud source/storage for end-to-end SDLC and DevOps – this can only reliable work now if the compilation steps are happening at your private nodes, otherwise there would be a point you would need to uncrypt the sources in the cloud. But generally, we agreed on that our industry is on a (long) journey to the cloud. Data in motion is encrypted. Cloud domains (like Azure AD) is for your authorization and authentication. You can even use IP fencing, or depend on custom leased lines – as it was announced a little while ago, the custom country specific azure zones are also there with no insight into them from outside authorities.

But than, how you can do Agile and DevOps in a highly regulated environment, like a financial company? You need to depend and you need to give a strong role to your QA, but if you start to go in the over-prescriptiveness way – what is the tradeoff there? What benefits you having, are not the barriers overshadowing the gain? So, the idea here might be is to push testing even more – to the earliest point in the technical and also in the business development (prototyping tools, anyone?), this should result in decreased time for testing per release (example for this is the Visual Studio Team Services approach – used to be months of testing, now down for a few days due to the small level of incremental changes and high agility to pull back releases and redeploy). Which all depend on – what kind, level, amount of bugs you can tolerate? You do need to optimize along your feasible constraints here. And counting, measuring is not enough – an example for this: if you decide to measure your developers based on number of user stories being done – you will get lot of user stories done. If you measure based on number of bugs fixed – there would be many bugs, and they will be fixed. None of this measures are really true, only business success count, but you need to reflect that in your system and measurement policies through – which is hard, how does business success show up in a microservice that you just modified?

Also, based on Microsoft's own journey into it – having a workflow for easily and quickly consume opensource packages, with the right level of legal, packaging, building, etc. happening under the hood with an automated system is something everyone should aim to have (probably this is a market nieche, anyone have a sparkling idea for a startup? 🙂 ). On a similar topic – how should you grow your organization, your team, how you should nurture the people? Microsoft did switch to the 'yellow sticky notes process' for a while in some of the teams, which shows good results.

What is the 'yellow sticky notes process'? Actually from time to time you ask people which team they want to be in, have them write this down as option 1./2., and than try to match it with the budgets, project constraints, etc. Based on their experience for running this process for a while, a whoopping 80% of the people are just happy from the fact that the choice was given to them, but not actually asking for a change. Therefore you are only left with 20%, which save for some extreme cases when you have to ask someone to stay with a team for one more iteration, is usually working out nicely. This approach might be not feasible for many organizations missing the agility to do this, but still would worth start be thinking about.

Next post would be focusing on the FSI DevConnect afternoon sessions; here I commence the morning part.

 

Connect2015 – Future of Software Development

Next session was focusing on the 'Future of Software Development'!

We quickly figured out: Microservices ARE happening. For me this brings back soft memories of the first time I was doing real multi-tier applications – at that time expectations from the systems weren't that complex, therefore in some perspective those were close to being microservices with today's scale and view. Part of the current problem is that the tools already catching up with trend. When would the developers catch up? As on the previous session, we learned how much the software development should focus on optimizing development productivity – no empty cycles, more information at hand. Which is interestingly leads to the question, and recognition: there are actually two kinds of developers, those who wants to sit in the most complex cockpit available with as much HUD as possible and integration into all the workflows and systems – and at the same time the large group of developers who would rather see there development cockpit also made of smaller microservices, that are pluggable – for the latter was VSCode dreamed for, and I think it does fit those shows perfectly with the large number of extensions. Next came a topic many of us were dying for to hear about – is Javascript (e.g. hybrid), Xamarin (e.g. cross compiled language tailored for the device and capabilities) or native the answer. I think we answer we got – "it depends" is actually the best answer you can do, there is no one size fits all. We have seen companies moving back and forth between these technologies as they did develop their mobile and desktop experiences, so even it might be different based on the growing or changing requirements. Also, we got a more detailed answer, where the major point was about 'code sharing' – e.g. your choice should depend on what targers you have and how much code and design you can or want to share, and whether you can depend on having a network of you have to be thinking an 'offline first' approach.

Also we dove into the question of running and finishing now the full cycle again – from native to JIT to native compilation again, however this time with the added complexity that a dynamic cloud structure will most likely result in a cloud recompile. On the same topic and about older devices and browsers, it was expressed, that "evergreen" development IS happening. You just have to come up with your definition of your minimum client/browser, probably aggressively. Than came the question that broke down everyone: "I still have ActiveX controls…" Actually at their own time they seemed to be an easy, clean and quick solution. I agree with the panels opinion that it's just the question of managing two browsers, one for legacy and one for normal life – and actually with Edge and Explorer separate Microsoft did the same distinction. After jumping around desktop and mobile topics, we could not miss going to the cloud next: I don't think any disagreement came after we declared that a non IT company's core competency just should not be managing server farms. So the dream cloud of the future? Is it more than just moving applications off onpremise? We know and probably believe as well how much the cloud enables business transformations – for big data, for big firms, but also the same way for startups.

Of course we did dive-deep into docker, and how a fully dockerized world would look like, and how the idea and need of docker was arisen, nurtured and now being projected full scale. This wouldn't be an IT conference in 2015 if the question about IoT and wearables would not be rosen (actually I asked it) – whether we look into self driving cars, mesh networks, displays and glasses, we can be sure: our kids will have a different world ahead of them than we had. Will our kids, grandkids know how to drive? Should they know? After touching on all these topics, we went to understand the need and reason for aggressive telemetry – technical insight AND customer insight are both needed for a succesful telemetry, but also to have the ability in the DNA to act upon it quickly is the most important point. We learned the anecdote on why right telemetry is more important than just having it – the large number of clicks on 'Add Service Reference' in the IDE does not mean people playing with microservices if it was followed by a quick cancel each time 🙂 With having telemetry part of your cycles, you need to have the confidence (as you already have the insight) to roll back a release when needed and to mitigate the occuring risk – both in the cloud, on prem and on the desktop. Lastly, we discussed if the Visual Studio 2010 releasenotes focused on Silverlight, WCF, Workflow and the new architectural tools – what Visual Studio 2020 release notes would be about? It was a wild speculation 🙂 On the same thread the last short spark: with the number of technologies to interact growing uncapped – do we need developers with less specialization?

In a (looks like sticky) one liner summary: It's a different Microsoft now! 

Connect2015 – Creating Projects in the Open

In the afternoon of Connect2015 day one, a choice was given between IT Pro and Developer track – I went with the latter to learn about ‘creating products in the open', with Jay Schmelzer, Erich Gamma, Amanda Silver and Patrick Chanezon.

#Connect2015One of the first questions was about how RedHat and Microsoft are going to cooperate on giving support for CoreCLR for Linux, e.g. whom to call if the server is on fire. I think best is to be summarized as the quote ‘Open source does not decrease the level of support and / or change the release process'. Next question was on ‘How to respond to a new fancy JavaScript framework coming every month', and the answer was really to focus on developer enablement – if approached with the relevant tools (e.g. nuget/npm/bower/cordova plugin and extension support in the IDE, quick uptake of the new libraries by the people creating the packages, etc), the actual framework picked becomes a less relevant question. It was interesting to learn the scale of open source dependency – in the (now opensourced) VSCode 130 different open source components were used as a dependency. With switching to opensource – as we learned – insight was given into where a project is going, and enabled other teams and projects to build on the capabilities earlier. What is a nice side effect: the definition of ‘Done' had to become from crisp, under the set of watching eyes. Socializing side was also strong – you are socializing in a virtual open space across the continents, something hard to achieve otherwise; and also – opensource projects and being opensource became a recruiting tool both for Microsoft and both for companies using Microsoft tech. Also – it does not have to be big bang! Do something meaningful but small first, and do see how the community reacts, and also: Releasing imperfect code does result in engagement – and engagement is actually a good thing. We were reminded on two blogposts from Scott Hanselman between the lines: Open Source is a thankless job. We do it anyway. and Bring Kindness back to Open Source – being in opensource development do require social skills.

To underpin all the good things Microsoft sees, they now have a healthy pipeline of projects to be opensourced, but no details were shared.

In a (looks like sticky) one liner summary: It's a different Microsoft now! 

Next on the Developer track was ‘the future of software development' – in the next post.