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.
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.
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
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
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.
To enable developers to understand that the data model must follow query patterns when using a NoSQL storage solution.
Developers using or thinking about using a database, be it relational or NoSQL. Anyone interested in distributed systems.
by Adam Granicz
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.
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.
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?
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.
by David Nolen
Target audience: Anyone interested in web and mobile technologies.
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.
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.
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.
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.
Broadly two categories:
1. Data scientists
2. Developers who want insight into their customer behaviour, especially around social recommendations.
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.
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.
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.
- 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.
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.
Explain the mismatch between data and programming languages and show how this can be solved by an extensibility mechanism like F# type providers.
Anyone who writes software that works with data including programmers, architects, analysts and data scientists.
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.
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 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.
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
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!
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
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.
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
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.
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.
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.
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.
4th–6th December 2012