Build
Go Mobile with C#, Visual Studio and Xamarin
Xamarin is awesome! They bring my favorite language, C#, to my favorite device, my iPhone. I use Xamarin in all my mobile apps and could not be happier.
Their growth these last couple of years has been amazing and they were the highlight of last years Build. Microsoft has focused on other companies and technologies this year, but Xamarin is one of the most important and innovating companies in the .Net ecosystem. They bring more value to peoples lives than ObjectiveC on Windows Phone ever could.
Miguel: “This is web scale”. Bingo!
Everything you can do with C#, you can also do with F#. F# did not get a lot of love during this Build.
Showing the C# slide.
The demo app is a chat client. That sounds familiar. DIRC didn’t have encryption though and automatic parent forwarding. Nor an Apple Watch app.
The DIRC icon is missing
DIRC is my goto Xamarin teaching app, used in the Norwegian education system.
Silicon Valley 101: Find larger market. Find a differentiator. Find product/market fit. Grow your market.
Miguel: “Parenting is kind of like Ruby on Rails”. Gamify driven parenting. Badges!
Snuggle!
Love to see Apple Watch apps in Visual Studio.
Use Xamarin Inspector to debug your UI on all platforms. It already supports C# 6. It’s like Apples playground, visual debugger and C# interactive all in once. The inspector supports visualizer for common things like images. Enables truly rapid UI prototyping or view hierarchy debugging. Available as a nuget package.
The inspector knows of images.
Where have I seen this before...
Xamarin Test Cloud is useful for Android developers for running UI tests across a range of real devices. iOS devices are also supported. The tests are written using Xamarin.UITest, adopted fron NUnit. The tests can be built using a live interacting REPL.
Unexpected red tests are the best red tests.
Android in all its glory.
Xamarin Insights is the Xamarin analytics solution. It supports all the usual stuff, exception reporting (both managed and native), optional user tracking and event tracking.
Insights has gotten more useful.
XAML Tools in Visual Studio 2015
Blend is recreated in new glory together in Visual Studio 2015. As is the XAML language service. Fast and fluid is the mantra.
Roslyn saves the world.
The XAML designer can now be disabled completely, though it is also more useful, so it’s a tradeoff.
Code Peek is present in the XAML editor as XAML Peek. You can quickly edit your C# while in your XAML editor, complete with Intellisense, refactorings and code actions! Awesome! Thanks Roslyn.
Who needs a designer view?
Regions are supported in the XAML editor. It’s maybe more useful there, but I doubt it. If you need regions, you are doing something wrong. Structure your code differently and remember Uncle Bob. Clean! Short! And in your face if it isn’t.
Regions are the root of all evil.
Right click on any XAML file and you can open it in Blend. Blend is recreated in Visual Studio, but with an additional designer friendly theme. Projects and source control integrations are shared between Blend and Visual Studio.
Blend lives!
And it's dark!
The visual debugger is a very welcome addition. A UI debugger is now a requirement for modern UI frameworks IMO. The Live Property Editor supports setting arbitrary properties on any visual element, even properties that doesn’t have a value set yet.
Blue lines are the defaults, yellow are the margins.
Killer feature: databinding debugging! In the Live Property Explorer you can search for DataContex and browse the current context. This makes it easy to check if the right context is set or find misspelled properties.
Also awesome is the timeline profiling tools which I covered yesterday in Debugging Performance Issues Using Visual Studio 2015 and XAML Performance: Techniques for Maximizing Universal Windows App Experiences Built with XAML.
XAML views can share the same code behind, making code sharing possible also outside MVVM. But you do use MVVM, right? InitializeComponent can now take a URI to a XAML file as an argument.
Adaptive like HTML :)
XAML Performance: Techniques for Maximizing Universal Windows App Experiences Built with XAML
Performance is good enough for the Windows Shell team and the Office team. It’s fast enough for them, for us and for you. Performance balanced with productivity.
Should've been a Tesla.
Optimization occurs across many axis, CPU, Memory and Responsiveness.
Where is David Letterman?
The Zen of Performance: The fastest code is the code you don’t run. Defer as much as possible.
Define your target and your goals. What is slow? Startup? Crashing? Lag? Track your goals and measure. Convert to a Universal Windows App. A lot of performance optimizations only for Windows 10.
Money for nothing and performance for free.
Profile your application. Use the Visual Studio 2015 timeline tool, profiler, memory profiler and the visual debugger.
Profile with the tools you need.
Drill down into the results.
Don't forget about your memory budget.
Defer all possible work. Never lock the UI thread!
I want this in my WPF!
Reduce the number of elements. Ballpark: 1000 elements is 1 second! Look at startup elements, unused styles and templates in repeaters and lists. Make sure you only load the elements that are shown on screen.
Use virtualization. Both ListView and GridView virtualizes. Though, placing ListView within a ScrollViewer or changing the panels used by them will disable virtualization. If virtualization works, about 2 pages worth of items will be cached.
Optimize databinding. Simply DataTemplates and use x:Bind. x:Bind generates code that gets compiled and is strongly typed. And it’s debuggable!
The new default.
Think of the Grid as a table. Use one! A Grid within a Grid should be unnecessary in 99% of cases.
Optimize your images. If the memory usage is high, resize your images or use DecodePixelHeight and DecodePixelWidth.
Optimize text rendering. Windows 10 text rendering is 50% faster, but certain typography features can disable this. DebugSettings.IsTextPerformanceVisualizationEnabled can visualize this in debug-mode.
Performance tuning makes you happy!
What’s New in C# 6 and Visual Basic 14
Everybody loves Mads and Dustin. The line was forming even 30 minutes before the session. The first session of the day.
A big year. Began talking publicly about C# 6, released and open sourced Roslyn, released .Net Core libraries and runtime as OSS on GitHub. OSS all the things!
Visual Studio 2015
The C# stack in Visual Studio 2015 has been completely rebuilt. Everything is a little bit better. And shinier. The IDE has stolen most of ReSharper best features and made them available out of the box. This is a good thing and I’m writing these words wearing a ReSharper t-shirt.
Code actions will show previews before you complete them. An improvement over ReSharper’s implementation. Potential conflicts that would come as result of the actions are visualized. Modal dialogues are also used less.
Refactoring preview in action.
Anyone can build code analyzers, and they can even be shipped together with the code the should analyze. For instance, ship analyzers for ImmutableArrays together with Immutable Collections nuget packages.
Language features
Static usings simplify access to static members. Console WriteLine can be called as WriteLine with using static System.Console.
Immutable types are awesome. Auto properties can now be readonly, same as with normal member variables. Only declare getters and you’re set. They can even be initialized directly.
Expression bodied members can skip the return statement and curly brackets, using the lambda arrow instead. Makes for more readable code when dealing with small methods. Thanks for the inspiration F#!
Simplify all the things!
String.Format can be converted to an interpolated string. Prefix the string with an $ and write your format string. Expressions can be used, not just values.
nameof(whatever) gives you the name of the variable. Useful when creating argument exceptions or in databinding.
Null conditional checks can be written with ?., an inline null check. It even supports indexers. No more foo == null boilerplate!
Object initializers can now initialize to an index, not only members.
Focus on the important bits, less cruft.
The team became smarter with time, an await can now be used inside catch and finally blocks. It just works!
Exception filtering is supported using the when keyword. Less logic in the catch block.
Debugging experience
Edit and continue is back and works even if you use new language features. You can code freely while stopped at a breakpoint, even create new types. Visual Studio 2015 still gives you Intellisense and the code actions and refactorings works!
Lambdas and LINQ can be used in the watch and immediate windows. Impressive, the language is even useful during debugging.
The C# Essentials is a useful extension, helping you use the new languate features.
Future stuff
A playground without equipment.
C# interactive window will be back with full Intellisense. Xamarin and Swift, you’re not alone! Not as feature rich as the Playgrounds of other languages, yet at least. Roadmap is available on GitHub. Though a REPL is still useful without visualizations.
The design notes of C# 7 is on Github. They’re issues tagged as Design Notes. Modern languages have greater potential to help the programmers being more productive and less error prone, such as nullability tracking or tuple types.
I love the new open Microsoft.
Using Git in Visual Studio
GitHub is fully intergrated with Visual Studio 2015.
Git is the preferred source control system for modular code bases, but TFS also lives on with both server and local workspaces.
Git is the natural evolution of SCMs.
View History is improved in Visual Studio 2015 with a new graphical view.
That's nice for people with command line phobia, such as myself.
Sync does a pull, merge and push, all in once.
Commits are immutable, but you can create a new history. This can be restricted in TFS using permissions.
Be mindful of your line endings, use a git attribute file. Default gitattribute and gitignore files are available from github.com.
The average number of commits per push is not surprisingly one.
If you don’t need branches, it’s because merging is too painful in older SCMs. Branches in git are just a pointer to a commit and remains in place in the file system. Thus, feature or personal branches is the way to go. Even if you work alone on a project.
There is no magic, only Git.
Posh-git is a good CLI for git on Windows.
Tags is also a pointer to a commit, but stays in place. Perfect for tagging releases. They can now be created from the History view in Visual Studio 2015.
Phil thinks rebase should be called graphing. Creating a linear history instead of the messy, branched real world. And you can rebase directly from Visual Studio 2015.
Visual Studio 2015 supports graphical merge, even in git. The conflict window only shows the conflicts, not the changes that worked.
Use pull request for merging into master and get a code review at the same time. This is best practice within Microsoft.
Microsoft and GitHub both enforces two factor authentication.
.Net Compiler Platform (“Roslyn”): Analyzers and the Rise of Code-Aware Libraries
A code-aware library is a library that provides guidance on correct use through embedded tooling and operates on the user’s code in real time.
This is the spiritual successor to FXCop. The most useful rules are already available on nuget.
The future is here.
The analyzers are also run inside the preview window.
Real preview!
By installing the C# essentials extension, an analyzer with a code fix project template is available. The boiler plate is a type name checker which checks that all types start with upper case letters. It also supplies an action to camel case the names. Such a project can be debugged, starting a new session of Visual Studio 2015.
Your first decision is what languages the analyzer should support. I recommend C#, off course.
The AnalysisContext contains the state of the analyzer, will be huge. You can write your code at debug time to better understand the content. Thanks edit and continue. “It now actually works”.
It's just code :)
For code fixes, a CodeFixContent context is provided. Using async operations to prevent blocking the UI thread.
Roslyn syntax tree visualizer will help with the code generation in the fixes. The Roslyn syntax APIs are immutable.
If your action do not appear in Visual Studio 2015, delete the ComponentModelCache (MEF cache) to force a refresh.
Introduction to ASP.Net 5
Who cares about the web anyway?
ASP.Net 5 is more modular, more faster and more awesomerer. It’s built upon the .Net Core framework, is open source and can run on multiple platforms. It’s a parallel track together with ASP.Net 4.6. 4.6 is built upon the full framework.
Progress!
Node has pushed the team, and version 5 uses 90% less memory.
The core framework supports side by side deployment. Bye, bye monolith and .Net installer.
Yellow is open source.
References lives in the project.json file. Teamwork and SCM friendly. The content of the folder is included by default. .csproj-hell is a thing of the past.
ASP.Net 5 now builds itself and does not save the result to disk. The feedback loop is shorter.
bower.json handles the JavaScript frameworks. No more nuget wrapping.
Running on FreeBSD.
And on everybody's favourite OS.
Debugging Performance Issues Using Visual Studio 2015
Bad performance leads to poor user experience. Continuously evaluate performance during debugging using PerfTips, Memory Tool and CPU graph.
Debugging is now useful.
PerfTips shows you the time used between steps. Overhead from debugging is removed from the number. Utilize edit and continue and moving of the instruction pointer to test different implementations without recompiling. This works anywhere you can debug, even remote debugging and while debugging unit tests.
While looking at the CPU graph, look for spikes. It could be one core at 100%.
Memory snapshots are useful while debugging memory problems. It only shows object on the managed heap. After two or more snapshots, these will be compared with each other. The deltas can be visualized, making it easy to find the offending objects. Cycles in the reference graph is automatically detected. Remember to clear your event handlers. Snapshots can also be taken while the application is running, but the object instances can only be inspected if you’re stopped at a breakpoint.
Intelligent filtering.
The native debugger can also be enabled, thus showing you native objects in your snapshots.
A garbage collections is simulated before showing the objects in the snapshot.
The timeline tool supports both WPF and Universal Applications. A ListView.GroupStyle disables virtualization in WPF.
The Timeline tool is going to be wicked useful.
Delay loading of images and other large assets during scrolling, load only when scrolling has stopped.
CPU profiling can be xcopied and used in production in Windows 8 and later.
The Performance Wizard contains more specialized profiling tools.
What’s New in XAML for Universal Windows Apps
XAML is the way for creating UIs for Windows 10 apps. Both for C#, C++ and other good languages. No special project types for mobile or table, only Universal App. Microsoft is all in. Even the Windows start menu is built using XAML.
XAML is the way.
Controls are updated to give a more uniform look and feel across the different devices. And creating experiences native to each device.
Your views will still ned to be created separately for each platform, but the same controls can most likely be used.
Responsive view development is easer than before. XAML has its equivalent of media queries, visual state triggers. The designer will help you in the futures, but it’s not done yet.
Relative Layout is back using RelativePanel. Enabling complex layouts without losing scaling support or using multiple different layout panels. Also, more panels means less performance.
It's nice to have an alternative.
XAML performance is better in Windows 10. Coding the Windows shell using XAML showcased a lot of slow paths.
Compiled bindings are more performant than the regular bindings which uses reflection internally. And you get compiler errors when the binding name is wrong! And you can wire up event handlers without going through commands. And you can step through your bindings in the debugger.
Yes!
Composable 3D Transforms can give fancy effects with very little XAML. Use it sparingly.
Just because you can, doesn't mean you have to.
XAML can be used as custom window chrome. No more crazy Win32 hacking.
Remember to stand out from the crowd. Or don't.
InkCanvas makes ink based applications easier, but not necessarily more useful.
Or write it on a piece of paper.
The new Edge browser is the new XAML WebView. If all your customers takes advantage of the free Windows 10 upgrade… For everybody else, there is still CEF (Chromium Extension Framework).
Debugging the visual tree is available in Visual Studio 2015 without third party tools. Values can be changed and the results seen during runtime. Perfect for rapid UI prototyping.
Snoop, you are no longer needed.
Money, Fame, and Flexibility: New Extensibility for Visual Studio and Visual Studio Online
Create your perfect development environment, even if it means extending Visual Studio to support Java.
Do it for the right reasons
Extensions can be published to the Visual Studio Gallery and consumed in all editions of Visual Studio.
You can create commands, add a tool window, a debugger visualizer or refactoring options. A lot of work has gone into Visual Studio 2015 making the development easier and improving the documentation.
Visual Studio Online extensions will also work in TFS.
The version to rule them all.
Debugger Tips and Tricks for .Net Developers with Microsoft Visual Studio 2015
Debugging is hard, time consuming less fun than writing the program correctly the first time. Thus, I’ve never tried debugging myself. For my readers:
You can start debugging a process directly by using “Step Into” before a process has started. Useful if you don’t know where a programs entry point is.
Return values of methods are now visible in the Locals window. No more local variables created just for debugging purposes.
When you have multiple method calls on a line, you can “Step Into Specific” to choose which method to step into. A timesaver if there ever was one.
Using the Call Stack, you can select a point in the program and “Run to Cursors” to step into that point.
WPF now has its own debugger visualizer. It’s easy writing your own visualizers for your own data structures.
Use the DebuggeDisplay attribute to change your class’ visualization in the debugger. No more unneeded ToString declarations.
Pinning values during debugging also makes them available after debugging has finished. The debugger helps even when it’s not running.
Visual Studio 2015’s debugger now supports lambda expressions, both in the watch windows and in edit and continue. Hello LINQ!
Breakpoints with configured Actions are powerful and can now be created without opening a modal dialog. Progress. Automatic continuation enables advanced logging without littering your code with temporary logging statements.
Break when thrown now has a search box, making it easier to break at the source of exceptions without breaking the F5 key.
Other goodies:
Profiling is awesome
Timings are awesome
My favourite feature of the future
Who would want this?
Build 2015 Day 2 Keynote
DJ Microsoft started the show in front of an ungrateful crowd.
Broiler is up next.
Microsoft is truly an open and creative company now. So says the guys in the motivational video.
We're the underdogs now, thus we need you, our developer friends.
Love me some C++ in the morning. Real drumsticks were so 1990, now we have electronic glow sticks making noise.
Though the C++ was too slow and was replaced with C#.
3D printing is the future of 1$ item creation. Windows 10 is not left behind.
Print all the cooking utensils!
OData processed by the Office Graph API. The pen is just redirection.
Data as a map.
The Windows jokingly takes credit for the Windows 8 failure.
Window 1 was the best Window edition.
One design language across all the Windows 10 devices.
Really loving that pivot control on the Hololens.
A solid foundation.
XAML and C# are my favorites.
Awesome map control. One line of XAML.
Shown on the least used device.
Adaptive triggers lets you customize the UI based on the device size.
Relative layout to the rescue.
Hololens!
Where is the pivot menu?
The web just works! If you use the Edge browser. It has the best performance of the lot, if you ignore Safari.
Web apps.
There is hope for WPF! And the suckfest that is WinForms.
The bridgiest bridge.
Android and iOS apps are the future for Windows 10. Or Microsoft could use their resources on more important things and kill the phone.
There be robots.
ObjectiveC is the new C#.
Please, please, please create apps for us!
Even the presenter does not like ObjectiveC.
The look of a broken and miserable man.
Cordova beat out Xamarin for this keynote.
Must try the iPhone during the keynote.
GitHub is the new TFS.
And I love it!
The Cloud is eating both software and data. It's a hungry beast.
Convenient for Microsoft
Microsoft is a much better story teller when talking about the cloud. Cloud wins if it comes into conflict with mobile.
Even dairy farms needs data analysis in the cloud.
AI meets AI!
Cloud connected pedometers improves breeding of cattle.
Even the cloud contains code written by humans. Code with bugs.
The beard adds 23 years!
IaaS - Intelligence as a Service
Azure Machine Learning is powerful.
Drag and drop modeling using R.
It can even generate the API for you.
Live genome analysis using Azure Machine Learning and R.
And an old version of Visual Studio.
Genome app!
Do your annual checkup.
Go Norway! eSmart connected grid.
Hashtag: Norsk aksent
Pompeii in the cloud.
Spellcheck didn't expect that.
DirectX 12 demo, 63 million polygons, 8K by 8K textures.
Every hair is a polygon.
Minecraft modding live on stage.
For the kids.
You loved using Visual Studio coding with ObjectiveC, now say hello to Java.
Cringe.
A Lap Around .Net 2015
Continued innovation without breaking existing stuff is one of the major drivers to increase the modularity of the .Net ecosystem. Modular and Optimized is the mantra, making the frameworks useful in our cross-platform future.
The .Net Framework 4.6 if the compatible in-place replacement for .Net 4, 4.5, 4.5.1 and 4.5.2. WPF is the UI stack for classic desktop apps. Still. .Net 4.6 and WPF contains many performance and reliability fixes. Should now render properly on retina screens.
One of these will soon be legacy.
WPF tooling in Visual Studio 2015 is much improved. It contains Blend, UI profiling and diagnostics tools, and a UI Debugger. Less need for third party tools, and no more excuses for not doing memory and performance profiling.
Good stuff. Desktop apps might be legacy, but also 90% of all apps running on Windows on a day to day basis. They will live on for a long time yet. Windows 10 will be the next Windows XP, a baseline which we can build upon in the future.
Roslyn is now open source, using the compiler as a service has never been easier.
.Net Native is used in universal apps when compiled in Release mode. The compilation gets another step, the VC++ compiler. Thus you get native performance, and managed productivity. Faster startup, less memory usage, better performance.
Microsoft continues its partnership with Xamarin and Xamarin’s tooling is neatly integrated in Visual Studio. Even the iOS and Android visual designers. You still have the choice between Portable Class Libraries or Shared Libraries for your cross-platform common code.
Nothing like a Mac in a Microsoft conference.
ASP.Net 5.0 is cloud-ready and the micro-services book has been read. Smaller footprint and more modular implementation. Nuget is used to import the different functionality. You need only what you use. Since .Net Core 5 can be run in-app, side by side with other versions of .Net, you need this .Net version to get the full feature set.
As with all other modern things, dependencies are defined in a .json-file, enabling collaboration with non Visual Studio users.
.Net Core 5 on Linux is deployed side by side with your application. XCopy deploy FTW, also for a framework. No UI-stack. Yet.
Porting .Net Core 5 to Linux and OS X took 6 months.
The Apple logo show by a .Net application running on Ubuntu.
Maximize Your Coding Productivity for Apps, Devices, and Services with Visual Studio 2015
New SKUs: Community (Free), Professional (everyone else) and Enterprise (supersedes Premium and Ultimate). This is really good news. Ultimate had many useful features which now gets into the hands of more users. I’m looking at you Code Lens.
Xamarin support is now available out of the box. Updates are smaller and more regular.
Signing in to Visual Studio I snow more useful, and you can sync your settings to multiple accounts at the same time. For instance, both your work and personal accounts can share your settings.
Retina-support is here! All icons reworked.
Finally! It's hard to create beautiful apps using ugly tools.
You can also save and load your window layouts, easily switching between them when moving from a multiple monitor setting to a laptop. Also, pinch to zoom now works as expected.
Peek Definition lets you see definitions in place while reading code. You can also navigate down through the rabbit hole without losing your place in the code. This works with XAML-styles too!
See details without losing your place in the code.
Code Lens works with all files now, showing source control history for the file. And is available in the Professional edition.
ReSharper light bulb fixes are now properly stolen and multiple fixes are available. Redundant code is dimmed, and fixes can be previewed before you apply them. JetBrains should be proud. These are created using Roslyn analyzers, and both the detection and fixes can be created by third party developers. Such as me!
Code Analysis can now be viewed in the Error List. This is more natural place for such messages, and they can naturally be filtered from regular errors or warnings. All error codes can be clicked, taken you to relevant documentation for that error. Or automagic Bing searches for the error if no documentation exist.
Bing is integrated in the IDE and you can search for code samples based on keywords. Cargo Cult programming has never been so easy.
Build 2015 Day One Keynote
Day One started with a long winding trek to the light that is the Build 2015 keynote.
Light at the end of the tunnel.
Satya's first demo contained the Surface, a pen, a musical C# and F# joke and off course, an index out of bounds error.
You mean there's more to F# than being a hipster programming language?
The Gu presented Azure as the only hyper cloud solution with more data center locations than Google and Amazon combined. Also you can leverage your existing skills, even Linux and JavaScript.
THIS IS THE BEST CLOUD!
Next was the CEO of Docker, Ben Golub, Docker for Windows is on. Like Donkey Kong. "Choose the best damn tools for the best damn application. And run it on any server". Love it!
Minecraft Docker container. Check! Thank you Mark.
Publish Docker container right from Visual Studio 2015. Check!
Attach the debugger from Visual Studio 2015 to a running Container and hitting breakpoints. Container running nix and .Net Core CLR.
Also, run the .Net Core CLR on OS X.
Mark is pushing his second favourite company.
Hanselman is here! Showing Android app written with Apache Cordova running on the built in Android emulator from Visual Studio. Nice.
Android simulators are more plentiful than JavaScript-frameworks.
Visual Studio Code on OS X!!! Mind suffiently blown! Thanx Scott!
Written using Electron.js
OS X in a Microsoft keynote. The tables have truly turned.
And on Ubuntu!
Tux watches as hell freezes over.
SaaS - SQL as a service. SQL is not dead, it's in the cloud.
Azure Insights is looking awesome. "Cortana, should i do a 10% promotion"?
Azure enables JustGiving to create iRobot charity giving intelligence.
OS X Leopard wants its wallpaper back.
Now comes the more boring stuff. Office with a SAP-plugin. On iPad! I take back the boring part.
The iPad even makes SAP better.
Every major modern application needs a solid extension model.
Uber extension in the iOS edition of Outlook.
And REST-endpoints.
If you're seeing JSON, you're doing something right.
Memo to self: disable drug dealer notifications while presenting on stage.
Even Satya wants the iPad Air 2. Should've been gold though.
Windows 10 is a new generation of Windows. Mobility across devices. Benefit the user.
WaS: Windows as a Service. To 1 000 000 000 users.
1 Billlllllllllion!
Windows Store, please make it work this time.
These are the hopeful eyes of a dreamer.
Universal Apps is the next big Bing, I mean thing. Great support for Web applications.
Universal platform capabilities are now available for .Net and Win32 applications. DIPS is ready for the Windows Store. Running isolated from the rest of apps.
Photoshop running as a Universal App, with some camera magic added in too.
Windows Phone now comes with Android! Run your Java or C++ Android apps on Windows Phone. Is Nice!
Or your ObjectiveC iOS app! Compile and link using Visual Studio on Windows 10 :)
Please make apps for our platform. Pliz!
Great syntax highlighting for ObjectiveC, highlighting all of ObjectiveC's poor syntax. Lol.
ObjectivC is not prettier in Visual Studio
One more thing. The Prize of the show is an HP Spectre x360.
It has 5 screens!
Joel showing of Aero Windows 10. Brings back memories.
The start menu is like a Windows Phone
And now the Windows 10 login screen, direct with app commercials from the Windows Store.
Project Spartan is now Microsft Edge. Memo to self: never use your internal code names in public.
Looking over the edge of the world.
RES (Reddit Enhancement Suite) is available for Edge already.
Windows 10 phones are omnidevices, becomming a PC when a keyboard and mouse are connected.
It's a phone. I mean it's a PC!
Continuum is Handoff on acid.
People, not devices, are mobile. Bring on the Holograms!
The future is very intense. And somewhat angry.
Microsoft Bob 2.0! Windows Holographic platform.
Look at the puppy!
Hololens is really cool in a professional setting.
View real physical objects in a greater than real detail.
No Phone or PC required.
Microsoft is running a Jony Ive design video, without Sir Jony. And not just on a white background.
Not pure enough! Where is the white room?
All Universal Windows Apps can be holograms.
You can now sumperimpose a virtual robot on a real one.
Build 2015 Expectations
I'm writing this from the SAS Lounge in Copenhagen, en route to San Francisco and the 2015 Build conference.
Microsoft is doing a lot of right things these days. They're moving away from their strategy tax burdened old strategy of "Windows first, no matter the cost", embracing the fact that the Windows monoculture is dead and will never return. "Cloud first, mobile first" and SAAS are the beacons of hope for a company that realises that its name is Microsoft, not Windows.
Ironically, my day to day work includes a huge desktop Windows client with internally hosted services. No shiny Azure cloud stuff, no Universal apps. Yet.
I look forward to see Microsoft vision of the future. Not just for new apps and services, but for large, enterprise applications traditionally hosted on site.
Thus, my primary interests for Build 2015 will be
- The future of WPF and the Windows Desktop. Are we stuck with Win32 forever?
- Web vs. XAML and Universal Apps.
- Partitioning of the .Net Framework.
- Deployment of tomorrow, OneGet, Docker and other goodies. Bye, bye MSI.
- The porting of WPF and Visual Studio to OS X and support for the entire Xamarin stack free of charge.
An answer to 4 of 5 will be good enough.