Build Stuff

Unix environments have fantastic tools like puppet, chef, vagrant and many others in order to eradicate the need for manual server configuaration environments. Windows was left behind when these fantastic tools were being developed. PowerShell is now emerging as the tool for Windows administrators and the tool to unite developers and operations staff in managing environments and deployments. Can PowerShell help to bring the devops culture to the Windows development world? In this session, I will demonstrate how PowerShell has become a tool necessary to know when working on a windows environment. The talk will demonstrate how to configure a Windows server with only an operating system on it. The session will also demonstrate how development environments can be built in a fraction of the time using some open source tools and PowerShell. No need to maintain desktop images any more, PowerShell is fast becoming a rockstar of the Windows configuration world. Since Puppet added support for Windows, we can really use PowerShell to kick windows into submission when managing environments.

In this session join a true Cloud enthusiast in pondering the opportunities in the Cloud. Let’s talk about what makes the Cloud unique compared to non-cloud predecessors. We will look at the nature of Cloud Computing – service oriented with a focus on statelessness, low coupling, modularity and semantic interoperability. How does this relate to the Modern App? How do I get going if I’m not a ‘Cloud enabled Developer’ today and is this urgent? We’ll talk about how to embrace the change. The session will underline the concepts with demos of services in the Windows Azure Platform.

In the modern world, the speed of making decisions and predicting trends based on data is becoming essential. Beating competitors through savvy near-realtime analytics, deriving automatic actions or decision options from massive, never-ending streams of data will become more and more important in the very near future. Sensors, web behaviour and traffic, mobile applications, internet of things are just a few examples of where such data can come from. Data like this needs to be taken in with adequate speed, reliability and scalability. Then, this data needs to be analysed, aggregated and eventually enriched. After that, a fast analysis needs to be done for ad-hoc decisions and actions. Further, this data needs to be reliably stored and quickly retrieved for different comparisons and long-term-predictions and exploratory analysis. All this reveals a huge challenge to technology. It's too easy these days - due to the massive choice and short time-to-market - to make a wrong technological decision which will influence the success of the solution and thus lead to the promise of continuous, fast decision making and automatic actions based on data not to be kept. Streaming technologies, vertical vs. horizontal grow, cascading, pipelining and aggregation, in-memory-processing, reliable storage, fast retrieval and not to forget the analytical complexity have to be considered when building such a solution. And it's always good to have a minimal, yet powerful abstraction and a good alternative for any of these technology-chain members. In this talk I will go through the topic and give the audience advice to which approaches and tools to use, how well they fit into the landscape of near-realtime analytics, rapid decision making and action automation based on massive data streams.

Traditionally, developers would write their applications without any thought as to what system it was going to be deployed on in production. It was also very difficult for them to understand how their software would react when releasing it into a production environment as they didn't really understand how that environment was configured. What if there was a way that developers could create the scripts needed to install dependencies and get the software running as it is developed? Vagrant does exactly this, it is a tool to create and configure lightweight, reproducible, and portable development environments. In this session, I will show you how to create a development work flow that will allow developers to use Vagrant to create a real continuous delivery pipeline. This means understanding the environment needs as well as what is needed to run the software.In this session I will demonstrate how to start with an ASP.NET MVC application and have the ability to create an Ubuntu environment to run this in production as well as how to run the same application in a Windows environment. I will also show how we, at OpenTable, integrate Vagrant into our pipeline to allow us to create a good acceptance testing environment against known data sets rather than having brittle test.

When you are developing a cross platform game engine used by more than 2 millions of game developers worldwide, you should be using the best tools available. If we can’t find the right tool, we forge it. We are the Toolsmiths. We build the tools for test automation.

This talk is about the tools we build and the approaches we use to deliver top quality game engine to the market.

The topics that are covered in this talk:
Unit Testsing and Test automation
Unity Runtime Test Framework
Continuous Integration
Game Test Framework
Performance Tests

The purpose of this talk is to share our experience with everyone who is interested in Test Automation tools and practices.

Some programming language theorists would have us believe that the one true path to working systems lies in powerful and expressive type systems which allow us to encode rich constraints into programs at the time they are created. If these academic computer scientists would get out more, they would soon discover an increasing incidence of software developed in languages such a Python, Ruby and Clojure which use dynamic, albeit strong, type systems. They would probably be surprised to find that much of this software—in spite of their well-founded type-theoretic hubris—actually works, and is indeed reliable out of all proportion to their expectations.This talk—given by an experienced polyglot programmer who once implemented Hindley Milner static type inference for “fun”, but who now builds large and successful systems in Python—explores the disconnect between the dire outcomes predicted by advocates of static typing versus the near absence of type errors in real world systems built with dynamic languages: Does diligent unit testing more than make up for the lack of static typing?  Does the nature of the type system have only a low-order effect on reliability compared to the functional or imperative programming paradigm in use?  How often is the dynamism of the type system used anyway? How much type information can JITs exploit at runtime? Does the unwarranted success of dynamically typed languages get up the nose of people who write Haskell?  For the answers to these important questions, and more, don’t miss this session.

In the space of the last year, I've been working on porting the Rakudo Perl 6 compiler to the Java Virtual Machine. Traditionally, languages have been at a disadvantage on the JVM when their type systems and dispatch mechanisms were a long way from Java. Extra dispatch and type checking logic would tend to bulk up code, throw off the JIT compiler's analysis and leave the JVM less able to apply its many, many optimizations.

Then came invokedynamic: a new JVM instruction aimed at making the situation better. While at first blush a single new instruction doesn't seem like much, it's the infrastructure that lies behind it that makes it so powerful. Really, invokedynamic is a programmable instruction, its meaning selectable - and even changeable - at runtime.

In this session I'll talk about how invokedynamic works, look at some of the ways I've been using it, and discuss how it impacts performance. I'll also try to pick out what it is about the design of invokedynamic that makes it so versatile, principles that can be applied whenever we build stuff.

The term "programming language" is often used to describe the medium we use to communicate with computers. However, to what extent can we also use programming languages like we use regular language? For example, could we use them to directly share ideas and thoughts with other people? Could programming be as live as a regular conversation? To what extent would such a live programming environment be ripe for mining novel ideas that would not only benefit the computer industry as a whole and yet even support artistic practices? This talk will explore these questions in detail emphasising the role and importance of functional languages in this context. What might a programming environment which has sufficient liveness, rapid feedback and tolerance of failure look like? Could we make such an environment live enough to support music performances? What benefits would such a style of programming offer business? Could live programming be beneficial for rapid prototyping, exploring big data sets, and even communicating formal business ideas?

Using a DI framework/container may seem obvious. But when was the last time you considered *why* do you really need one? After all, "dependency injection" is just a fancy name for passing arguments to a constructor. In the talk we'll walk through some of the features of DI containers and see if we can replace them with pure Scala code. We'll start with "manual" DI, followed with using MacWire to generate the wiring code for us. Then we'll proceed to a no-framework scopes implementation (e. g. request or session), which are very useful in web applications. We will also discuss possibilities of adding interceptors using macros. And finally, we'll see how to use traits to create and compose modules (similar to the module concept known from Guice), which can be viewed as a simplified cake pattern. As MacWire heavily uses macros, as a bonus, I'll explain how Scala Macros work and when they can be useful.

The Akka toolkit and runtime enables us to go Reactive (see www.reactivemanifesto.org) by building scalable and resilient applications. In this session we introduce Akka's most important tool, the actor model, and show how you can use it to easily build applications that scale up and out and handle failure in a self-healing way. Be prepared to see a lot of Scala code and live demos.

Good tests spur our feet,

bad tests grip like winter mud,

testing zen brings spring.

Acolyte Foo mastered the use of stubs and mocks. Soon the tests were running fast as the swiftest river.The master walked by, and deleted a swath of code: she watched as the tests passed regardless.

The next day, the other acolytes found only a straw dummy in Foo’s bed.  When they asked the master where Foo had gone, she replied: “Observe: these tests were 
Foo’s, they still pass: Foo must be alive and well”.

Thus, the acolytes gained enlightenment.

You don't yet speak Scala? Then let us invite you to a journey on which we will explore the outstanding features of this programming language for the Java Virtual Machine. As an intoduction we will briefly talk about Scala's key characteristics. Then we will explore this language and some of its typical applications, e.g. concise OO and powerful functional collections. If you are a developer and expect vivid examples and live coding, then you will love this session.