Just a spoonful of Front End OpsBen Cooper
When developers think Ops, most of think DevOps. Also most of us shudder. Just me?
When we think DevOps, we also think about it in terms of servers and system architecture and it seems very focused to the full stack/back end orientated programmer.
In this talk I would like to introduce you to this branch of the sector and cover the various areas from performance, tooling and even localisation. I think a spoonful maybe a little bit of an understatement.
Software Development for Formula 1Chris Alexander
Formula 1 is a fast-paced and accuracy focused engineering discipline, with constrained resources and constantly evolving requirements.
Discover how the McLaren Racing Software Development team has evolved its process and software in order to handle this challenging environment and to consistently deliver reliable, robust and highly adaptable software to meet the needs of a complex engineering problem.
Along the way find out about the history of McLaren and our long line of technical and engineering innovations; how the team is structured and where software engineers fit in; and our role during race weekends, in Mission Control, and how we provide first-class support whether our users are in Woking, Sao Paulo, or Azerbaijan.
Evolving PM: from the sin to the virtueAntonio COBO
PM role needs to evolve from the classical Waterfall (plan-driven) approach to a facilitator role in line with the Agile approach. This talk is intended to share my thoughts on this evolution, talking about the biggest sins the PMs can fall into and the virtues needed to drive the team to accomplish the project goals with success.
Main ideas to get from the talk:
-Filling the gap between Business and Development Team.
-There are not separated groups in a company, but only ONE company with same goals.
-The communication and its facilitation are the keys to success
Building (micro) services in .NetSean Farmar
In this talk I will demo how we can build deploy and monitor a couple of (micro) services using the .NET platform.
On the Java platform we have a LOT of options to implement micro services, this is not the case on the .Net platform, lets look how we can do this using .Net tools like NServiceBus
Building your first dashboard with Azure PowerBI EmbeddedJoel Hammond-Turner
Users love dashboards… Dashboards give them that warm fuzzy feeling that they can see into your software and watch it working perfectly… And dashboards give you the same insight into what's actually going on.
Microsoft's new Azure PowerBI Embedded product lets you capture data, analyse it and present it on dashboards that live within your application.
In this session, I'll take an existing instrumented application, pipe the data into Azure and demonstrate just how easy it is to create a rich dashboard to monitor the application - live.
React for the .Net DeveloperChris Canal
ReactJs is the new hotness for creating maintainable, composable UIs. In the session, we will cover what ReactJS is, how it works, and what advantages you have as a .Net developer. This session assumes you are comfortable with web technologies, most of the Gang of Four design patterns, and cursory knowledge of declarative functional coding.
In this session, I will walk you through the process of setting up a WebAPI service and how to secure it by using MS Identity and the OWIN middleware.
Run Your Team Lean and Deliver MoreStephen Haunts
Lean software development (LSD) is a translation of lean manufacturing and lean IT principles and practices to the software development domain. Adapted from the Toyota Production System, a pro-lean subculture is emerging from within the Agile community
In this talk we will look at Lean Software Development and how it is a benefit to modern development.
We will start off quickly looking at Waterfall and Agile, and then look at the history of Lean and its origins at Ford and Toyota. From there we will show how leans applies to software with the following lean principles:
- Eliminate Waste
- Build Quality In
- Create Knowledge
- Defer Commitment
- Deliver Fast
- Respect People
- Optimize the Whole
We will then answer the question Agile or Lean and then look at different software practices that will help support your use of lean including Kanban.
The talk would be aimed at software developers who are keen to apply lean to their software projects.
Azure Functions is the cool new kid you want to hung out withChristos Matskas
REST APIs and the Internet of Things: A winning combination.Alexandra Bowen
A developer perspective of Internet Of Things
-REST and the Internet Of Things
-Leveraging open source services to build IoT applications
-Demo - raspberry pi into IoT gateway *optional
Internet of Things (IoT) is more than a buzzword. The convergence of devices, cloud and analytics is creating a perfect storm for the developers. Cheaper sensors, affordable prototyping platforms like Arduino, Raspberry Pi, and BeagleBone make it easy for the developers to get started with IoT. But sensors are only the tip of iceberg. The actual value of IoT is in the data generated by the sensors deployed at various locations. Developers need to deal with a variety of data sources such as object storage, semi-structured NoSQL databases and RDBMS to store and process sensor data.
I will touch on how DreamFactory Services Platform (DSP) empowers developers through a unified, industry-standard REST backend to interface with multiple data sources. DreamFactory shortens the learning curve by abstracting proprietary APIs via simple REST APIs. What's more, DreamFactory can be deployed in any LAMP host including Raspberry Pi 2. This capability turns Raspberry Pi 2 into an IoT Gateway that aggregates data ingested by Sensor Nodes.
But wait... what about component patterns (createClass?, ES6 classes?, functional?), instance life-cycle (mix-ins?, higher-order components?), state management (props?, Flux?, Redux?), asynchronous operations (call-backs?, promises?, middle-ware?, RxJS?), immutability (Immutable.js?, discipline?), static type analysis (Flow?, TypeScript?), build chain (Babel?, Browserify?, Webpack?), test framework (Mocha?, Jasmine?), ...
How to speed up .NET and SQL Server web appsBart Read
Performance is a critical aspect of modern web applications. Recent developments in hardware, software, infrastructure, bandwidth, and connectivity have raised expectations about how the web should perform.
Increasingly this attitude is applied to internal line of business apps, and niche sites, as much as to large public-facing sites. Google even bases your search ranking in part on how well your site performs. Being slow is no longer an option.
Unfortunately, problems can occur at all layers and in all components of an application: database, back-end code, systems integrations, local and third party services, infrastructure, and even – increasingly – the client.
Complex apps often have problems in multiple areas. How do you go about tracking them down and fixing them? Where do you begin?
The answer is you deploy the right tools and techniques. The good news is that generally you can do this without changing your development process. Using a number of case studies I’m going to show you how to track down and fix performance issues. We’ll talk about the tools I used to find them, and the fixes that resulted.
That being said, prevention is better than cure, so I’ll also talk about how you can go about catching problems before they make it to production, and monitor to get earlier notification of trouble brewing.
By the end you should have a plethora of tools and techniques at your disposal that you can use in any performance analysis situation that might confront you.
Introduction to node.js: From "Hello, world" to deploying on AzureColin Mackay
In this talk, I'll discuss what is node.js, show you the obligatory "Hello, World!" application, how to add dependencies into your project including how the node package manager works and finally how to build a basic web application in node.js and deploy that to Azure.
SignalR - Can a real-time library for .NET be more awesome?Christos Matskas
.NET developers now have a great, open source library for implementing real time communication solutions both on the web and the desktop. SignalR is a persistent connection abstraction library for .NET which was inspired by tools such as socket.io and now.js on Node. Join Christos Matskas as he shows you how to get started with SignalR, it's requirements, features and supported platforms. Leaving this session, you will have a firm understanding on how SignalR works and how to leverage this amazing, community-driven library to provide real-time experiences for your users.
.Net Mvc SecurityJohn Staveley
The number and frequency of attacks on websites in the news is increasing steadily and effects can be devastating. However for each company that you hear about there are many more who cover up or are unaware of breaches on their sites. Thus what you hear about in the news represents just the tip of the iceberg. This primer session on security focuses on the major risks and the practical steps you can take now in your software development to protect an ASP.Net Mvc website from the major threats in the web today and will include code you can take away and implement in your own sites. Each type of attack will be introduced in a technology agnostic way, then highlighted with some case studies using major breaches as examples, then finally countermeasures which you can use will be proposed for each risk. The attacks I will be looking at are:
• SQL Injection
• Session hijacking
• Password hacking
• Weak account management
• Insecure direct object references
• Sensitive data exposure
• Missing Function Level Access Control
• Unvalidated redirects and forwards
A sample code project is included as part of the talk which helps mitigate against all of these threats and more.
This talk has already been presented at DotNetNotts, Derby.Net, LeedsSharp and NEBytes and has had great feedback from the developers who have seen it.
What’s in that package?Kevin Kuszyk
Do you use NuGet or npm in your solutions? Have you checked your dependencies for known security vulnerabilities?
In this talk we’ll look at tools which can plug into existing continuous integration scripts to check projects at build time against databases of known NuGet and npm vulnerabilities. Finding vulnerabilities is not enough though, we need avoid taking dependencies on packages with known vulnerabilities and respond quickly when new vulnerabilities are disclosed.
Salesforce Platform ToolsKevin Reece
Sage recently embarked on a journey to become a Salesforce ISV and develop a market leading and revolutionary accounting product called Sage Live. Sage Live was initially developed in 90 days and this was achievable by the rapid development that the Salesforce platform enables.
This session will cover an introduction to built-in platform tools such as Object Modelling, Approval Processes and Process Builder.
Implementing OpenID Connect using IdentityServerRajpal Singh Wilkhu
OpenID Connect is an authentication protocol built on top of OAuth 2.0, which facilitates clients to verify the end-user identity against the authentication performed by an authorisation server. At the same time, it provides methods to transfer the end user information through claims.
In this talk, we will introduce OAuth 2.0/OpenID Connect and IdentityServer followed by how we migrated an existing custom authentication system to OpenID Connect. We will look at patterns of extending and implementing security within IdentityServer.
We will finish off with what's new in IdentityServer 4.
Code Quality and Static Code AnalysisStephen Haunts
Visual Studio offers many great tools to help you with improving the quality of your code. These range from unit test tools, code metrics tools and static code analysis.
In this talk we will explore some of these tools and also take a look at tools like NDepend which offers a very rich palette of tools to help assess the quality of your code, or investigate dependencies of legacy brownfield code.
Sketchnoting for DevelopersDerek Graham
As developers the one thing we can count on is that we can never stop learning. Retaining, processing and making sense of new information are all parts of what we do every day. Sketchnoting is a set of techniques you can use to support and improve your visual thinking, communication and learning. You can even use it to get more benefit from the other sessions you attend at DDD North!
In this session, I will show you how sketchnoting works, how to get started, tips and tricks to save you time and why sketchnoting is so much better than F#. I'll also cover how it can be applied beyond conferences and talks to UX/UI design, team collaboration, agile methods and your personal development.
Getting started with Unity3DLee Williams
With the rise of Indie Game Developers we take a look at one of the biggest tools being used right now. In this session I will be talking about my experience as a developer learning Unity and some of the common mistakes and how to avoid them from happening to you.
We will be creating a basic 3D game from scratch written in C# and using some free assets from the Unity Asset Store. I will also be showing you some examples of what I have been working on over the last year and looking at some lessons learnt.
The Post Factual Political Age And Why it Means Your Software SucksGary Short
We now live in a post factual political age, where the facts of any issue no longer hold sway with the electorate, but why is this, and why do the same factors of human psychology mean the majority of large scale software projects suck? In this presentation, I'll enumerate the features of the human condition that led to the post factual political age, and I'll align each one with the software development process to show the issues your team must overcome in order to ship working, complete and correct software.
Securing your API with OAuthFilip Ekberg
Rolling your own security layer on top of your API? Stop it. You'll end up regretting that decision for the lifetime of your API!
Why should you care about OAuth and Identity? What's the difference between authoriation and authenticaiton? Should you just roll your own OAuth implementaiton (No!....)?
I'll make sure you know how to secure your API with OAuth, be it with IdentityServer, or some PaaS. You'll know the difference between all the OAuth flows and where they're applicable. We'll see how to approach this from the server, and the client.
Getting Into the Zero Downtime Deployment WorldTugberk Ugurlu
Continuous delivery is a huge step forward in our ability to rapidly deliver features and value to the users of distributed applications, but it comes with a cost and a responsibility. Most modern web applications need to be highly available, and this also means that it should be up during the deployments. Dealing with zero-downtime deployments is a challenge, and there is no easy solution. Moreover, the solutions available vary based on the number of integrated clients, which parts of the World it addresses, how many active users it has... Isn’t there a simple way to figure out how to get there?
Join me to get into the details of the key steps on your path to zero downtime deployments. Learn about the patterns, practices and techniques that make it easier, such as semantic versioning and blue/green deployments. We’ll also walk through an end-to-end demo of how a high traffic web application can survive the challenge of deployments.
What seemed insurmountable at the start of the session will be practical and applicable by the time we’re finished, and you should be able to see how to start moving your production application close to the zero-downtime gold standard.
Developing apps in Windows Containers using DockerNaeem Sarfraz
You've ignored Containers long enough now, Microsoft is bringing them to you in Windows Server 2016. Yes, that's right, you'll be able to run Containers in Windows using Docker.
In this session we'll look at what a Container is, how to get started and how to deploy an ASP.NET application into one. We'll be focusing on what this means for your workflow as a developer using the latest offerings from Docker & Windows Server.
The Internet: transforming society and shaping the future through chat(bots)Galiya Warrier
Are chatbots the next new hot thing in tech? Well, yes and no, a lot of hype for something sticking around since late 90s, but they are smarter and (sometimes) "more human" these days, thanks to more accessible AI algorithms in speech processing, NLP, computer vision, etc.In this session we will touch on their history and I will show how you can build a simple, but smart enough bot using Microsoft Bot framework. You'll learn how to deploy it and make it available in different apps (FB Messenger, Skype, Telegram, etc). And you can take it further and ... maybe develop that one bot, which will make you rich, or at least entertain your friends!
Safe At Any SpeedIan Cooper
You committed to TDD, you embraced your agile methodology, you read up on CQRS and whiteboarded your microservices. The time has to come to release and you are brimming with confidence. But once you are live the pain starts coming; deadlocks in the Db, servers that begin queuing requests and then fail, users reporting errors you have never seen. Keeping an application alive in production takes more than just good practices. You have to understand stability patterns like retry and circuit breaker, you have to understand what it means to be a multi-user system if you don't want deadlocks, you need to understand what happens if you lose a node and you need to know how to monitor your application in production so you can understand the pain when it hits you.
In this presentation we explore some of the key patterns you need to know to keep your application alive in production. By the end of the session you should have a far better idea of what you need to know to stay up.
Jankety JankBen Cooper
Rendering performance is becoming such a prominent figure in web applications that not having an understanding will cost you dearly in the eyes of your users. Understanding how the browser optimises rendering and what the app lifecycle consists of, your apps will be running at a silky smooth 60 FPS in no time.
With no particular focus on a specific rendering engine, we will focus on what is known as the "Rendering Pipeline" and provide a detailed understanding of the tasks which must take place in order to get your web application on to the screen.
Machine Learning for MugglesMartin Kearn
Artificial Intelligence is the latest hotness. We’ve heard how bots are going to be the new apps allowing natural conversational interfaces. Siri, Cortana and Google Now are no longer a gimmick and are becoming more useful every day. Machine Learning sits behind artificial intelligence and on the surface it may seem like a deeply technical, scientific topic. We are here to tell you that it is more accessible than you think. We’ll look at some of the basics around machine learning. We’ll also look some of the API services that make it very easy to implement artificial intelligence ‘smarts’ into your application with simple, standard REST calls
RPC is EvilIan Cooper
As the microservice train thunders into town, it is bringing with it an old enemy - the Remote Procedure Call. Libraries like Thrift are being used for client-server communication and no one seems to be looking back to the past to understand why we ran screaming from RPC last time. Drawing on bitter experience of DCOM, .NET remoting and Web Services, and his very British desire for a decent cup of tea, in this talk Ian Cooper will explain the anti-patterns of RPC and look at the alternatives which will ensure your system stays stable and he gets a decent brew.
Protect your home with rIoT gearGareth Midwood
We all like going on holiday. Unfortunately, bad people like it when we go on holiday too. Does switching a lamp on at 6pm every night really deter a burglar? Does their burgley sense tingle when you don't open the curtains for a week?
What if we protected our homes with an army of connected robots.. robots that could open & close curtains, turn on the lights, take a photo of people when they approach the door - and what if you could check on the state of things while you're on the beach sipping a pina colada?
Armed with some node and an Internet of Things, here's what we'll do..
Audio Synthesis in F#John Stovin
Functional languages are a great fit for writing applications that generate and process audio signals. In this session I will attempt to provide a whistle-stop tour around digital audio theory, and demonstrate how F# makes it easy to create the basic building blocks of an audio synthesiser and hook them together.
Warning: for those of a nervous disposition - there will be noises.
Getting your Splunk on - a developer's introduction to SplunkJoel Hammond-Turner
Splunk is a magical tool - it sucks in your logs, indexes them and gives you a rich search and data mining application to drill deep into them.
But as a developer why the heck would you want to use such a DevOps'y tool?
In this session, I'll show how using Splunk whilst developing can give insight into your code - how to time transactions, graph volumes and analyse performance - and how Splunking as a developer will make life in production that much easier.
The Three Real Problems in Software DevelopmentPeter Smith
Coding is fun and rewarding, but sadly we need more than just programming skills in order to build great software and deliver value to our customers. Software is a people industry, and we have to get to grips with collaborative design, select the best architecture, processes and tools, and then convince others that our approach is correct. Where's the stack overflow for that!?Fortunately, many problems you'll encounter in your career in software boil down to just a handful of core concepts from which many solid strategies can be derived. This talk will cover three of these that I consider most important, things I wish I'd known years ago. You'll learn ways to help guide your team on their journey to building better software, and more importantly identify when your way may not be best after all (!)
Metrics driven developmentSam Elamin
Moving to a distributed system will solve all your problems and you will be in developer heaven. Right? Not exactly, having hundreds of services doing different things means it's increasingly difficult knowing where exactly production issues are hiding.
In this talk Sam Elamin will relate his real life experience working on a distributed system dealing with £100,000 worth of transactions every hour. Sam will cover monitoring and how to develop your features based on how your customers use your platform and, most importantly, business metrics.
Sam will cover how to implement metrics in your application and setting up dashboards to gaining visibility into what is happening in your production system right now. We'll also go through some helpful techniques to help you convince your domain experts that gaining this insight is invaluable to keeping your competitive advantage.
As an extra treat come and see how JUSTEAT time travels in production, using open source software that can be set up in a matter of days!
Reusable APIs for the win! -or- Why Reusable APIs Win for Mobile DevelopmentAlexandra Bowen
This talk describes lessons learned writing one-off APIs the bad way, important characteristics of a reusable API, and how architects and developers can use reusable APIs in practice. With mobile applications and APIs taking over, this talk provides practical guidance for a winning API strategy.
3 part talk:
- 1. Lessons learned
- 2. Reusable API's - what that means, why they are important, and why you should embrace them for mobile app development
- 3. Use a reusable API - tips, techniques, examples that are useful to developers and architects of mobile apps
You read The Phoenix Project and you loved it! Now what?Matteo Emili
Pipelines and DevOps are the new Big Data - everybody is talking about them, but how many actually implemented and use them in a valuable way?
The Phoenix Project is a great book describing a very common scenario in many companies, and you can read it very quickly - let's say in a weekend. But once you get back to work, you risk facing a shock: you might still be deploying on Friday afternoon, or you might still face the kind of frictions the book narrated that well.
Can I introduce a Release Pipeline in a regulated environment, or in an enterprise where most of the development teams are still anchored to a legacy perspective? How can I actually bring value in an incremental and iterative way, without disrupting everybody like a big bang?
This session is all about this - from my experience and others', a different perspective on DevOps and Continuous Delivery focused on how to bring the practices in an environment where big, disruptive changes are not always welcome and on using technology to bring a tangible contribution to the ultimate business goal: revenue.
DDD: The God that Failed?Gary McLean Hall
DDD is rarely applied 'properly'. When directed at the right sort of problem and executed well, DDD is a valid solution. But DDD is over-used, misunderstood, misapplied, deified, and just downright bastardized. It is a small core concept that has gargantuan consequences throughout the solution.
Thankfully, there are alternatives. By following the Single Responsibility Principle at an architectural level, we can create a suite of small, decoupled services with high internal cohesion. These services can be composed and orchestrated in many different ways to solve business problems.
Ping Me! Bidirectional messaging with SignalRDon Wibier
In HTTP-land, everything is supposed to be initiated from the client: the client requests, the server responds. But what if you wanted some other kind of communication, one that’s not limited by this protocol?
One of the very cool latest additions to the ASP.NET web stack is SignalR, which allows real-time communication between your web apps and your client apps, even outside the browser.
This session will walk you through the process of adding real-time communication to your web app and setting up a number of different clients like web, desktop and mobile apps. You will also get to know what needs to be done when your app needs to scale out.
Angular 2 & rxjs, a force to be reckoned with!Andrew Macdonald
The second version of Angular is hot off the press (or very close) and it comes with many cool new features and improvements over the original version.
When considering what cool feature to focus on, we could choose to look into how Angular has re-written it's change detection from the ground up, how it offers advanced shadow dom features that work now for legacy browsers while ready to master new green field browsers or even how rendering and processing have been split to facilitate native or browser based utilisation of your core directives, services and app logic!
Nope, in this session we will instead take a look at how Angular has embraced the power of rxjs, including it as a first class citizen.
After a brief introduction to some basic Angular and reactive programming concepts, we shall swiftly move into several code examples where rxjs can empower your development experience!
Complex objects and microORMs: an introduction to the Dapper.SimpleLoad and Dapper.SimpleSave extensions for StackExchange’s Dapper microORMBart Read
Dapper (https://github.com/StackExchange/dapper-dot-net) is a popular microORM for the .NET framework that provides simple way to map database rows to objects. It’s a great alternative when speed is of the essence, and when you just don’t need the functionality offered by EF.
But what happens when you want to do something a bit more complicated? What happens if you want to join across multiple tables into a hierarchy composed of different types of object? Well,then you can use Dapper’s multi-mapping functionality… but that can quickly turn into an awful lot of code to maintain, especially if you make heavy use of Dapper.
Step in Dapper.SimpleLoad (https://github.com/Paymentsense/Dapper.SimpleLoad), which handles the multi-mapping code for you and, if you want it to, the SQL generation as well.
So far so good, but what happens when you want to save your objects back to the database?
With Dapper it’s pretty easy to write an INSERT, UPDATE, or DELETE statement and pass in your object as the parameter source. But if you’ve got a complex object this, again, can quickly turn into a lot of code.
Step in Dapper.SimpleSave (https://github.com/Paymentsense/Dapper.SimpleSave), which you can use to save changes to complex objects without the need to worry about saving each object individually. And, again, you don’t need to write any SQL.
I’ll give you a good overview of both Dapper.SimpleLoad and Dapper.SimpleSave, with a liberal serving of examples. I’ll also explain their benefits and drawbacks, and when you might consider using them in preference to more heavyweight options, such as EF.
Component Driven Development with AureliaSean Hunter
The web development and design worlds are converging on the idea that websites should be built out of a system of components (or significant panels) rather than the traditional monolithic website approaches of the past. Building websites in this way improves agility, testability, reusability, and even team collaboration. The design world is also moving in this direction with the increasing popularity of Atomic Design http://bradfrost.com/blog/
In this talk we’ll take a deep dive into how to build component based single page applications by combining Aurelia’s dynamic composition and CustomElement & CustomAttribute features. We’ll then look at how we can make these components communicate in a way that is simple to implement and maintainable in the long run, by combining DataBinding and pub-sub with the AureliaEventAggregator.
Development and QA dilemmas in DevOpsMatteo Emili
The quick rise of Continuous Delivery in the enterprise means that common problems are often approached the other way round. Concepts like Feature Flags and Testing In Production caused several headaches to developers and QA engineers, especially where they have a wealth of experience about traditional development.
There are some challenges and approaches which are very common, and they still scare newcomers. Let's have a look at a few of these, with the most common solutions.
Thinking FunctionallyJohn Stovin
The determined programmer can write FORTRAN programs in any language - Ed Post
To program effectively in a functional language, you need to discard many of the thought processes and habits that you have developed for coding in ‘curly bracket’ languages, and understand a new set of idioms and ways to think about code.
In this session I will talk about some of those fundamental idioms, explain why they exist and how they interact to provide a very different framework for thinking about your code. Even if you never write any F#, these ways of thinking can be used to make your C# code more efficient and more robust.
Beautifying your mobile appsJames Croft
There's more to creating mobile apps than a great idea and a developer. The best apps don't get where they are without a great user experience that keep the user engaged and excited to use them.
In this session, we will take a look at common UX concepts for creating beautiful, simplistic mobile apps, show you how you can take an existing app UI and give it a bit of umph with animations, transitions and effects to create a beautiful experience with UWP app demos.
While the demos will focus on UWP, this talk is appropriate for anyone looking to create awesome app experiences and you don't have to be a designer to do this.
Take Control - Control Code ComplexityFan Yang
This talk is about control, control our code, the flow, the tests and the complexity. It might be difficult to control the border of this country, but as a developer, we can take control of our code, can't we?
Reading code and maintaining code cost us time and money. “The ratio of time spent reading (code) versus writing is well over 10 to 1 ... (therefore) making it easy to read makes it easier to write. ("Clean Code: A Handbook of Agile Software Craftsmanship" - Robert Martin)
We can’t manage code complexity if we can't measure. It has been forty years since Cyclomatic Complexity was developed and published in the seminal paper “A Complexity Measure” by Thomas J McCabe.
What have we learned from this measure? Can this measure help us limit the complexity of our code? How to use this measure to guide our coding and testing? How to reduce our code complexity and make it easy to read and maintain?
This talk will look at a real-world problem and see how we can solve the problem with less complex code.
Designing an API for developer happinessGarry Shutler
How do you go about designing an API that makes developers happy? Garry will discuss the decisions Cronofy made to optimise their developer experience, what's gone well, what hasn't gone so well, in order to help you make developers happy too.
The Murky World of Hybrid AppsMartin Kearn
Don't Build Your Own REST APIs/Up Your API Game, from REST to MicroservicesAlexandra Bowen
Many companies face the same challenges we had to think about and tackle over the years. One of the biggest challenges is figuring out a winning API strategy. This talk lays out some of the traps and pitfalls that companies often experience when they decide to build their own REST APIs.
Many project managers and engineers underestimate the full workload required when releasing an API. I will also be discussing the perils of building your own REST API, look at some ineffective solutions that companies use to battle backend API complexity, and survey the advantages of a more comprehensive and reusable API strategy
-Building your own REST APIs can snowball into a giant mess that adds to backend complexity and slows mobile and web development projects.
-Building APIs with REST API development tools, or trying to manage backend complexity with API management tools, doesn’t solve the root complexity problem, and adds an additional arbitration layer to the mess.
-Building comprehensive, reusable REST API services for groups of applications is possible with a carefully designed RESTful backend.
Desiging Solutions with Ployglot Persistance In-mindTugberk Ugurlu
The World we live in today makes us deal with a lot of information. The solutions we put out there also has the same problem. We collect a lot of data through our applications and we try to give those data back in a non-asphyxiating fashion. Doing this with a single data storage technology makes you feel definite agony even on a medium-scale solution but it's next to impossible to provide a viable solution in a large scale products like Foursquare and Twitter.
This is where the polyglot persistence comes into picture. As much as the word "polyglot persistence" sounds extremely fancy to your ears, it's also not that straightforward to adopt in a solution, especially in existing ones. Come and join me in this session to learn about what most matters in this type of architecture to build a viable, maintainable solution. Also, I will be talking about how to make decisions to choose the right data storage technologies based on my personal experiences I gained with the side project I am spending my nights on.
By the end of the talk, polyglot persistence should seem less scary and you would at least have one real world example in your mind on how a solution is being architected where polyglot persistence is the solid foundation.
Creating VSTS extensions for fun and profitRichard Fennell
TFS 2015 and VSTS share a new extensions model with an associated Marketplace for web widgets, build/release tasks and other components.
In this session I will look at how you too can write these extensions, there will be PowerShell, NodeJS, Visual Studio Code and much much more!
But I don't use TFS or VSTS I hear you cry, will all is not lost, the session will also focus on the DevOps workflow I am using that allows me to locally build my extensions and then share them in the marketplace as private extension to only my test accounts, prior to full publication when I am happy.
So something for everyone
Busting the Myths with Cross-Platform XamarinFilip Ekberg
You're promised high amounts of code sharing when building your next million dollar business with Xamarin, but is that really what's going to happen?
We'll uncover the truth about code sharing with Xamarin; looking at custom renderers versus doing a native UI approach, as well as talking about how these decisions can haunt your throughout the development and maintenance of your app.
With web applications becoming ever more interactive, and the meteoric rise in popularity of mobile browsers, the kind of performance and resource usage issues that once only concerned back-end developers have now become common currency on the client as well.
In this session we’ll look at how these runtimes manage memory and how you can get the best out of them. We’ll discuss the “classic” blunders that can trip you up, and how you can avoid them. We’ll also look at the tools that can help you if and when you do run into trouble, both on the client and the server.
.NET Data Security : Hope is not a StrategyStephen Haunts
Not encrypting your data is a risky move and just relying on hope that you won't get hacked and compromised is not a strategy.
As a software developer you have a duty to your employer to secure and protect their data. In this talk, you will learn how to use the .NET Framework to protect your data to satisfy confidentiality, integrity, non-repudiation, and authentication.
This talk covers random number generation, hashing, authenticated hashing, and password based key derivation functions. The talk also covers both symmetric and asymmetric encryption using DES, Triple DES, AES, and RSA. You then learn how to combine these all together to product a hybrid encryption scheme which includes AES, RSA, HMACS, and Digital Signatures.
Living in Orleans for a yearAndrew Macdonald
It’s becoming more of the norm for web sites and applications to be hosted with hyperscale cloud providers like Azure, Amazon and Digital Ocean to name a few instead of using co-located dedicated hardware.
While there are many facets to helping an application become cloud native and making the best of the hyperscale on offer, we'll be taking a look at Project Orleans; a framework designed from the ground up to assist in the delivery of distributed high-scale computing applications without the need to learn and apply complex concurrency and other scaling patterns.
Is it really this simple, what are the pitfalls, what are the benefits and more importantly if I had to choose again, would I still make the move into Orleans...?
Giving apps intelligence with Cognitive APIsJames Croft
You may have seen this in action with sample demonstrations like the "how old do I look?" website but how do you go from having fun with smart APIs to gathering useful information to provide rich user experiences in your applications.
This session will take a look at Microsoft's Cognitive services, which allow you to build smarter applications using the knowledge of the web, and how you can integrate them into new or existing projects with demos!
Functional Frontends - An Intro to ElmlangRob Ashton
Elm is *amazing*.
Okay, I have some misgivings but you have to praise how easy the author of this language/framework has made building front-end applications in a haskell-like programming language. It is super accessible and has some wonderful patterns (Think React but more authoritarian).
I want to help you build better front-end applications and I think that Elm is a brilliant starting point for this. Let's do an intro together, let's build an application and cover the patterns and look at the tooling and fantastic error messages and how easy this actually is.
A Piece of Cake - C# powered cross platform build automationGary Park
Have you ever wanted to create a build script for your application, but been faced with learning a new language, or DSL, or writing more XML than any person should ever need to?
Have you ever wanted to create a build script that will work cross platform?
Have you ever wanted to create a build script that has first class support for the most common build tools like XUnit, WiX, SignTool, and many others?
Have you ever wanted to create a build script that uses a language that you already know, and love?
If you have answered yes to any of these questions, then the Cake (http://cakebuild.net/) Build Automation System is for you!In this session we will start with a standard .Net Solution and incrementally add a build and orchestration script to compile the application, run unit tests, perform static analysis, package the application, and more, using the C# skills that you may already have.
Running a real-world node.js applicationColin Mackay
Node.js is taking off in the .NET world in the build pipeline, but you can also run real world web applications with it too.
Optimizing client-side performance in interactive web applicationsBart Read
Devices nowadays offer a wide variety of form factors and capabilities. On top of this, connectivity – whilst widely available across many markets – varies considerably in quality and speed. This presents a huge challenge to anyone who wants to offer a great user experience across the board, along with a need to carefully consider what actually constitutes “the board”.
In this session I’m going to show you how to optimize the client experience. We’ll take an in depth look at Chrome Dev Tools, and how the suite of debugging, data collection and diagnostic tools it provides can help you diagnose and fix performance issues on the desktop and Android mobile devices. We’ll also take a look at using Safari to analyse and debug web applications running on iOS.
Learn how to become a Visual Studio Jedi MasterChristos Matskas
Do you spend most of your day working in Visual Studio? Do you feel that you know all there is to know about it? Would you like to learn how to unlock some of its hidden features in order to boost your productivity and code more efficiently? Visual Studio's powerful IDE comes crammed with numerous features that can suprise and amaze you. Join Christos Matskas as he showcases some invaluable tips and tricks to help you become a Visual Studio Jedi Master.
Diving Deep into DockerDavid McKay
Docker, the hottest technology around at the moment. It swept the Ops world by storm in 2014, became mainstream in 2015, and now it’s set to dominate the developer world, in 2016.
Docker is a tool that allows you to package your application up into a single-runnable distributable binary. Docker allows you, a developer, to specify the exact environment your application needs to run, across development; test; staging; and production.
In this tutorial I will introduce you to Docker and explain its fundamental concepts. I will walk you through Docker layering, networking and volumes; pulling back the curtain to see how it all really works.
The Hitchhiker's Guide to ReduxSam Hogarth
The traditional MVC approach to application structure is eschewed, in favour of a predictable unidirectional data flow. By adopting a few functional programming principles, Redux can significantly reducing the complexity of your code.
To understand the approach, we will first understand its philosophy and what problems it solves. As applications scale they introduce a new set of problems, from developer tooling to communication between modules. Redux has some interesting ideas in these areas too! Utilising hot module reloading and Redux's reducer structure, we can debug by travelling through time. Redux's companion libraries, such as reselect and redux-saga, are targeted at efficient data access and containing asynchronous side-effects.
The Hitchhikers Guide to Redux will present you with a glimpse of the future of front-end development, from a beginner's point of view.
Bringing the Admins to the Dev SideRyan Yates
In this session we will look at how IT Admins can be coaxed into working with more in the Dev side of the Force - wait no - the IT World - in their day to day tasks. in a more efficient manner with effective Unit Testing and Source Control of their Scripts. In a Windows world this really means PowerShell but increasingly we are getting submitted to other scripting languages including Python & Ruby we can carry the practices across to these languages too as we require.
This is a session where there will be chance to follow along (if you bring your own laptop) and learn in real time from the co-ordinator of the UK PowerShell User Groups for getting started with the PowerShell resources - however you will also be lead to further community resources for getting started with Ruby & Python as well as further PowerShell resources if you require further time after the session to get this built into your current day to day workflow.
10 more things you need to do to succeed as a Tech LeadJoel Hammond-Turner
In 2014, I talked about 10 things that I believe any developer stepping into the role of Tech Lead needs to do to succeed.
This year, I've got 10 more things you should be doing as a Tech Lead.
This new 10 things are a little more specific, and a little more controversial in places, but they're tried and tested and well worth considering, if not implementing right now!
Brighter to the CoreToby Henderson
This is an experience report on moving Brighter, an Open Source project, to .NET Core 1.0.
As .Net developers we have an exciting future where we can target multiple runtimes, running on multiple operating systems.
It is not as bad as it sounds, some of the pain of this multiple craziness has been made easier for you with the new tools which have recently been made available.
This talk will take you through that journey and show you how we used the tools, what was missing for us, what we did to solve them and what we have not yet been able to solve.
How to Make Your Bookie CryGary Short
We've all heard the saying, "I've never met a poor bookie", well we'll put that saying to the test! In this session I'll explain what the published odds actually mean, and show you how the bookies make their money. We'll then use a number of statistical and machine learning techniques to attack the bookies' margin and also to identify which bet we should place and at which odds. This session will greatly improve your understanding of machine learning techniques and may even improve your bank balance. :-)
Responsive Web Design for DevelopersDon Wibier
Unless you work for a web agency where you have an art director and a team of web-designers, it is probably you, the developer, who has to make sure that the sophisticated web application you are building looks visually stunning on any internet connected device.
In this session you will see how your web application can look attractive on computers, tablets and smartphones by delivering a responsive user interface. We’ll investigate CSS media queries and some ready to go responsive CSS Frameworks like Bootstrap, but you will also see how to create reusable CSS by using the CSS preprocessor LESS and how to add images without going (completely) mad with Adobe Photoshop.
Becoming an awesome Open Source contributorChristos Matskas
Have you always wished you could contribute to Open Source but didn't know where to start from? Perhaps you want to build something great and gain invaluable experience by working in open source? Or you just want to join the open source movement because, well, OSS is the future? Just look at all the cool tech built with OSS: Node.js, BootStrap, ASP.NET etc. Join Christos Matskas to learn about the many ways to contribute, the development tools necessary and what it take`s to become a successful first-time contributor and collaborator in this welcoming and open community.
Should I forget about the build?Matteo Emili
In the Continuous Delivery world what matters is bringing value to the end user, and we need to do that with the best possible tools we have at our disposal.
In this session we are going to explore how to use VSTS' build with non-Microsoft technologies (Java!), how to make it work like we really want and how in this new world we can consider it just an orchestrator of 'stuff' that happens to our code before feeding it into the pipeline.
App 2.0 - why the web lost and Apps won.Liam Westley
In the heady days after the dotcom boom and bust, Web 2.0 arrived and created an exciting new delivery mechanism for software. Browser wars improved performance to a level where they could host fully functional applications, with easy of deployment and updating.At the same time smartphones had appeared and the first real applications were breaking cover, but they suffered from reliability, performance and discoverability issues.When Apple launched the iPhone, and the App Store it solved many of these concerns.
We now have easily discovered applications, streamlined deployment and high levels of usability.Is everything solved though? There are issues related to speed of updates, development costs, security, deep linking and whether the mobile platform owners are fighting back against the likes of Facebook.What is the future of apps? Who will win the platform battles? What will it mean to write an app for a light switch?
Continuous what?Kevin Kuszyk
In this demo led talk we’ll see how to setup continuous integration with Team City for a sample ASP.net MVC app. We’ll then take things a step further and enable continuous deployment using Octopus Deploy.
Why would you want to do any of this? By building and running tests on every commit we can shorten the developer feedback loop, and by shipping more frequently and reliably to test and customer environments we can shorten these feedback loops too. Shorter feedback loops are less expensive and result in better quality software.
Don’t use Git, Team City, or Octopus Deploy? No problem. The concepts introduced in this talk can be applied to other CI / CD stacks too.
Docker swarm, Azure Container Services, Mesosphere, Service Fabric - what, when & why!Andrew Macdonald
It seems like every day a new container orchestration platform is joining the bandwagon!
I don't know if it's the same with everyone else, but seriously, I'm starting to suffer from decision paralysis with all the options!!
I'm sure there are many more than those mentioned in the title, but the session will start with a brief whistle stop tour of these guys and then the floor will be opened to encourage an open discussion on what, when and where!
I don't have all (if any) of the answers.. just my own thoughts - this is an opportunity for you to shape my and others thoughts on the topic!
Reactive applications with Akka.NetAnthony Brown
As the systems we build need to respond to ever stronger user demands, it's important that as developers we're able to build solutions which are able to react to changes faster, automatically recover from failure and operate at potentially massive scale. All of these requirements are encompassed as part of the reactive manifesto, a set of guidelines proposed by some of the biggest names in hyper scale application development, including Twitter, Lightbend and many others.
In this talk we'll look at how we're able to implement the reactive manifesto in .Net with the use of Akka.Net and build applications up from simple actors communicating through the use of message passing. We'll look at some of the killer features of Akka.Net which allow us to rapidly auto scale applications across clusters of machines whilst also automatically recovering from failures they may encounter.
Selected Data Science SinsGary Short
Machine learning is the newest hot topic, and data scientist is the sexy new role we all want. As a result, the conference circuit is full of talks like: "Become a Data Scientist in Your Lunch Hour" and "Data Science, it's Not as Hard as You Think". Well guess what, it is really that hard and like anything worthwhile it takes years to learn properly. In this session I'll highlight some of the sins against data science that I've seen made at conferences by people demonstrating the "cool new online machine learning services" We'll examine each sin, talk about the fundamental statistics behind it, and show you how to perform the analysis correctly.
Back to Basics: Efficient Async and AwaitFilip Ekberg
We've all experienced deadlocks, and we all hate them, but how do we prevent (and potentially fix) them?
That's right, no one likes applications crashing or giving users an unexpected behaviour. Introducing asynchronous patterns is so much more than just applying async and await to your methods; you really, I mean really, need to understand what's going on.
In this session, we'll make sure you know how to avoid crashing your applications, and how to adhear to best practices when applying asynchronous patterns in our .NET applications.
Logic Apps! Integration made easyLee Williams
Moving data quickly and securely between applications has always been a challenge. With Logic Apps you can now keep all your services connected in the cloud and on-premise without having to write any code!
In this session I will show you how you can easily integrate many cloud services and automate business processes within minutes. We will also look at how you can extend your existing on-premise systems to integrate with popular cloud services such as Office 365 and salesforce.com
Developer UI testing made easy before you commit to source!Richard Wilde
Unit testing helps us when writing any sort of application, however we often end up writing unit tests for small pieces of logic that don't really matter and sometimes miss out on the bigger picture. As a developer we tend to shy away from Web UI testing as the feedback loop is just too slow.
In this demo led presentation we will take a look at a toolset that gives us end-to-end testing to give us far faster feedback. As a developer you will be able to run UI tests before you commit your code to source!
I will show you:
- how to get up and running
- how to screen scrape and take screen captures
- how to test your UI
- how the Page Object pattern can help you maintain your test code
- how Visual Studio Code and Typescript fits in
Continuous deployment with TeamCity and Octopus DeployJohn Staveley
Everyone is doing continuous deployment, in the case of Flickr they are doing over 10 live deployments per day. There are huge business and developer benefits from being able to deploy at will including:
- Shorter time to market
- Less downtime
- Faster developer/marketing feedback
- Effortless 'boring' deployments
- Deployments to new environments is not a headache
In this introductory session we will set up a TeamCity and Octopus deploy to automate a deployment of a website to a test server so we can perform automated web tests against it. With what you will learn you will then be able to extend to similar deployments in QA, UAT and production environments.
Does a mobile app need local storage?Liam Westley
A mobile app that has no local storage is just a glorified web application that doesn't work properly when your device is offline.
Is this true? What are the different types of mobile apps, and what requirements do they have for offline storage?
Dealing with intellectual trolling, how to hack harassmentAlexandra Bowen
Don’t let trolls define your experiences in work, in your communities and in your projects. If you've ever had to deal with an intellectual bully in an online community, on a project, or social media, you know that it's one of the most unpleasant aspects of the internet. An intellectual bully may be adding value, but is mostly condescending, rude and aggressive. Don't let your toxic users define your community. Do you want a "death star" or "rock star" community member? I will also touch on how to create inclusive experiences.
Create Dynamic UI with D3... and Data Visualizations with React!Stephen Turner
But could we build our SVG visualizations in React, harnessing the expressiveness of composable declarative components? And could we create our primary UI with D3, leveraging its powerful layout and animation framework?
Or could we exploit the best of both, unleashing React's highly performant virtual DOM along side of D3's amazing depth and breadth of visualization algorithms.
Together we with explore the synergy of D3 and React.
Love and Death -- or, Everything you wanted to know about coupling but were afraid to askKevin Rutherford
TDD is the panacea of software development, the golden child of Extreme Programming. But there is a problem with test-driven development. A big problem. Everywhere I go, I see teams practicing TDD, and yet they are still creating horrible, smelly balls of mud. Code with many tests, and yet also many bugs. Code with many tests, but which cannot be refactored. How can that be possible?
The problem lies in the third step of the RED-GREEN-REFACTOR cycle. It's just too difficult!
In this talk we will explore a tool that can help us decide what to refactor and when. That tool is COUPLING (aka CONNASCENCE).
WARNING: Many of the slides in this talk will show code snippets.
Docker Changes the Way You Develop and Release Your Scalable SolutionsTugberk Ugurlu
Developing a distributed software solution is hard. Even if you boil it down to modular pieces and nicely define deployment boundaries, what matters at the end is that all of those modular pieces should work together in a cohesive way. It’s a must to get it building and working locally to see it in action but it’s a challenge if you have too many moving parts. Not to mention you need to control this many moving parts in production, too.
I have been working in a .NET project and it has many moving parts including MongoDB, Elasticsearch, Redis, HTTP Services, worker processes, clients… I felt the pain very deeply. However, I was able to see the light at the end with Docker. Docker made it easy to glue all the pieces together in development, pre-production environments and production. Getting the application up and running is just possible by running a single bash script thanks to Docker’s declarative nature.
But, how? How does it all work together? What are the tips and tricks to get it all functioning properly? Is Docker the magic silver bullet? What are the caveats? Join me in this session to walk you through the 1000 feet overview of this architecture and answer these questions based on my experience. By the end of this talk, you should have the right concepts in your mind to start thinking about bringing your solution to a high quality, stress-free level.
SOA lessons learnt (OR Microservices done better)Sean Farmar
Service Oriented Architecture has been around for a while, now Microservices is the new black, that’s cool, but can we learn from when we failed and succeeded implementing SOA? There are some really useful lessons we can take and avoid the pitfalls.<p>
Enabling Plugins in your web application with MEFDon Wibier
One of the many smaller sub-frameworks in the dotNET development platform is the Managed Extensibility Framework. In essence, this framework gives you the ability to support plugins and extensions in your application.
In this session I will show you what MEF is about and how to get started with it. I will also discuss some of the pitfalls you’ll encounter and how to get round them to make sure your app remains maintainable and secure.
Storymapping for beginnersColin Mackay
Sometimes it is difficult to work out how to prioritise the backlog and effectively work iteratively. What do you put in your MVP (Minimal Viable Product)? What then goes in each incremental release to give your users more and more useful functionality? Storymapping is a technique for solving this problem and getting your solution to your users faster.
In this highly interactive session I'll explain how you go about creating a story map and I'll get you to create one. Lots of sticky notes later you should have a fairly good grasp and be able to use the same technique on your own projects to better manage your backlog.
Breaking Bad: you CAN make Fast Web PagesDon Wibier
This session discusses the bad habits you may have picked up from those "web school" pages on the internet and shows how to break them with some simple-to-follow rules.
No Heisenberg uncertainty involved either, you'll understand and use the developer tools provided with your browser to tweak performance, save time, and optimize bandwidth.
Introduction to Salesforce DevelopmentKevin Reece
Sage recently embarked on a journey to become a Salesforce ISV and develop a market leading and revolutionary accounting product called Sage Live. Sage Live was initially developed in 90 days and this was achievable by the rapid development that the Salesforce platform enables.
This session will cover an introduction to Salesforce development, inc. APEX, Visualforce and Lightning.
Why Service Oriented Architecture?Sean Farmar
When we go about designing and building a scalable durable system we need to solve the number one issue in developing scalable software systems: coupling.
Implementing Service Oriented style architecture also refereed to lately as micro-services will help you solve this problem.
In this talk, I will try to explain the Service Oriented Architecture’s paradigm…
Meet new kid on the block – Microsoft’s .NET is going to rock your world.Christos Matskas
NET Core has been written from the ground up to be the best web development platform for Windows, Mac, and Linux. You can now use your favorite editor to create faster, leaner and more memory efficient NET applications that work everywhere. In this session, you'll get an introduction to the major advancements and an overview of what's changed in the new, brave world of .NET Core. You'll also get the chance to see how you can create ASP.NET Core apps that leverage all the new front-end tooling like npm, Bower, Grunt and Gulp to make development easier. This is going to be session full of demos and information that promises to rock your world!
Levelling Up - Intentional Practice and the Coding DojoDerek Graham
A Coding Dojo is a safe environment for beginning developers to learn and for experienced developers to teach or hone their craft, with intential practice.
It’s where we get together to discover, learn and have fun. It's about sharing knowledge, practicing and improving technical and human skills needed in modern software development. It's collaborative, non-competitive and inclusive.
It's where we practice or experiement with new techniques (XP, pair programming, TDD, katas, mob programming, clean code and refactoring) to make us more effective in our lives as professional developers.
In this session, I'll talk about how intentional practice fits into the dojo format, what tools you will need, how to be a participant, how to organize your own and will include some stories and advice from my own experience running a weekly dojo for the last 3 years.
This presentation is not guaranteed to turn you into a coding "rockstar", web "wizard", a cyber "ninja" or even a programming "guru".
Building a Continuous Delivery Pipeline using TFS Build & ReleaseNaeem Sarfraz
Creating a release pipeline using TFS has never been easier and faster but the mere mention of TFS sends shivers down the spine of developers.
Both the Build and Release tools have been re-written for both on-premise and VSTS. Gone are the days of creating XAML builds and releases using the WPF Release Management client. A much improved, lighter, task based system helps get you up and running in no time.
Come along and give TFS another chance as we build a delivery pipeline from scratch in this session.
This is not the Async you are looking forLiam Westley
With the introduction of Async/Await .NET developers never had asynchronous code this easy before. Finally, every programmer could create a multi-threaded app.
It’s nearly four years since that official launch of .NET 4.5 and there is still a significant level of misunderstanding on what Async/Await actually provides and when to use it.
I think it’s time to rewind and get back to basics and ask some fundamental questions.
- Is your application CPU intensive, or I/O intensive?
- How many CPU threads will your application actually be running on?
- Are your business requirements suitable for asynchronous processing anyway?
We’ll check out the great advantages of Async/Await, highlight some gotchas and take a look at the other ways of creating multi-threaded applications so you can select the right approach for the problems you have.
On demand big data processing with F# and MBraceAnthony Brown
There's no denying the fact that we're starting to produce more data than we know how to handle with traditional analytics processes and so we need new solutions to solve these problems. In the JVM world, we've got plenty of options for processing terabytes of data including the likes of MapReduce and Spark, but in the .Net world we can sometimes feel as though we're lagging behind somewhat. In this session, we'll see the .Net answer to Spark in the form of MBrace. MBrace is an open source framework allowing for rapid development of big data workloads through cloud computations and MBrace's signature CloudFlow. We'll also see how we're able to combine MBrace with some of the other F# open source projects to enable strongly typed access to the files we access with type providers. And the best part is, all of this is directly scriptable from your editor of choice thanks to the power of F# interactive.