Session voting is now open. Please read through the sessions and vote for those that you would like to see on the agenda.
As a developer I wanted to get an understanding of machine learning and with the arrival of Azure Machine Learning I got my chance. This talk will go through from a developers perspective the highs and lows of machine learning. I will introduce the tools, show how easy it is to use and then talk about what us as developers can add to the process
Nowadays AI is all the hype, but what many might not know is that AI is an established discipline originating from a paper from Alan Turing in the 1950s. In this talk I will present the historical milestones of AI from the originating paper up until present days. In addition we will look into the crystal ball in order to see what the future might have in store.
We will start out our journey by looking at what happened in a workshop in Dartmouth in the 1950’s which started it all. Then we’ll be reviewing a number of areas where AI initially was put to use between 1950-1970. We’ll cover the AI winter in the 1980’s and its’ reasons. In the second part of the talk we’ll cover applications and milestones from the 1990’s and onwards.
Finally we’ll look into the crystal ball and try to see where AI might takes us in the future.
Sports betting is a field that exposes some of the weaknesses in Machine Learning. In this session I will illustrate some of these weaknesses and show you how to mitigate against them in your own machine learning models.
In this talk we'll look at:
Web Assembly has been on the tip of everyone's tongue recently with the unveiling of Blazor, Microsoft's foray into bringing C# and ASP.NET into the browser.
In this talk we'll start with a deep dive into the history of Web Assembly, what it is, how it works and how other languages such as Rust and Go are battling for developer mind share by offering compelling support for Web Assembly as a compilation target.
Next we'll load up our IDE and dive into Blazor, Microsoft's attempt to change the shape of front end development in ASP.NET via Web Assembly.
Over the last couple of years, I've presented 20 tricks and tips that I've found invaluable as a Tech Lead. But in this session, I want to turn things around and look at applying some of those to solving specific issues that are common within many software development teams. I'll be taking lessons learned from the last 2 years of a major development project and using them to illustrate my points. We'll look at managing your BAs and PMs and how to balance their need to understand exactly how long everything takes versus your team's need to not be over-pressured by artificial deadlines.
We'll see how a structured approach to analysing problems encountered in LIVE can make everyone's life easier, and how to prove whether the problem is (or is not) the fault of your software. And how to handle that inevitable case where it is.
And we'll look at the problems of implementing uniformity across multiple code-bases and multiple teams delivering multiple releases of multiple features... and where getting your tooling right can give the biggest benefits.
Amongst other things...
There's so many parts to Azure, it's sometimes hard to decide what to use and when.
Do I use TableStore or CosmosDB? Would BlobStore be better? Should I host a full-fat .Net service in a VM, or stand up an ASP.Net Core WebApi? What about functions? The choices are myriad.
In this talk I'll describe how at Landmark we made these kind of decisions as we implemented some new features in our product. I'll talk about the questions you need to ask to make those decisions, where we went wrong, and how we succeeded in the end.
I'll describe in detail how we used CosmosDB, Azure Functions and Service Bus together to provide a Compliance Audit trail feature that would scale properly, work reliably, be trivial to use, and that wouldn't break the bank.
We will take a closer look at why we care about async, how it works and then deep dive into async issues.
By the end of this session we will understand what SynchronizationContext is, when to use ConfigureAwait, how deadlocks occur and how to detect and avoid them.
Whether you're building web apps or shared libraries, there will be something for everyone.
Machines are doing things today that were unthinkable even a few years ago. From computer vision, to understanding human conversation, to translating text, or even generating art; they're encroaching on domains previously thought to be strictly human realms. The technology behind this is actually fairly old; neural networks have been around for decades. However, modern hardware capabilities have made them technology feasible to such a degree that they can now drive cars.
Tensorflow is Google's open source framework for deep learning. It makes it relatively straightforward to apply these techniques. In this session, we'll cover the basics of image recognition, and use Jupyter Notebooks, and Tensorflow to apply it.... with a dash of GPU processing to boot.
We will cover a practical example writing our web assembly using Rust. We will go through everything from writing your web assembly code to publish it as a npm package and finally use it in an existing web application.
In the world of microservices (yes, there's that buzzword again!) and distributed systems we often find ourselves communicating over HTTP. What seems like a simple requirement can quickly become complicated! Networks aren't reliable and services go offline. Dealing with those inevitable facts and avoiding a cascading failure can be quite a challenge. In this talk, Steve will explore how we can build .NET Core applications that make HTTP requests and rely on downstream services, whilst remaining resilient and fault tolerant.
This session will focus on some of the improvements which have been released in .NET Core and ASP.NET Core 2.1, such as the HttpClientFactory and the new more performant socket based handler. Steve will identify some HTTP anti-patterns and common mistakes and demonstrate how we can migrate existing code to use the new HttpClientFactory to work more correctly with HttpClient instances.
Next, Steve will demonstrate Polly; a fantastic resilience and transient-fault-handling library which can be used to make your applications less prone to failure. Now integrated with the Microsoft HttpClientFactory; wrapping your HTTP calls in retries, timeouts and circuit-breakers has never been easier!
If you're building .NET services which make HTTP calls, then this talk is for you!
Historically integrating different systems has been challenging and you have needed experts to help you build even the simplest integration. Microsoft has introduced its Azure based offerings to help take some of the complexity out of integrating to allow you to build your own personal workflows. This talk will introduce both Flow and Logic apps, show you where to use each and how you can migrate from Flow to Logic Apps.
Bots are exciting and they can be very helpful tools that you can use to communicate inside your organization or with your clients. They can answer frequently asked questions, create meetings with your co-workers or remind you that you need to follow up with a client. During this session we will cover how to create a bot using the Microsoft Bot Framework, what development options we have, how to add more intelligence into the bot using various Cognitive Services and then finally, how to install the bot into your environment (SharePoint Online, MS Teams, Skype for Business) and then some general tips for long-term maintenance. Come and join the bot revolution! Or at least join this session…
It's taken a while but Web Components change everything.
In this talk, I'll explain what they are and how to use them in your existing apps.
You don't have to be a super hero, to make a difference to our planet. Just a bit of programming skills will suffice. We can't imagine our lives without electricity. We use it to have light and heat, keep our food fresh, we work with computers, use mobile phones, and don't forget entertainment! We need electricity for driving cars, even more now with EVs. Electricity is generated mostly with fossil fuels, we can use nuclear power and hope that nobody makes a mistake and people do make mistakes. That's why we build wind farms, solar panels, hydro power plants, but we can't force them to generate electricity when we want. They are not aware of world cup finals. So how can we make sure, we use green power more? We need to store electricity when they can generate it, and use when they produce less, but storing electricity is hard. We have to change the way we consume energy, but it has to be automatic, so people wouldn't even know. That's what we do at OVO Energy, using IoT devices to change the power usage patterns, create virtual power plant, which can be used when the demand exceeds supply. I will show you how we use Azure IoT Hub to do that, you don't have to be C or C++ developer to work with IoT.
Do you lack confidence in your tests? Do you practice TDD and maintain a high level of code coverage but still feel there's something missing?
I know I felt this way, which was why I was intrigued to hear about mutation testing for the first time about a year ago. This is a powerful yet under-utilised technique that highlights gaps in your testing that code coverage analysis cannot.
Join me to hear about my experiences using mutation testing across different code-bases. I'll describe how it's helped increase test quality, change developer behaviour for the better and also some of the pitfalls to avoid.
I'll also talk about how I ended up writing my own mutation testing tool for C# and what I learned along the way.
By the end I hope that you'll be inspired to give mutation testing a try in your projects, armed with the knowledge of how to get started.
Pretty much everyone use telemetry in software systems today – to understand where things break down, where performance or load are issues and if our components are working as expected.
But this is just a fraction of what you can do with telemetry. Telemetry can help you understand why the adoption of your new ‘market breaking’ feature is not as expected, it can become a critical business tool to gather information about how to provide the most value to your users and how to make minimum viable products successful. With the help of a bit of artificial intelligence it can even prevent outages or explain sudden load surges so that you can plan in advance.
This session is all about this: how telemetry helps the business, and how it can really become a major player for your development teams.
These days there is a strong misconception in the software development world – DevOps equals to ‘the Cloud’ (and inherently greenfield projects). I strongly disagree.
Given that DevOps is about best practices (aided by technology) nothing prevents you from bringing these practices in your own, on-premise world. I’ve heard too many times this ‘equation’, and in hindsight many companies would benefit from a DevOps approach even for internal, ‘legacy’ applications.
This doesn’t mean you should be forced to use legacy technology too, at the end of the day technology is out there to help, not to force your decision down a certain path. The Phoenix Project is all about this after all…
Let’s see how to put this into practice, leveraging on the right practices and modern tools to put your on-premise application on par with the rest of the field.
In a large distributed environment your API will have more consumers than you can count. It's simply unfeasible to build a new API and then migrate all your consumers across. To borrow from The Eagles: You can check in [code] any time you like but you can never leave [legacy code behind].
In this session I will share a number of different approaches to managing your APIs that will help you decouple your code from legacy consumers so that you can continue developing it, preventing the stagnation that is inherent in legacy systems.
Research have shown that emotions play an integral role in decision making, cognition, perception, learning and more. If we want our computers to be intelligent and be able to interact with us we need to ensure that they are able to recognize, understand and express emotions. This is the basic assumption of the field of Affective Computing. In this talk I will give an overview of Affective computing and how it can be applied.
First I will give an introduction to the field starting with established findings from the field of psychology on how we best can measure emotions.
Then I will describe how the field of Affective Computing has transformed from its origin in the 90’s until now when it is an established research field. I will highlight some of the technology enablers that has made Affective Computing a hot topic nowadays and give some examples of API and services that we as developers can use as of today.
In the second part of my talk I will give some examples on application scenarios across various fields (retail, medical, education and social). After that I will be show casing what is in the front line now. I will conclude my presentation with some recommendations on how this affects us as developers going forward.
Hand on heart, how confident are you that your test codebase is up to the task? We've all got used to example-based testing where we supply known inputs and expect a known response (state). Whilst this is good for the happy path and the obviously unhappy ones, it does leave some grey areas that sometimes only reveal themselves when the code is in production. Property-based testing is a different way of testing where you validate the response against inputs that are only known at runtime. By running a large number of these tests with controlled random inputs, you can feel more confident that your code will not have as many bugs as it may have done.
In this session you will learn some strategies for determining the properties that will give you the best quality test coverage for the minimal time and effort.
Machine Learning, Data Science, Artificial Intelligence. These all big words we hear coming into our businesses lately - but what does it all really mean?! Microsoft has created a set of simple and scalable tools that any developer can use and integrate into their applications super quickly!! This session will focus on the various Cognitive Service offerings and show you plenty of demos on how to use them in your apps such as ASP.NET Core, SharePoint Framework and Flow. Come and learn how to take advantage of these awesome services for your everyday work!
Containers are really a thing, but how many organisations are actually using them in production, every day? Why isn’t yours among these?
It’s not because Containers are not reliable or too complex. It is also not because they require some special technology stack to deploy on brand new hardware – they are actually quite nimble. It is often because (like with all new technologies) there is some sort of misinformation around them.
They are actually really invaluable tools not just for new applications but also for existing ones, as they fit very well with a packaged distribution model for example.
So let’s try to shed some light on these, from a different point of view: the DevOps perspective.
Do you want to explore how to build advanced user experiences leveraging the power of the Intelligent Cloud and the Intelligent Edge?
Are you interested in both Mixed Reality and Artificial Intelligence?
In this session, we'll explore how to build a fully working Mixed Reality app using Unity, Visual Studio and the Computer Vision APIs leveraging the capabilities of the HoloLens device including gestures, speech recognition and integrated sensors.
We'll also take a look at the new Windows Machine Learning platform for evaluating trained models locally on the device leveraging the device's CPU or GPU to provide hardware-accelerated performance.
I'm going to live code a simple data-driven website using the Serverless framework on AWS. An introductory session which will leave with an idea of just how little work is required to produce a scalable web-based solution.
So you want to get started, putting together Functional code, but you don't have time for the learning curve that comes with F# or Haskell? Or maybe you're fine with them, but the rest of the team isn't ready to follow yet. Whatever the case may be, it's perfectly possible to implement a lot of the amazing features of Functional programming in C#, without the need for any new dependencies, or even any especially complicated code.
We'll be looking at:
From the docs:
The Task Parallel Library (TPL) provides dataflow components to help increase the robustness of concurrency-enabled applications.
What it actually does is give you the tools to create in-process async pipelines in a simple, structured manner.
And I'm betting that like me (until recently), this is a library you'll never even have heard of.
I'll cover the basics - Sources, Targets and Blocks - and how to link them together into useful asynchronous and parallel pipelines within your programs. We'll handle error conditions, cancellation and how to control the degree of parallelism - with samples that give you a bit more than "Hello World".
Kubernetes is all the rage now, and it's capable of many things. But how does this fancy new buzz word actually help my organisation to deliver software? In this talk I will discuss some of the key elements of Kubernetes and how they help an organisation delivery software better.
Most talks on functional programming revolve around immutability, concise syntax, perhaps higher order functions. While these are definitely useful attributes, I personally think of them as nice side effects. I find the notion of composable abstractions as a key benefit of functional programming. And I will cover some of these aspects in this talks. Come along, and (finally?) get your head around Functors, Applicatives, Monoids, Monads, and see how they can be useful to you. We will see examples from a few functional languages to best get to grips with the core concepts.
Cloud-native is an approach that fully exploits the advantages of the cloud - it's how you build and run your applications to allow easy scaling and continuous deployment. You may have seen the Twelve-Factor App methodology (https://12factor.net/) for developing applications that embrace a cloud-native philosophy but with that, there's little or no guidance on security.
Security can't be an afterthought and cloud-native is no different. This talk looks at how to approach security for an app deployed to the cloud. Can you forget about infrastructure security? Where should you focus your attention? Is cloud-native more secure?
We'll consider the similarities and differences between traditional apps and cloud-native apps. We'll look at how you can avoid the most common security vulnerabilities that affect cloud apps and we'll look at approaches applicable to both Linux and Windows. You'll come away knowing how to be more secure in cloud-native.
This will be a beginner's workshop for Docker. If you've heard of docker at conferences such as this one and want to know what all the hype is about, this workshop is for you.
We will also show how docker can help in your development process even if your company doesn't use docker at all.
Docker is a Linux tool, but you don't need to be a Linux expert, just be able to type some commands in at the command line on your OS (mac, windows, and Linux will all be catered for).
There will be some installation instructions to run before you arrive if you are planning on attending this workshop (I'll post these later). Otherwise, feel free to pair up with someone else or simply sit back and enjoy the show.
• Introduction, terminology
• Creating an image
• Running a container
• Using docker for compilation
• Using docker for unit/integration tests
• Creating services using docker-compose
C# is a great language for developing Line of Business applications but F# is even better, particularly for modelling domains. If you want to write code that expresses your requirements clearly, ensures correctness and supports rapid, and fun, development then guess what, F# does all that and more. If you have never seen an F# domain model, you are going to be amazed at how concise and readable it is.
In this session we will explore how the F# type system helps us to create domain models that we can use in any .Net application.
No prior experience of F# is necessary for this session.
As a developer, I find the most important job I have isn’t writing code, it’s shipping code that delivers value, and code only delivers value if it works. At a company without the most resources, we need to be clever, which is why we relied on Kubernetes to help automate our test infrastructure and increase confidence in our product.
Kubernetes is container orchestration - but that doesn’t mean you need to be a docker expert to take advantage of the platform. Testing is imperative to any product, but it can be hard. Long running tests can be painful, especially when running them concurrently isn’t possible because of resource constraints, with kubernetes, we can address this. Tools such as selenium grid can be difficult to orchestrate and deploy, but with kubernetes, it is significantly simplified.
Together, we’ll explore how we use Kubernetes to automate our test infrastructure and have greater confidence in our product, and you will learn how you can do the same.
While CI is now the norm in our daily workflows, deployment still has sort of an artisanal feeling – everyone does it their way, ignoring that there are several patterns and practices that can actually be re-used.
Concepts like feature flags, A/B testing or canary deployments are actually just at arms’ length, but for some reason these practices are often misunderstood, with people believing they are just for ‘the big boys’ like Amazon, Google and Microsoft.
This cannot be further from the truth, and the learning curve is actually very low. Let’s take a look at some real example from the field and learn how to implement these in your pipeline.
Should I care about Docker if I'm a developer? What are the advantages and how can it make my life easier? How painful is to port an existing application to Docker and get it to production?
These are some of the questions we promise to answer during this talk, and you'll get super excited seeing how seamlessly Docker can plug in your development experience.
We'll start from the very basics of Docker, so you will have no problems on following it even if you've never used it before.
And then we'll see how we can containerise a non-trivial existing ASP.NET Core solution and have it running on Linux, thanks to the support of Visual Studio 2017.
After executing it locally on our machine. we'll explore which options we have in order to run it on the cloud, we'll set up a CI/CD pipeline on Visual Studio Team Services and we'll deploy it to AKS (managed Kubernetes) in Azure.
In a reasonable a system (i.e. a system that helps me to understand it, to reason about it) I should be able to understand how to make a change without holding the entire system in my head. I should be able to reason where the change needs to be made and reason about the impact it will have.
I want to explore what reasonable means to me, from the processes of the team all the way down to an individual block of code. Along the way, we will encounter existing frameworks, tools, and patterns that our community has developed over the years to help us to reason about our code and processes; I feel that they have often been misused and end up creating the opposite effect, adding unnecessary complexity to how we work.
In this session I will demonstrate how you can make a chatbot by using the Microsoft Bot Framework together with LUIS (Language Understanding Intelligent Services). The chatbot will be multi-lingual meaning it will adapt in real-time according to the user’s language (i.e. switching from English->Spanish->Norwegian).
Finally we will integrate our chatbot in Xamarin Forms application and demonstrate how we can use this in a mobile scenario.
DevOps changed the way software factories work for good. Continuous Delivery did the same to the end-to-end transformation of ideas into products.
This means that Product Management's world is turned upside down. Is there a way that us, as a Continuous Delivery-focused team, can make their life easier and smoother? At the end of the day, a software team without Product Management's direction is pretty much wandering in the dark. And adding to the mix, these days users have a way louder voice than before.
This session is about matching requirements of PMs with the tools and practices Continuous Delivery uses, with solid, shared architectural best practices - I know it seems a mouthful, but let's see how.
Mixed reality is the result of blending the physical world with the digital world. It is the next evolution of human, computer, and environment interaction and unlocks possibilities that before now were restricted to our imaginations.
The Mixed Reality Toolkit is a collection of scripts and components intended to accelerate development of applications targeting Microsoft HoloLens and Windows Mixed Reality headsets.
In this session, we'll explore how to fast-start Windows Mixed Reality development using Unity, the Mixed Reality toolkit and the Universal Windows Platform.
In a world where distributed systems are the norm and where we are building more and more things as micro-services we need a way to keep track of what is going on. We need a central place where we can collate all the information we need to diagnose any issues we have without needing to remote onto a service and look through the log files. Wouldn’t it be good if we could also write queries and create alerts so that we know when things are going wrong before our customers do? This is where Azure Log analytics comes in. This talk will introduce some of the capabilities of log analytics, show how you can query your logs and create alerts.
I want to take a look at nature's approach to delivering a product (i.e. you are the product), the lessons we can take from it and when we should take a different approach.
What are the comparisons between nature and the world of software? How does the natural world build a successful product? How can life scale in complexity and physical size?
I want to explore what can we learn from nature's approach and what could we do differently.
Securing a web application is a challenge. The internet is awash with malicious traffic and web applications are globally accessible. Don’t make it easy for them and the baddies will move on and find someone else to annoy.
We’ll look at the risks facing web applications, the steps you can take so that you don’t make yourself a target and the things you should do to avoid becoming a data breach statistic. We’ll also look at lessons that can be learnt from mistakes that others have made.
We’ll demo some of the techniques (basic and advanced) and tools in both attack and defence with examples for any web application developer.
There are so many formal approaches to architecting solutions and people can get quite invested and passionate about one approach versus the others.
I’m going to take a step back, remember why we’re doing this and discuss a more durable approach. There will be nothing groundbreaking, nothing revelatory, rather an examination of how we can do the right amount of architecture at the right time with the right people.
I spent an incredible amount of time doing migrations and transformations (on both process and technologies), as a consultant for most of my career and then inside a product company, bringing ALM, Agile and then DevOps to people varying from who was willing to change and who just wanted to retain their 20 years old habits.
The amount of lessons I learned is massive, not just about technology itself – that changes at the speed of light – but about how to deal with change in an organization.
This is not going to be a technical session – far from it – but instead it will be a short collection of some of the most striking experiences I had since I first heard about Software Engineering.
If you're building web applications that need to expose an API to anything other than your own client, then REST is probably the right way to go. But if you're building web applications where your API is only consumed by your own SPA application then I have a better way for you.
Is Docker on your list of technologies to explore? There's no better time than now…
In this talk, Steve will introduce you to Docker, an application packaging and containerisation technology that opens new possibilities for development and deployment of your ASP.NET Core and .NET Core applications. Steve will share with you the Docker journey that his team are on, exploring their motivations for using Docker, the benefits they've achieved and the workflows they have developed.
We’ll learn about the core terminology and concepts that .NET developers need to understand in order to begin working with Docker. Steve will share demos which show how easy it is to start leveraging Docker in your own ASP.NET Core projects. Finally, we’ll look at a complete CI-CD pipeline using Docker and Jenkins. Steve will explore the AWS Elastic Container Services (ECS) architecture Madgex has built to enable rapid, continuous delivery of their microservices.
You’ll leave this talk with the knowledge you need to get started using Docker in your .NET Core projects and excited about the value that Docker can add to your workflows and deployments.
In this session Microsoft MVP Don Wibier will tell you why you should use Dependency Injection (DI) in your applications. He will next tell about how this is done in .NET Core 2 and by coding examples, he’ll show you how easy it is to start using this yourself.
I GET how to DELETE but the real question is "To PUT or to POST?" or is it PATCH? What there's more?!
After doing the standard HTTP CRUD, sometimes you need to do more, become a little more sophisticated in your manipulation of resources and add some depth to your HTTP API.
This talk will take you through some common HTTP API patterns, provide you with names for these patterns so we can talk about them, describe what the patterns are and when they are generally used, and go through working examples.
Hopefully this information will help people create richer HTTP APIs, make you REST easy and everything 200 OK.
We all talk about tech debt but we rarely think about what the metaphor actually means. Let's explore this metaphor and see how we can extrapolate it to learn more about how our actions impact the maintainability or the code we own.
The SharePoint Framework (SPFx) is newest and recommended by Microsoft technology to developer web parts and extensions that provides full support for client-side SharePoint development..., easy integration with SharePoint data, and support for open source tooling. With the SharePoint Framework, you can use modern web technologies and tools in your preferred development environment to build productive experiences and apps that are responsive and mobile-ready from day one. In this session, we will learn what the SharePoint Framework does, what tools we need and how easy it is to develop new Web Parts and Extensions, and then deploy them on Azure and/or SharePoint… You don’t want to miss it!
Join DevExpress Technical Evangelist Don Wibier as he shares just how easy testing your web app should be. Using it's 'plug-in free' design, Don will demo the benefits TestCafe delivers in just a few mouse clicks.
The year was 2014. Like many people in 2014 I was a C# developer, but unlike most I was ready to give it all up.
I'd been a professional programmer for 10 years and I thought programming wasn't for me. Without any formal CS qualifications and the feeling that something wasn't clicking, I was all but ready to drop out of the game and leave it to the experts.
Then I discovered functional programming and it ignited something in me.
With .NET Core, an explosion of .NET IDE's happened! There's good old Visual Studio, but also VS Code and JetBrains Rider, which even work cross-platform. In this talk, we'll dive into the latter. We'll explore navigation, code inspections, quick fixes and code generation as well as built-in tooling like local history, version control and docker integration. Also we'll focus on a few secrets the debugger has to offer, like dependent breakpoints, a smart step-into function and on-the-fly decompilation of third party libraries. Come to this session to learn about this new (and fast!) kid on the block and learn plenty of tips & tricks to enhance your development productivity.
I see many junior or even mid-level engineers who are are well on their way to mastering the C# language, but don't know much about working effectively with NuGet packages in their projects.
I will cover NuGet 101, and a bit more depth. What problems does NuGet solve? The basics of SemVer. What syntax do you need to know? both VS2017 NETCore new style syntax, and old style. Via the VS GUI, command line and via text editor. Good practices to make it work for you. Things that we have done wrong, that you can avoid. Publishing, Beta releases, Internal feed, global tools.
Finishing with a look at automating NuGet updates into your code using open-source tools such as dotnet-outdated and NuKeeper.
NUKE is a build automation system with C# DSL, which allows us to automate processes like compiling solutions, packing artifacts or deploying applications. In contrast to existing tools, NUKE integrates as a simple C# console application. Therefore, we are able to use all the IDE features we love - like debugging and auto-completion - out of the box! This also means, that it requires less learning to actually manage or extend a build, which increases overall acceptance and adaption in a team. Integration of command-line tools is a top priority. For that reason, NUKE utilizes a revolutionary code-generation approach that helps to provide a clean and consistent API for them. Join this talk to learn how to write maintainable and reliable builds.
We all know what good code looks like. It’s simple, small, readable and extensible with explicit intent. Above all it is built with SOLID Principles. The question is: is good code enough? If we want systems that are truly agile and that can be changed easily, what other characteristics do the code and architecture of those systems need to have to allow us to re-shape them continuously? In this talk we will look at various design and architectural patterns which allow us to turn good code into truly agile code. All the example will be in .NET Core
The repository has experienced its fair share of security scares, one of the most recent was a significant typosquatting attack in August 2017. Although the attempt was not considered to have been very effective, it went unnoticed for two weeks and served as a catalyst for security companies to look for similar attacks.
This talk describes my efforts in this space using ideas from the attack to look for other active ones. Attendees should expect to learn about my investigative efforts and the awesome features of F# which made it easy and fun.
Writing code is not enough! No matter if we're working inside a team or as a single developer - continuous integration is essential to ensure the correctness of a project while moving forward. In this talk we will look at a number of common steps that every build chain should include, while showing some of the best practices used for release versioning, maintaining changelogs and keeping up code quality. What are the key aspects when implementing a build chain using a build system like Cake, Fake or Nuke? How is that combined with build servers like AppVeyor, VSTS or TeamCity? And what additional benefits do we gain through them? We will look at various pros and cons that can help to make educated decisions and becoming better at mastering the CI!