•  

Tech Mesh schedule

View as grid

Tuesday 4th December 2012

  • Haskell: practical as well as cool

    by Philip Wadler, Simon Peyton Jones and John Hughes

    You’ve probably heard about Haskell by now, but life is short, so why should you bother about yet another programming language? In this talk we’ll focus on three distinctive aspects of Haskell that you might make it worth the bother. First, purity: uncontrolled side effects are the bane of correctness, testing, and parallelism, and Haskell get them under control. Second, types: going well beyond the sterile static/dynamic debate, Haskell is an amazing cauldron of new ideas in types, and we’ll tell you why that matters. Last, domain specific languages: we all need them and no language makes it easier to develop and morph a DSL than Haskell. We hope you’ll go away at least provoked and intrigued.

    At 9:15am to 10:15am, Tuesday 4th December

    In Woburn, Hotel Russell

    Coverage slide deck

  • Erlang and OpenFlow: A Match Made in the Cloud!

    by Stuart Bailey

    How our view of networking must evolve to address the multi-core crisis!

    I'll be describing LINC: an Open Source OpenFlow switching platform developed in Erlang intended for use with the OTP. I will also introduce OpenFlow, the Open Network Foundation, and the community around LINC called FlowForwarding.org.

    Talk objectives: Spark debate and interest in solving networking challenges in ultra-scale computing platforms like Erlang/OTP and Scala/AKKA.

    Target audience: The Erlang/OTP community and emerging ultra-scale computing enthusiasts.

    At 10:35am to 11:25am, Tuesday 4th December

    In Benjamin's, Hotel Russell

  • Faith, Evolution, and Programming Languages: from Haskell to Java

    by Philip Wadler

    Faith and evolution provide complementary--and sometimes conflicting--models of the world, and they also can model the adoption of programming languages. Adherents of competing paradigms, such as functional and object-oriented programming, often appear motivated by faith. Families of related languages, such as C, C++, Java, and C#, may arise from pressures of evolution. As designers of languages, adoption rates provide us with scientific data, but the belief that elegant designs are better is a matter of faith. This talk traces one concept, second-order quantification, from its inception in the symbolic logic of Frege through to the generic features introduced in Java 5, touching on aspects of faith and evolution. The remarkable correspondence between natural deduction and functional programming informed the design of type classes in Haskell. Generics in Java evolved directly from Haskell type classes, and are designed to support evolution from legacy code to generic code. Links, a successor to Haskell aimed at AJAX-style three-tier web applications, aims to reconcile some of the conflict between dynamic and static approaches to typing.

    Talk objectives: Offer a historical perspective on the development of programming languages, considering the roles of faith and evolution.

    Target audience: Engineers interested in the evolution of Programming Languages

    At 10:35am to 11:25am, Tuesday 4th December

    In Virginia Woolf's, Hotel Russell

  • Gaming: How to deal with too much Success

    by Enrique Paz Pérez

    In the talk I start by describing how Spil Games built a successful online gaming platform and what technical & organization challenges we encountered along the way. Then I will focus on architectural solution that we settled on and how this will resolve scalability issues in terms of throughput, data storage, and organization scaling.

    Talk objectives: Sharing the lessons learned from how we are re-implementing our core systems using a new architecture.
    Forming an understanding in the mind of the listener in how the architectural design informs many parts of the organization, not just technical or software development, but also processes.

    Target audience: (Software) architects, Software engineers, Erlang developers, Software development managers, Technical team leads, System engineers

    At 10:35am to 11:25am, Tuesday 4th December

    In Library, Hotel Russell

  • Next Top Data Model

    by Ian Plosker

    Data modeling is hard, especially in the world of distributed NoSQL stores. With relational databases, developers have tended to store normalized data and shape their query model around that structure. This can come back to bite you when it comes time to scale, as complex queries across dozens of tables begin to affect application performance. It’s common to find developers rethinking their data model as query latency increases under load.

    With NoSQL stores, developers must consider their query patterns from the outset of application development, designing their data model to fit those patterns. A number of techniques, new and old, can be used to allow for maximum performance and scalability.

    Topics covered will include:
    De-normalization, time boxing, conflict resolution, and convergent & commutative replicated data types. Additionally, discussions of common query patterns in light of the capabilities of various NoSQL data stores will be reviewed.

    Talk objectives:
    To enable developers to understand that the data model must follow query patterns when using a NoSQL storage solution.

    Target audience:
    Developers using or thinking about using a database, be it relational or NoSQL. Anyone interested in distributed systems.

    At 10:35am to 11:25am, Tuesday 4th December

    In Woburn, Hotel Russell

  • Developing and Integrating WebSharper applications with Facebook

    by Adam Granicz

    In this talk, I will present some of the work we are doing at IntelliFactory to enable creating mobile and web applications with F# that can interface with social networks such as Facebook. I will demonstrate how one can develop using various functional programming techniques a simple web application in F# that can be run in the browser, in a mobile app, and as part of a Facebook page - all from the same code base. This work leverages our open source WebSharper framework, the main web and mobile development framework for F#. WebSharper provides powerful functional programming abstractions that enable modeling first-class, type-safe, composable web applications and user interfaces, and automates the translation of client-side F# code to JavaScript.

    Talk objectives: The talk aims to demonstrate the use of functional web programming abstractions and how WebSharper enables creating web and mobile applications in F# in a succinct and robust way.

    Target audience: Developers, Application architects, IT Managers and Decision Makers.

    At 11:35am to 12:25pm, Tuesday 4th December

    In Library, Hotel Russell

  • Multi-core with less Pain: Deterministic Parallel Programming with Haskell

    by Duncan Coutts

    You want to make your code run faster, so you think about changing it to run in parallel to use multiple cores. But most approaches to parallelism also force you to rewrite your program using explicit concurrency which means you'll always worry about race conditions, deadlocks and other concurrency bugs. Deterministic parallelism frees you from concurrency bugs and gives a strong guarantee that your program remains deterministic, so it will give the same result no matter the number of cores or the scheduling being used.

    Haskell offers a variety of libraries for deterministic parallelism that enable concise high-level parallel programs. In this talk we will look at the idea of parallelism without concurrency and give an overview of the paradigms that Haskell offers in this area.

    Talk objectives: The point of the talk is to understand the distinction between parallelism and concurrency and see how functional programming lets us achieve the benefits of parallelism without forcing us into using concurrency. We will see a few different approaches to deterministic parallelism and you should get a sense of which approach to use for which kind of problem, or indeed when concurrency is the best approach.

    Target audience: If you're interested in multi-core parallelism or functional programming then you should get something out of this talk.

    At 11:35am to 12:25pm, Tuesday 4th December

    In Benjamin's, Hotel Russell

  • Pragmatism, Puritanism and Functional Programming

    by Ben Moseley

    This talk will examine the promise, potential and pitfalls of functional programming (FP) - both as a potential alternative to and extension of more widely-used programming paradigms. Drawing on real-world industrial experience of the exclusive use of pure functional programming over the past 5 years, the talk will highlight the benefits but also the limitations of FP. Can all the benefits of FP be gained by extending a traditional language?. From a pragmatic, industrial perspective does pure FP go too far? Does it go far enough?

    Talk objectives: To investigate the realities of using pure functional programming.

    Target audience: Professional software developers who are interested in Functional Programming but maybe have concerns / reservations about how it might play out in the real world. Is it all abstract mathematical nonsense about proving programs correct and talking about Monads, or could it actually be relevant to real people just wanting to get the job done?

    At 11:35am to 12:25pm, Tuesday 4th December

    In Virginia Woolf's, Hotel Russell

  • The Database as a Value

    by Rich Hickey

    Proponents of functional programming tout its many benefits, most of which are available only within a particular process, or afforded by a particular programming language feature. Anything outside of that is considered I/O, dangerous and difficult to reason about. But real systems almost always cross process and language boundaries, and most require, crucially, a very gnarly bit of shared state - a database. In this talk we will examine how Datomic renders the database into that most prized and easy-to-reason-about construct, a value, and makes it available to multiple processes in multiple languages, functional and not.

    Along the way, we'll discuss the importance of immutability and time in representing information, the reification of process, and the mechanisms of durable persistent data structures. No knowledge of functional programming is required.

    Talk objectives: To make people rethink fundamentals of database architecture, in light of the principles of functional programming.

    Target audience: Anyone who builds systems involving databases.

    At 11:35am to 12:25pm, Tuesday 4th December

    In Woburn, Hotel Russell

  • ClojureScript: The Essence of Alchemy

    by David Nolen

    It is no longer possible to ignore the reach of JavaScript Thanks to the web, JavaScript is one of the most widely distributed programming languages. Thanks to intense coporate competition between Google, Apple, and Mozilla, JavaScript engines are some of the fastest runtimes available. Yet JavaScript has many well known (and not so well known) shortcomings. This talk will discuss how JavaScript strengths can be leveraged and its costs mitigated via transpilation using ClojureScript as a specific example.

    Talk objectives: JavaScript is an excellent and improving target for functional programming languages. This talk will illustrate why and how.

    Target audience: Anyone interested in web and mobile technologies.

    At 1:25pm to 2:15pm, Tuesday 4th December

    In Virginia Woolf's, Hotel Russell

  • Go Do: solving Real Problems correctly with Go

    by ✕✕✕✕✕

    Software engineering can be considered a process: developing a system from its current state to its ideal state. For many problems in large-scale web environments, Go is an excellent tool to facilitate that process. A very brief introduction to the language is followed by examples of real-life use-cases at SoundCloud. The talk demonstrate how Go's simple, powerful, and orthogonal primitives can be combined to build robust, maintainable software.

    Talk objectives: The talk aims to demonstrate that Go is a production-grade language, whose unique combination of simplicity and orthogonality lends itself to elegant solutions to a large class of problems.

    Target audience: Engineers managing complex requirements in distributed, fault-prone environments, who value simple, unambiguous, and robust service-oriented solutions.

    At 1:25pm to 2:15pm, Tuesday 4th December

    In Library, Hotel Russell

  • Implementing Riak in Erlang: Benefits and Challenges

    by Steve Vinoski

    Riak is a scalable, reliable, open source distributed database modeled after Amazon Dynamo, and it also supplies additional features such as secondary indexes and full text search. Riak is accessible via a wide variety of programming languages but is implemented mostly in Erlang, and is primarily written and maintained by the developers at Basho Technologies. The choice of using Erlang has resulted in both benefits and challenges to the Basho team and Riak community.

    Talk objectives: In this talk, Steve will provide an overview of Riak, its internal architecture, and its Erlang implementation. Along the way he'll discuss the advantages and challenges of using Erlang to implement Riak.
    The goal is to supply attendees with details of the benefits and challenges of using Erlang/OTP for a highly scalable and reliable production system.

    Target audience: This talk is intended for anyone who is not already an expert in Erlang/OTP and is considering using it for their products and production systems.

    At 1:25pm to 2:15pm, Tuesday 4th December

    In Woburn, Hotel Russell

  • The Actor Model applied to the Raspberry Pi and the Embedded Domain

    by Omer Kilic

    The Actor Model has interesting properties that could be used for dealing with complexities posed by modern embedded systems. Using actors as compositional units to describe these systems is a new proposal which stands out and challenges conventional approaches.

    This talk will demonstrate how, creating a layered architecture for hardware modules and partitioning up complex systems in smaller units, testing becomes much easier, runtime errors are contained, and the architecture becomes maintainable.

    At 1:25pm to 2:15pm, Tuesday 4th December

    In Benjamin's, Hotel Russell

  • A Little Graph Theory for the Busy Developer

    by Jim Webber

    In this talk we'll explore some of the innate properties of (social) graphs from fields like anthropology and sociology. By understanding the forces and tensions within the graph structure, we'll be able to predict how the graph will evolve over time.

    In turn we'll apply these powerful techniques to modelling domains in Neo4j (a graph database) and show how Neo4j can be used to drive business intelligence using both techniques like graph algorithms and predictive techniques from graph theory.

    Don't worry, there won't be too much maths either :-)

    Talk objectives: to show the audience how a few simple, well-known properties of graphs can be used to power some impressive predictive analytics from a connected data set.

    Target audience:

    Broadly two categories:
    1. Data scientists
    2. Developers who want insight into their customer behaviour, especially around social recommendations.

    At 2:25pm to 3:15pm, Tuesday 4th December

    In Woburn, Hotel Russell

  • From Java to Erlang Thinking

    by Kresten Krab Thorup

    Designing systems in Java is very different from designing systems in Erlang. In this talk, I'll report on my journey from being an expert Java developer into the land of Erlang concurrency and systems design. As always when you travel to foreign places, you may learn more about the place you came from than you expected. Some of the new concepts I learned certainly changed the way I look at Java in ways I did not anticipate.

    Talk objectives: Report from a journey.

    Target audience: Attendees who want to see the difference in thinking in the Java and Erlang ecosystems.

    At 2:25pm to 3:15pm, Tuesday 4th December

    In Virginia Woolf's, Hotel Russell

  • Social Architecture 101

    by Pieter Hintjens

    Social Architecture by analogy with conventional architecture, is the process, and the product, of planning, designing, and growing an on-line community. Social architectures, in the form of on-line communities, are the cultural and political symbols, and works of art of the Digital Society. The 21st century will be identified with its surviving social architectures.

    As Social Architects, we participate in communities, we identify successful naturally-occurring patterns, or we develop new patterns, and we apply these deliberately to our own architectures. We apply psychology (our social instincts), economics (how we create common wealth through specialization and trade), politics (how we collect and share power), and technology (how we communicate). We continually adapt our toolkit based on new knowledge and experience. Our goal is to create on-line communities that accurately solve the problems we identify, that grow healthily, and that survive by themselves.
    All successful communities are based on the inherent contract of mutual benefit. That is, it is possible to build a billion-dollar business based on volunteer labor, but only if every participant contributes for selfish reasons. Often participants do not realize, or care, that they are part of a community. However, every single act is economic. Thus, "crowd sourcing" (as the exploitation-for-profit of volunteer labor is sometimes called) only works when the crowd really wants to solve the problems you throw at it.

    As a worked example I will explain how we designed and grew the highly successful ZeroMQ community.

    Talk objectives: Explain how to build open source communities.

    Target audience: Budding social architects.

    At 2:25pm to 3:15pm, Tuesday 4th December

    In Library, Hotel Russell

  • The Disruptor, Now, Next and the Future

    by Michael Barker

    This talk will start with a little bit of the history and motivations behind building the Disruptor and some of it's current problems. Then by doing a whistle-stop tour through non-blocking concurrency in Java it cover the changes coming into version 3.0 and how it will address some of the aforementioned issues. This includes lifting the covers on the how some of the important concurrency primitives in Java are implemented on Intel x86. Lastly we'll focus on asynchronous event systems (e.g. CSP, Actors, Disruptor, Queues, etc.) in general and how changes in the JVM and hardware could help to build the ultimate eventing system.

    Talk objectives:
    - Provide a greater understanding of non-blocking concurrency on the JVM.
    - Shed some light on the internals of the Disruptor.
    - Challenge attendees to think about the possibilities of what could be achieved on modern hardware.

    Target audience: Those who are interested in performance, concurrency and low-level technical details.

    At 2:25pm to 3:15pm, Tuesday 4th December

    In Benjamin's, Hotel Russell

  • How F# Learned to Stop Worrying and Love the Data

    by Tomas Petricek

    The world of data speaks a different language than the world of programming languages. It uses REST, SQL database schema, XML, JSON while programming languages only understand types and classes. This causes big confusion when we try to access data from programming languages, especially from those with (otherwise very useful) static type systems.

    How can a programming language learn to understand data? In this talk, I'll show how this is done using type providers in F# 3.0. You'll see how integrating data into the programming language opens the possibilities for creating exciting applications.

    Talk objectives:
    Explain the mismatch between data and programming languages and show how this can be solved by an extensibility mechanism like F# type providers.

    Target audience:
    Anyone who writes software that works with data including programmers, architects, analysts and data scientists.

    At 3:35pm to 4:25pm, Tuesday 4th December

    In Virginia Woolf's, Hotel Russell

  • Real-world scaling with Scala & Akka

    by Kevin Wright

    A brief journey through the scaling that we had to deal with at Zeebox, and how running on the JVM allowed us to bring some very effective and mature tools to bear on profiling & load-testing tools to bear, how we primarily use Akka as an asynchronous/event-driven framework far more than we use it as an Actor framework, how we use JSON as the lingua-franca across hundreds of nodes in EC2, and how the ability to create DSLs in Scala and to easily create the right abstractions made it far easier to test ideas and to rapidly change bad decisions.

    Talk objectives: Explore how Scala and Akka fit within a larger framework of ideas in a real-world setting; such as Agile project management, RESTful web services, cloud computing, and the ever-popular social networking!

    Target audience: Anyone curious about the suitability of Scala for use in a new or existing project, and anyone investigating potential technologies for a large multiple-component cloud based architecture.

    At 3:35pm to 4:25pm, Tuesday 4th December

    In Benjamin's, Hotel Russell

  • The Properties of Riak

    by John Hughes

    Riak is one of the new breed of no-SQL database management systems, which has begun to replace relational databases for some applications. Riak is a distributed key-value store, inspired by Amazon’s Dynamo, designed for applications where scalability, low latency and high availability are critical. Riak uses replication to provide fast access to data, even when multiple nodes or parts of the network fail. It supports concurrent access to the same data by multiple clients, even when the network is partitioned. All of this makes it very hard to test.

    I will show how QuickCheck helped us to model Riak’s behaviour, improving understanding and revealing the occasional bug.

    Talk objectives: To show how property-based testing can be used to find subtle interactions that it just isn't practical to test for with a hand-written test suite.

    Target audience: Anyone interested in testing more with less work!

    At 3:35pm to 4:25pm, Tuesday 4th December

    In Woburn, Hotel Russell

  • You are not Alone - Scaling Multiplayer Games for the Web

    by Knut Nesheim and Jesper Richter-Reichhelm

    At Wooga we are creating the next generation of social games. To be truly social, a game needs to offer real interaction between players in different forms.

    Taking one of our upcoming games as an example we will present the state synchronization used in client and server, how we do real time communication without websockets and how we are making a backend scalable enough to support millions of users every day. We will also share secrets about our prototypes for first person and real time strategy games.

    The Erlang process model with evented IO, asynchronous messaging, links and isolation fits very well to real time multiplayer games. Come to our talk to see how it's used to build a very successful business.

    Talk objectives: Show why Erlang is ideally suited to build real time multiplayer games.

    Target audience: Any developer with interest in distributed systems, complex state handling, or games in general.

    At 3:35pm to 4:25pm, Tuesday 4th December

    In Library, Hotel Russell

  • I am for the Web - Massive IM Scalability using WebSockets

    by Michal Slaski

    The ability to chat with your fellows is an important feature of games and social applications. In the talk I discuss chat features of mobile and web applications. I start by describing messaging protocols and focus on XMPP. Then I present techniques of connecting client applications with servers (TCP, HTTP and WebSockets) and discuss benefits of each technique.

    Then I will focus on how server scalability can be achieved and will share experiences from implementing MongooseIM - an XMPP server in Erlang.

    Talk objectives: Sharing the lessons learned from scaling IM applications.

    Target audience: Software developers and architects, technical team leads

    At 4:35pm to 5:25pm, Tuesday 4th December

    In Library, Hotel Russell

    Coverage video

  • Living in a Polyglot World: Ruby on the Client, Erlang on the Server

    by Christopher Brown

    Over the course of 4 years as a startup in the configuration management space, Opscode has seen a lot of code come and go. We've just completed a full rewrite of the server side API from Ruby in Unicorn to Erlang in Webmachine, with amazing improvements in memory usage and concurrency. I'll talk about why, for Opscode, Ruby is still the best choice on the client, but Erlang rules the server.

    Talk objectives: This talk shows the "horses for courses" choices we make in languages and technologies to serve a diverse set of business needs.

    Target audience: This talk will appeal to technical implementers of scalable web services, functional programmers of all sorts, and even Ruby zealots!

    At 4:35pm to 5:25pm, Tuesday 4th December

    In Benjamin's, Hotel Russell

  • The New Face of Cassandra

    by Michaël Figuière

    Cassandra has always been a highly performant distributed database, but not always simple to use though. Apache Cassandra 1.2 finalizes CQL3, a query language which provides a new interface to communicate with Cassandra that dramatically shrink its learning curve and simplify its daily use while still relying on its highly scalable architecture and storage engine.
    This talk will briefly introduce Cassandra and will then present an overview of CQL3 query language, a look at the new client architecture, and an update on data modeling best practices. Then we'll see how to implement an enterprise application using this new interface so that the audience can realize that a number of design principles are inspired from those commonly used with relational databases while some other entirely different, due to Cassandra partitioning approach.

    Talk objectives: This talk aim to help the audience to get familiar with the new face of Cassandra, which has been designed to make it simpler to use for mainstream enterprise applications

    Target audience: Beginner/Intermediate with NoSQL DBs

    At 4:35pm to 5:25pm, Tuesday 4th December

    In Woburn, Hotel Russell

  • vert.x - Polyglot Asynchronous Application Development for the Modern Web

    by Stuart Williams

    Vert.x is the new polyglot asynchronous application framework for the JVM from VMware that enables you to write effortlessly scalable asynchronous, web-enabled applications in JavaScript, Java, Ruby or Groovy.

    In this talk Tim will be explaining why the growing number of mobile and internet enabled devices demand applications that can efficiently handles 10s if not 100s of thousands of concurrent connections, and how that leads us to an asynchronous programming model.

    We'll look at how Vert.x's super simple simple concurrency model frees you from the pitfalls of traditional multi-threaded programming, and we'll cover how to use the Vert.x event bus to communicate between the components of your applications, including client side JavaScript, enabling you to create modern "real-time" web applications incredibly simply.

    At 4:35pm to 5:25pm, Tuesday 4th December

    In Virginia Woolf's, Hotel Russell

  • Keynote: The Language of the System

    by Rich Hickey

    Most software systems are not single processes written in a single programming language. Instead, systems are composed of a suite of processes, often written by separate parties. Even when every process is written in the same language, there is another language present, emerging from the interfaces, protocols, facilities and semantics the components offer to each other. Unlike most programming languages, these emergent languages are ad hoc, incomplete and poorly specified, with quirky semantics. In this talk we'll look at the roles these emergent languages play in the system as a whole, their characteristics, and the choices involved, drawing analogies to the facilities programming languages and their runtimes provide. We'll also look at what programming languages might learn from the requirements of systems.

    Keynote objectives: To inspire and provoke

    Keynote audience: Programmers building systems in multiple languages

    At 5:30pm to 6:30pm, Tuesday 4th December

    In Hotel Russell

Wednesday 5th December 2012

  • Keynote: 183 Years of Programming

    by Joe Armstrong, Mike Williams and Robert Virding

    The three of us (Joe, Robert and Mike) have more than 183 years combined experience of programming. We have noticed the vast majority of software development projects use programming languages based on concepts which were developed close on a half a century ago. Tools and development environments have changed, but with few exceptions the basic paradigms remain the same.

    We will reflect on out experience, what is good, what is bad and what is ugly. How did the past and our experience influence us when we developed Erlang.

    At 9:00am to 10:00am, Wednesday 5th December

    In Woburn, Hotel Russell

  • 100% Big Data. 0% Hadoop. 0% Java.

    by Pavlo Baron

    If your data is big enough, Hadoop it!" That's simply not true - there is much more behind this term than just a tool. In this talk I will show one possible, practically working approach and the corresponding selection of tools that help collect, mine, move around, store and provision large, unstructured data amounts. Completely without Hadoop. And even completely without Java.

    Talk objectives: Show how continuous analytics of large amounts of random data can be done without Hadoop, Java and corresponding tools.

    Target audience: Developers, Architects, Managers, Project leads, geeks.

    At 10:20am to 11:10am, Wednesday 5th December

    In Library, Hotel Russell

  • Application Stacks for the Modern World

    by Rob Harrop

    The last five years have seen a dramatic change in the makeup of the application stack.

    What was typically a cookie-cutter affair of bare metal servers running a monolithic application server talking to a relational database, is now an exotic mix of architectures, platforms, data stores, and languages.

    This talk explores the four most important trends that are influencing how the application stack is changing.

    Wide availability of cloud infrastructure opens the door to new architectural styles while facilitating easier, faster and cheaper access to large-scale compute resources. As developers we need to be familiar with the wealth of cloud options available and be comfortable with how we can apply them to solve our problems.

    The acceptance of polyglot applications affects the stack in a great many ways. Not only are applications being written in multiple languages, but there is now a much wider selection of middleware components to chose from. Developers now need to understand more than just Java or C# to get by.

    The NoSQL movement has yielded a great selection of relational database alternatives. From key-value stores to document-oriented databases, developers now have an important choice to make when assessing how to handle their data requirements.

    The rise of DevOps has increased the importance of integrating development and operations. As a developer, an understanding of how your systems are managed and monitored is critical. Projects and Chef, Puppet and MCollective mean that developers now have an important role to play in creating an effective operations organisation.

    Talk objectives: Highlight the changes and developments in application stack makeup in the last few years and equip developers with the understanding needed to build modern applications.

    Target audience: Architects and developers interested in full-stack architectures.

    At 10:20am to 11:10am, Wednesday 5th December

    In Virginia Woolf's, Hotel Russell

  • Making EDSLs fly

    by Lennart Augustsson

    In this talk Lennart will show how to implement a toy EDSL (Embedded Domain Specific Language) in Haskell.

    First, we will look at how to get a typed DSL embedded in Haskell.

    Second, we will consider executing such a language using an interpreter.

    Finally, we will use the LLVM bindings to generate efficient code for the toy EDSL.

    At 10:20am to 11:10am, Wednesday 5th December

    In Benjamin's, Hotel Russell