We've put together an amazing lineup of speakers this year. See below for some information about each speaker and the talks they will deliver.
Microservices have become the defecto architecture pattern for building services. However separating business logic into small services that operate with a single logical data set has introduced consistency challenges. Previous attempts to solve this problem like two phase commit have not been widely adopted due to availability and liveness issues.
The defect standard today is developers implementing feral concurrency control mechanism. This technique can be error prone, and often results in “Death Star” architectures which rely on chained calls to enforce application invariants. These architectures become more complicated over time, and are difficult to modify and extend.
In this talk I propose a new solution for this problem, Distributed Sagas, a protocol for coordinating requests among multiple micro services, while ensuring application invariants.
"Starting with the ‘domain-specific language’ movement, and bolstered by the Pragmatic Programmers’ suggestion that programmers should learn a new language every year, the notion of ‘polyglot programming’ became something of a critics’ darling when talking about career paths. But somewhere along the way, it feels like the original intent has been lost, and the focus has shifted to ‘learn to program in as many languages as possible’.
If you’re a software developer, and you’re currently fluent in one language, are you doomed to irrelevancy? Is it actually better to be a ‘jack-of-all-languages, master of none’, or is there some kind of happy medium in between? And if so, how do you tell when you’re in it?
In this talk, a polyglot, polycrepido and polypraeclusio programmer will talk about his experiences living across multiple languages, platforms and storage systems. It’s not all been a bed of roses, you’ll find, but there are advantages, up to a point. More to the point, by the end of the conversation, you’ll have a better idea of where you want to fit on the ‘polytechnical’ continuum, and how to make the necessary steps to get there.
Reality operates on a set of rules. Through replication, Life has evolved to exist inside of these rules. By utilizing mutations, it is possible to evolve a neural network that is capable of operating inside of an artificial environment.
C# is very popular with game developers, and the ways it is used in game development can be very different from "regular" development. On this tour of game development tools, techniques and practices, we'll look at various scripting techniques and approaches used by the industry, from component based programming to data driven design, dynamic programming tools and functional programming approaches to enforce a hard separation between the game engine and the game designers that are making the games.
Well look at how the Unity Editor uses C# to create a dynamic programming environment where you make your game by extending the editor that you're using to build the game, how Naughty Dog made the Uncharted series, and the interesting lessons that can be drawn from how game developers approach programming and how the constraints of games encourage different ways of doing things.
By the end of this talk you should have a better understanding of how games are built, a broader perspective of development techniques and approaches, and a few tricks under your belt in case you're looking to make games.
I'll give you an overview of what .NET Standard is, why you should care about, how it works, and how you can use it to build & ship kick ass libraries via NuGet.
We're in the midst of an immersive computing paradigm shift with virtual & augmented reality that's moving us from the Information Age to the Experiential Age. Kent Bye has interviewed with over 750 VR/AR pioneers over the last three years on the Voices of VR podcast, and he'll be sharing some experiential design patterns to help you make sense of these new spatial computing metaphors as well as an elemental theory of presence framework.
Parallel and asynchronous programming has an important place in solving real world problems of efficient processing of constantly growing data and need for lower latencies. Sometimes, regular means of dealing with concurrency are not enough and in this talk we will look at Hopac. Hopac is F# library that makes it easy to write correct, modular and efficient parallel, asynchronous, concurrent and reactive programs. We will see in which cases Hopac is faster and more useful than existing F# solutions for dealing with parallel and asynchronous computations. Looking at the examples, audience will also see why F# is a great choice for parallel programming.
Does your unit, integration, and manual testing scale? Did that nasty bug that you thought you fixed reappear? Do you lack manual testers? UI automation can assist with these challenges as a supplement to your quality process.
Let's look into the reasons why you might want to consider adding UI automation testing with a case study of how the GitHub for Visual Studio Extension does this with Coded UI Tests.
It has never been easier to get a new person writing their first few lines of C#. DotNetCoreKoans is intended to be used as a teaching tool for beginners. The overall goal is to get someone having fun learning and writing C# in just a few minutes. It can be used solo, in a class setting or a coding dojo.
In this session, I will introduce the project along with the confluence of people and events that inspired it. Then I'll cover holes in the existing code base and how to contribute to the project. Finally, after the talk I will facilitate a hacking session to add new koans and features focused on first time OSS contributors.
gRPC is a high performance, language-neutral, general RPC framework developed and open sourced by Google. Built on the efficient HTTP/2 standard and protobuf serialization protocol, gRPC brings many benefits such as bidirectional streaming, flow control, header compression, multiplexing and more. In this session, you will learn all about gRPC and how to use it for efficient intra-service communication for your .NET microservices.
There has never been a better time to be aware of the benefits of the .NET OSS ecosystem. However, some in our ecosystem may be struggling to catch up, and this great "new" world may feel like whiplash. My talk seeks to define levels of open-source awareness/maturity as a spectrum so that users can take it back to their companies and move them toward the next step.
I hope to coincide this talk with the launch of a web site which I've been thinking about since Fringe 2016. This web site will also be open-source. I hope it can become a vehicle for a public, community-driven push to expand contribution & appreciation of OSS in our community.
With the release of .NET Core, the long-awaited dream of running .NET natively on Linux is finally here! Even better, .NET Core has arrived just in time for the coming container revolution!
In this talk I will be covering getting started with .NET Core on Linux, including a progressive approach to introducing Docker starting with CLI and tooling all the way up to a fully containerised application in a short, but practical development scenario.
In this session, we will get started with a basic Hello, World! in C# on a Linux host and demonstrate how Docker can be used not just in production, but also during development to not just simplify the Linux development experience, but also to enable powerful new capabilities including cross-platform scripting, seamless scaling, reproducible builds and simple testing.
This talk will be focussing almost exclusively on developing on Linux so is perfect for .NET developers new to the platform as well as Linux gurus who may not have gotten their hands dirty with .NET Core yet.
We started Orleans at Microsoft Research in 2009 as an experiment attempting to create a system that would qualitatively improve building high-scale cloud services, “Ruby on Rails for the Cloud” how we stated the goal then. The project eventually shaped into a distributed actor framework, and gained initial credibility via production usage in high-scale services for AAA games. The virtual actor model invented by Orleans got cloned for JVM and inspired a cross-platform implementation of it, a rare mindshare success for a technology that originated in the .NET ecosystem.
Open-sourcing of Orleans in 2015 unleashed the power of contributions from the vibrant global community, and made Orleans a backend technology of choice for a wide range of users. The continued collaboration with Research keeps bringing major new features: geo-distribution, ACID transactions, indexing, to the point that people started refer to Orleans as a “Distributed Actor-Oriented Database”. I will talk about the evolution of Orleans, lessons we learned, where it is now, and where it is heading.
TDD won’t save your lunch, microservices are a bad idea, do repeat yourself, statics are great, upfront design is crucial, put dependencies into git, concatenate SQL strings
Come in if you want to challenge everything you ever believed in, and remember, the only best practice is to remember that there are no best practices!"
Catch up with the latest goings-on in the world of Mono! We’ll start with an overview of the state of the runtime today, and the kinds of scenarios in which it excels. We’ll look at the ongoing work converging Mono’s class libraries with .NET Core’s CoreFX, and take a dive into the bundling, embedding and linking tooling, and some of the exciting things that they enable. We’ll finish off with a look at some of the work that’s being done to simplify the community contribution process, and some plans for the future.
CoreFX repo (http://github.com/dotnet/corefx) is a large repo with unique challenges to handle bugs, contributions, triage issues, etc.
Its size is a challenge to monitor due to high traffic. I will describe some of the key challenges we encountered and how we handled them:
How we implemented a distributed monitoring model, with distributed responsibilities per repo areas. What other challenges it brings for us, repo maintainers, and to our community interactions.
How we respond to new API proposals, which APIs we take and which we don’t. Evolution of our understanding which APIs belong into CoreFX repo.
How API usage data helps us balance perf improvements against code complexity. Why is it sometimes better to not take a perf improvement into the code base.
How being open-source is shifting our engineering culture and challenges our engineering practices and responses on GitHub.
"Have you ever watched the moon rise on the horizon and thought, ""Wow! I've never seen the moon so big!"" Sorry to tell you, but the moon isn't actually bigger. The moon has the same physical size the entire time in the sky, even on the horizon. What you are experiencing is a type of ocular illusion called the moon illusion. Google it!
Just like the moon illusion, there are other psychological traps we developers need to be aware of when writing dev tools. For example, color does not exist. There is no consensus what ""red"" actually looks like, because there's no way to compare our subjective experiences of what we actually see when the ""red"" wavelength hits our eyes.
This is *not* a talk on proper UX design. Instead, this talk will explore what goes wrong cognitively when we try to design our own dev tools and will offer suggestions to avoid falling into the most common psychological traps for developers."