Keynote (8:15 - 9:30)
It’s finally happened. .NET Core and ASP.NET Core are open source and run nearly everywhere. Microsoft developers work in the open on GitHub and iterate quickly. How did this happen? Join Scott Hanselman as he delves into 15 years of .NET history and what it took to reach this point. What do YOU need to know about .NET Core and ASP.NET Core, and how does it work?
Session 1 (9:45 - 10:45)
With all the buzz around Microsoft’s revitalized ASP.NET MVC Core framework, you may wonder what has changed since your “legacy” ASP.NET MVC application was written. Sure, there are new framework features and development tools available; but, which of these things are actually worth adopting and when? Should I stick with ASP.NET Web Optimization for bundling & minification, or should I use Gulp? What’s the difference between a tag helper and an HTML helper? Which package manager(s) should I use to acquire the requisite bits and assets? How does the framework support dependency injection for my controllers? Should I target .NET Framework, .NET Core, or both? Lend me 60 minutes of your time, and I’ll answer these and some other frequently asked questions. You’ll leave with a clearer picture of a practical migration path for your aging MVC application.
Are you mystified by SQL Server performance? Do you wonder why sometimes your SQL statements runs fast but other times, they run painfully slow? Do you wish there was a pragmatic set of steps you could go through to troubleshoot performance problems that didn't require you to have a PhD in database internals? If so, this talk is for you.
In this talk, I'll describe database performance from a developer's point of view. I'll show how you can accurately measure the performance of any SQL statement, how to understand what the statement is doing when it runs and what you can do to improve this performance. I'll show how the right database indexes help SQL Server locate the data your application needs very efficiently and what you need to know to create effective indexes for your application. Finally, I'll discuss how you can use built in capabilities in SQL Server to find your worst performing statements and tables that are missing indexes so you can quickly find and solve your biggest performance bottlenecks. At the end of this talk, you will no longer regard database performance as black magic, but instead be able to confidently analyze and solve any performance problems you encounter.
The modern world of concurrency can certainly be confusing! This talk is a gentle introduction to the many forms of concurrency. In this talk, you'll learn which types of concurrency are appropriate for which scenarios.
Most developers have heard of parallelism, so this talk starts with parallel computing, showcasing the Parallel class and Parallel LINQ (PLINQ).
The next stop is asynchronous code. Asynchronous code is a totally different kind of concurrency than parallel processing, and the async and await keywords enable maintainable asynchronous code in modern applications.
This talk will also introduce you to TPL Dataflow. A beautiful mix of parallel and asynchronous techniques, TPL Dataflow is a little-known but extremely powerful library.
The last technology covered is Reactive Extensions. This talk will cover the concepts behind Rx and the most useful operators. This session is entirely practical; the phrase "mathematical dual of IEnumerable" does not appear on any slides.
When considering how to build iOS and Android applications, many people think that the native languages, Objective-C, Swift, and Java, are the only choice. However, over the past few years, an entire new ecosystem of platforms for building mobile applications has emerged.
Xamarin is unique in this space by offering a single language – C#, class library, and runtime that works across all three mobile platforms of iOS, Android, and Windows Phone (Windows Phone’s native language is already C#), while still compiling native (non-interpreted) applications that are performant enough even for demanding games.
In this talk we'll give an introductory look into what Xamarin is and how you can begin writing cross-platform mobile apps using the language you know and love - C#.
Session 2 (11:00 - 12:00)
"Make it so, number 1!" The ease with which these Star Trek commands are done is an ideal, but environment in which we work isn't nearly as automated! We have development and operations teams cobbling together data from disparate systems, talking to each other with chat streams like Hipchat or Slack and then trying to command complicated infrastructure. This often becomes chaotic during incidents and leads to errors. What if you could capture a piece of that Star Trek world and surface key information, issue key commands and communicate all in a single medium?
In this talk, I'll explain how to take the chat client you may have today and incorporate it into deployment, monitoring and support streams. We'll cover the basics of infrastructure management and demo how to integrate external tools including a a detailed technical implementation of creating chat command and designing key incoming alerts. I'll also highlight the benefits to your team like integrated security and a single combined source of truth that can be invaluable during retrospectives or critical support situations. Additionally I will cover the common dysfunctions and resolution tips that arise from leveraging a chat tool as a primary information source. Learn to combine communication and technology into one harmonious stream of information!
In .NET, if your user permissions are simple, you’re in luck. Access the IPrincipal for the current user, call IsInRole(), and you’re done in about 3 lines of code. It works great…until it doesn’t and then you’re hosed.
When your application’s user permissions model starts getting complicated, you’ll instantly run into problems with .NET’s role-based security. The good thing is that it’s not that hard to write your own custom authorization system.
In this session, we’ll start by discussing what role-based security is all about and what it’s limits are in a typical ASP.NET or WebAPI application. From there, we’ll start going “off road” to talk about how to design, build, and test custom authorization schemes that handle more complex authorization scenarios. Along the way, we’ll talk about how to handle tricky details like user administration, creating arbitrary logical groupings of items & users, load testing your security code, and (most importantly) how to make all this code maintainable in the long term.
As developers, we are asked to absorb even more information than ever before. More APIs, more documentation, more patterns, more layers of abstraction. Now Twitter and Facebook compete with Email and Texts for our attention, keeping us up-to-date on our friends dietary details and movie attendance second-by-second. Does all this information take a toll on your psyche or sharpen the saw? Is it a matter of finding the right tools and filters to capture what you need, or do you just need to unplug. Is ZEB (zero email bounce) a myth or are there substantive techniques for prioritizing your live as a developer? Join Scott Hanselman as we explore this topic.
Add filters, blur, emboss, the gooey effect, and many other fun effects to html elements without plugins. This course will provide a brief introduction to what is possible with svg filters, and a deeper dive into some of the more complex base components and how they tick. After this course, you will think twice before jumping to an image editor.
Lunch (12:00 - 1:15)
Lunch will be served in the Grand Salon.
Session 3 (1:15 - 2:15)
The popularity of using containers and tools like Docker for managing and deploying workloads in an agile, massively scalable way has not been missed by Microsoft. In this session you'll be introduced to the many ways Microsoft and Azure are supporting containers, as well as new Windows containers built-in to Windows Server 2016.
Revolutionary technology can lead to disruptive innovation. We are witnessing the dawn of augmented reality and the Microsoft HoloLens is leading the way. The HoloLens provides a new landscape for us, as developers and innovators, to break new ground with more emerging experiences.
This discussion will briefly introduce tools for the HoloLens that are often not shown in the videos you may have seen and then spend the majority of time on various developer scenarios. We will go beyond the built in apps, look at the development environment, choices you have and what it is like creating our own apps and games.
The stereotype for software developers is that we're bad communicators. That we're all introverts. That we'd rather spend our time interfacing with computers than working with flesh-and-blood humans. Code is logical and predictable. People, by contrast, can feel absolutely chaotic. We're complex, complicated, emotional.
But software development is an activity performed by people and for people. We have to communicate with humans in myriad ways every day. Improving our communication skills can have a substantial effect on our job performance and satisfaction.
We'll talk about the importance of good listening and how to get better at it, how to identify and defuse conflict scenarios, and how to level up our influence and persuasiveness.
Have you ever heard of a “magic mirror”? And no, I’m not talking about Snow White. I’m talking about a real-world mirror, with smarts… Lend me 60 minutes of your time and I’ll walk you through my experiences of developing my magic mirror. It’s running Windows 10 IoT Core, on a Raspberry Pi 3. It was written in C# as a Universal Windows Platform (UWP) application. My magic mirror boasts facial recognition and the Microsoft Cognitive Services (Emotion APIs), plays music, updates with current local weather and forecasts, displays a clock, and your upcoming aggregated calendar events.
Session 4 (2:30 - 3:30)
Grand Salon A
The beaten path of developing with Xamarin.Forms is well marked, but can be a bit narrow. As soon as you need to leave it to perform something out of the ordinary you can find yourself lost deep in the woods, far away from home with night falling quickly and a heavy fog settling in. This session will be your map to get out of the woods and back home quickly by exploring the more advanced topics in Xamarin Forms. Learn the techniques to boost the performance of your app to get out of the woods fast. Find some of the forgotten tools that Forms already provides and how to combine them together to create a super tool that can bind a command to any control’s event! Finally, we’ll customize the UI without having to resort to creating a renderer. At the end of this session, you’ll never get lost in the Xamarin.Forms forest again!
Grand Salon B
Building a SaaS product in the cloud is more complicated than choosing a hosting platform. IaaS or PaaS? What are my data storage choices? How do I implement logging across resources? How do I secure my environments? Which monitoring tools should I use? Should I cache? What are my options for authentication? What are Blobs and Queues? This session will discuss one team’s journey down the Azure path; separating the good choices from the bad.
Code is communication. Between you and the compiler, definitely. But more importantly, code is communication between you and the next developer. Code that communicates poorly is code that cannot be maintained, and code that cannot be maintained is costly.
In this session, we'll discuss ways to be a better communicator in your code. We'll look at examples of code that might leave you scratching your head, and talk about ways to improve these examples. We'll talk about some principles of effective verbal communication, and look at how these relate to the fundamental principles of writing clean code.
If customer facing issues are your top priority, then you already adhere to the primary principle of Exception Driven Development.
It's a pretty simple concept: Collect application data, especially regarding errors and crashes, and then focus on fixing those problems that your users are actually experiencing. Join me for 60 minutes and I'll walk you through what you're doing wrong with your current log collection approach, and how you should be doing it. Additionally, we'll cover visualizing errors in a more meaningful manner that eliminates all the noise.
Session 5 (3:45 - 4:45)
Grand Salon A
There’s an obvious problem with diversity in tech, and we talk about it- a lot. It seems to me that we can talk about the problem, and the leaky pipeline and the lack of applicants until we’re blue in the face. Instead of that, let’s talk about actionable ways to lower barriers, reach over, and help people across. I’ll dive into how the Madison Women in Tech, a meetup of a whopping 500 members, reaches its membership, and explore options for mentoring . Last, I’ll dive into how our developers are working on a pro bono development partnership with the pen pal organization, Chins Up, to make mentoring a digital endeavor.
Grand Salon B
This demo-paced session will walk attendees through the end-to-end process of creating a Continuous Delivery pipeline using Visual Studio Team Services (VSTS). We will check code into a git repo, create an automated build that compiles our code and runs our unit tests, and create a release pipeline to promote the application and run automated smoke tests through a series of Azure environments using VSTS. And we will do all of this in an hour.
A main focus of mine has been leveraging the Azure platform to help clients explore the possibilities that cloud computing can afford them. Azure has been a great experience and showcases how Microsoft has evolved and matured into a much more open company willing to experiment, fail and succeed with developers and partners.
This presentation is based on my real world experience of developing with Azure functions to create a prototype for a client that will be entering a pilot launch in select markets.
A client of ours wanted us to prototype a solution that incorporated SMS using Twilio and NLP using IBM's Watson platform. Furthermore they wanted it to be scalable from the get go. Our initial approach was to use AWS Lambda's but given that our client is heavily into Azure, Azure functions seemed like a natural fit.
On our way to create the prototype, I quickly discovered the ease with which I could incorporate extremely useful constructs like Queue's and event based triggers and also quickly discovered some of the tooling deficiencies and lack of deeper documentation that could have saved me time and fistful's of hair.
Along the process of developing the prototype, I engaged heavily with some of the developers at Microsoft who were always willing to help out and also through painful experimentation discovered some techniques that allowed for the system to make sense.
I would love to share what I have learnt to allow developers to try out this feature of Azure (which I think has great potential for an on-demand scalable compute experience) and also learn from others experiences with the technology and platform. I will outline and describe some of the core technology like triggers, message queues, function chaining, stateless development, shared custom assemblies across functions along with CI/CD hooks that I used to deliver on the prototype.
This was done using C# and .NET, but explicit knowledge of C# or .NET is not required, but experience with a higher level language/runtime would help.
Happy Hour (4:45 - 6:00)
Join us for happy hour!