Your current filters are…
by Cory House
Writing code for the computer is easy. Writing code your co-workers can maintain and understand is hard. So in this live, interactive refactoring session, you’ll learn how to write code with readability in mind by discussing an ugly chunk of code together. We’ll transform a sloppy class into a beacon of self-documenting beauty. And along the way, we’ll build a strong vocabulary for clean coding practices. I’ll facilitate the conversation and help lead the refactoring, but also look to the crowd to contribute viewpoints on how to clean the mess up! The application we’ll dissect is written in C#, but the principles and vocabulary you’ll take away apply to developers working in any C-like language. Prepare for a loud, hands-on session, as we learn key terminology for clean coding by rallying around the keyboard!
by Don Syme
Born in a lab, matured in a company and enterprise setting, and now fully baked as an open-source, cross-platform, professionally-supported language - the F# journey has always been about reconciling the irreconcilable: Functional and Objects, Types and Dynamism, Company and Openness, Mac and Windows, Android and iOS, Programming and Data, GPU and CPU, Async and Sync, Server and Client. Take two irreconcilable ideas, and F# finds a way. Come along and take a journey with me through the modern programming landscape and the F# approach to research, language design, interoperability, tooling and community.
Some software problems are difficult; and then, some are insanely hard. In this talk, we will explore one of the latter, the Mona Lisa Travelling Salesman Problem, and how we used modern tools to tackle it. We will demonstrate how we leveraged F# asynchronous and concurrency models in combination with Azure worker roles, service bus and storage, to build a distributed genetic algorithm which can be deployed, scaled and torn down in a couple of clicks - in about 1,000 lines of surprisingly simple code. While the specific problem at hand might be somewhat unusual, the key ideas presented are broadly applicable, and will illustrate how F# and Azure are a deadly combination to build simple applications that scale.
by Cory House
Building applications is hard, especially if you are using the wrong tools for the job. Wouldn't it be nice if you had the right tools for almost every problem you have? It turns out you can. If you are applying CQRS and eventsourcing together with polyglot persistence and programming you can solve many problem much easier then we are used to today. This is by no means a silver bullet, but it will work for a lot of applications we are building today.
I will in this talk show you how you can build an application more effectively that communicates what the business wants better. I will also show you how to integrate multiple databases and how easy it is if you are using eventstore as your main storage. Some of the technologies/languages that I will show you in the talk are: both C# and F# for programming, eventstore to store everything that has happened in our system, elasticsearch to get a first class search experience and neo4j to easily show complex relations.
Cells are the building blocks of all life. If we could program living cells as effectively as we program digital computers, we could make fundamental breakthroughs in the treatment of disease and the biofabrication of materials, while also gaining insight into the workings of life itself. In spite of this promise there are still many challenges to overcome. First and foremost, programming cells remains highly complex and error-prone, and we have reached a point where powerful computer software is needed to design and construct larger systems. This session presents our web-based software for programming cells including molecular circuits and understanding decision-making in stem cells. We present a molecular program of an optimal consensus algorithm and show results of the working system compiled into DNA. We’ll demonstrate our software tool chains for analysis of existing cellular function and the design of genetic devices from characterised parts. We show how software techniques including satisfiability analysis and property-based testing can be used to establish correctness in such a complex application. Just as software for programming digital computers heralded a new era of technology, software for programming cells could enable new applications of biotechnology.
by Jeff French
When setting up a continuous delivery system there are many pitfalls and dragons to beware of. I know because I've run into all of them! In this session I will take you through the elements that make up a good continuous delivery system from development and branching strategies, to continuous integration, and finally deployment. I will show you the tools I've used and the techniques I've developed over the years to deliver software efficiently and effectively. We'll look at building our code with both TFS and TeamCity and deploying it with Octopus Deploy.
Boilerplate’ code is unavoidably tedious. Mathematical calculations are maddeningly sensitive. Surprisingly, many developers spend their days preoccupied with these two tasks. Fortunately, the F# programming language has (amongst its many powerful features) ways to brush aside the tedium and fortify the sensitivity. In this talk, we’ll look at type providers and units of measure — a one\two punch for common coding tasks. In particular, we’ll review the ways in which units of measure provide contextual clarity to otherwise-opaque data, while they help prevent common mathematical errors. We’ll also see how type providers bring data into play quicker, while extending a developer’s reach for data sources. Ultimately, looking at the union of these two tools (and possibly some other F# goodness), we’ll arrive at a state of simpler data access, smarter calculations, and a happier development experience.
1st–5th December 2014