by Mike Malone
Rapid adoption of consumer web applications and Internet connected devices has pushed distributed systems work out of academia into mainstream web development. This talk will cover how we've used tools like Apache Cassandra, Flume, node.js, Hadoop, and RabbitMQ at SimpleGeo to create scalable, fast, adaptable, and resilient systems -- all critical architectural characteristics.
As an infrastructure services company, it's critical that our systems stay fast and robust at scale. As a startup, we're keen to keep costs down and returns high, and as a young company agility is doubly important. The traditional LAMP stack forces hard compromises on some of these points. Modern generic distributed systems are more flexible in this respect, and provide facilities for making compromises at a more granular level. These cutting edge technologies certainly have their own sharp points. But for us the benefits have far outweighed the costs.
Now, we know you can do that for scripting languages, but what do we do about Java? With the proper context (some kind of framework responsible for instantiating classes), it is possible to emulate many of those same capabilities, by applying a simple set of code transformations at runtime. In this session you’ll learn about meta-programming and how it can apply to traditional Java. You’ll learn about the techniques needed to transform classes at runtime, adding new behaviors and addressing cross-cutting concerns. The presentation will discuss a new framework, plastic, designed for this specific purpose, but also draw examples from the Apache Tapestry web framework, which itself is rich in meta-programming constructs.
by Andy Gross
Many technology case studies are predictably simple – covering problems, solutions and the benefits received by the user. However, the rose-colored lens of marketing departments all too often glosses over the actual hard work and tough decisions needed to get to the desired result. This session intends to take a deeper look at some popular use cases around Riak – delving deeper into the configurations and the trade-offs made by the users. Attendees of this session will come away with a greater understanding of the flexibility of Riak, as well as how Riak solves serious data problems in interesting ways, and learn where Riak might not be the best fit.
The Yesod web framework is based on Haskell, a strongly typed, purely functional language. It lets developers use traditional MVC patterns, but takes advantage of its Haskell roots, using strong typing to get rid of entire classes of bugs and security holes, thereby reducing the need for unit tests. Yesod also leverages Haskell's performance strengths - its default server, Warp, can handle more requests per second than any other web application server.
by Erik Onnen
Programming server-side Java can still be concise, effective and iterative but doing so requires changing long-standing assumptions about how Java should be written. For Java to continue to compete for developer mindshare, Java idioms need to be informed by frameworks like Sinatra and languages like Scala and Erlang.
This talk will cover techniques for writing Java applications that are highly performant and operate at scale while keeping maintenance and operational impedance low. The talk will challenge long held beliefs about Object Oriented programming, IoC and ORM frameworks and techniques for building HTTP services. The talk will attempt to demonstrate that by using simplified idioms while leveraging the power of Java tooling (such as IDEs), Java is still one of the best programming languages for the JVM and the best for deploying high performance applications on the JVM.
Twitter is increasingly relying on services written in either Java or Scala and running on the JVM. While JVM gives us a world-class runtime in terms of operational stability, performance, and manageability, it is still not trivial to achieve the desired performance characteristics of the programs being run on it, especially when you're dealing with services that need lots of memory, or have very low latency requirements, or both. In this talk, we'll present examples of performance problems we encountered while operating JVM-based services and the ways we solved them.
by Gil Tene
The original "memory wall" first predicted in the mid 1990's was supposed to have emerged by now, with applications stretching server capabilities to their limits. However, today's typical application instance only utilizes 5-10% of a modern server's capacity, and the percentage is dropping. In this session, Gil Tene (CTO, Azul Systems) discusses the Application Memory Wall and and the likely causes of an observed decade-long stagnation in application instance memory growth and consumption. Gil will analyze the key technical challenges that have led to the emergence of the Application Memory Wall, reviewing the relevant state of the art in garbage collection within managed runtimes in general, and in commercial Java Virtual Machines in particular. Gil will outline the main technical problem areas that need industry attention and focus, and shows how solving these problems can lead to a post-Wall era - an era in which applications will once again be free to productively and naturally consume the abundant compute resources available in modern servers.
14th–18th November 2011