It’s been a quarter of a century since objects really arrived on the software scene, with great fanfare, lofty expectations, and more than a little hype. One can argue, and there are those who do, that objects have won. That their triumph is complete. That object-oriented programming has become, well, programming. And yet, the case can be made that this “victory” has come at a cost that must be measured against the conceptual complexity these highbrow languages have brought with them, the architectural Balkanization and “Trail of Tiers” they have wrought, and the impedance mismatches that have resulted from the Babel of languages that O-O has spawned, and its defeat in the data tier.
Have objects met the transformative promises made for them a generation ago? Or have they done more harm than good?
The time has come to put them on trial. We’ll remand objects themselves to the dock, and hear from a panel of distinguished, expert witnesses for the prosecution and the defense, before letting the You, the Jury, decide their fate.
It's said that without evil there can be no good and that without darkness, there can be no light. Is the same true of ugly and beautiful code? Maybe... but that's certainly not a question I'll be answering in this talk. Instead, we'll talk about ugly code, where it comes from, how to avoid it, and how to rid your codebase of it. And of course, I'll share some of my favorite anti-examples from The Daily WTF.
by Alex Buckley
Oracle recently shipped JDK 7, the first major release of Java SE in nearly five years, and now we're working on JDK 8. One of the main features of JDK 8 is Lambda, a new language feature to support closures.
Oracle is also planning enhancements to the library APIs to take advantage of the Lambda feature, supporting a more functional style of Java programming and offering increased parallelism in a convenient and concise fashion. This talk will review JDK 7, describe the JDK 8 roadmap, and sketch the current state of bulk data operations on collections
by ryan betts
Most developers are familiar with the special requirements of high volume OLTP applications such as airline reservation systems and capital market ("tick") feeds - systems that process massive amounts of real-time data with "high 9s" availability and ACID-level consistency. Such extreme requirements demand highly specialized data infrastructures costing many millions of dollars.
Fueled by mobile computing, online gaming and interactive web applications, a new class of transactional systems is emerging. These systems have many characteristics of their traditional OLTP counterparts, including the need for guaranteed transactional consistency, but there are also important differences:
Time-to-implementation. Most new transactional systems must be built, tested and deployed in less than six months.
Deployed to cloud. Cloud deployments are increasingly common for all classes of new applications, and transactional systems are no exception.
Low cost profile. New transactional applications must be brought online at a fraction of the cost of traditional OLTP solutions.
In this presentation, we will discuss real-world applications of high volume transaction processing. We'll explore high- and low-frequency transaction profiles, as well as the need for real-time analytics. Importantly, we'll also discuss how high volume transactional solutions like VoltDB can be integrated into existing data infrastructures.
by Aaron Bedra
Join Clojure/core's Aaron Bedra as he steps through the ideas behind ClojureScript and demonstrates how to start using it on your applications. Aaron will build a basic web service, then move on to building the front end without ever leaving the Clojure language. You'll watch in amazement as you begin to ponder such things as "why did I ever bother with JSON", and "wow, I didn't realize how much I lost while switching programming contexts".
You will walk away from this talk armed with the things you need to get started writing your own ClojureScript code. Warning, side effects may include euphoria and unexplained oubursts of joy.
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.
Arthur C. Clarke said, “Any sufficiently advanced technology is indistinguishable from magic.” Today, we find a lot of magical thinking associated with lean management. This should be expected. Lean Manufacturing has been a spectacularly successful instantiation of lean management in the domain of manufacturing. It is no surprise that its ideas are migrating into product development. However, it might surprise you to find out that these ideas span the full range from tremendously useful to dangerously toxic. For example, though it is desirable to eliminate all variability in manufacturing, doing the same thing in product development will eliminate all innovation.
How can avoid the trap of magical thinking? Treat lean methods like the advanced technology it is. Understand the mechanisms of action behind the methods. Find out WHY the methods work, not just WHAT to do. This presentation will examine some key lean methods like queue management, batch size reduction, WIP constraints, and cadence. It will discuss their governing economic tradeoffs and how these methods can be exploited by product developers.
Keywords: Lean, Product Development, Lean Product Development, Science, Magic
Target Audience: Managers and software professionals who are seeking a deeper understanding of lean product development and why it works.
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.
Once a project has chosen an appropriate architecture, it's all about the code. We have all joined projects which have good response time and supports the required number of users, but is impossible to maintain. Why?
We have all developed for one year in the same project and saw it becoming dirtier and dirties, until it reached the point of no return, the dark whole of code quality.
It can't be something nasty and big. We don't do big nasty things. So where are all those small nasty things that we do, that accumulate over time, culminating in that horrible piece of software that no one wants to maintain?
While developing, design and code decisions influenced its quality in a way that its impossible to say what happens, when it happens and where it happens. It is time to take code in our hands and care about it: not only on the short term, but also on the long run. This talk will go through some of the small and controversial decisions, that affect code both on the short and the long run. Issues with AOP for business logic, concise code, bad tests, long code and so on; always mentioning how average and above average developers affect those projects.
Another important point is that smaller projects are easier to be rewritten: should we favor them to always keep code in shape?
Note that as this is not a language specific issue, we will go through examples of perfect running code, that is impossible to maintain, in Java, Scala and Ruby.
If you are tired of seeing the same code design mistakes, while just jumping from one language to another, this session is for you. Come and also share your examples on poor code design.
The keywords for the workshop are: TDD, Design, Quality, java, ruby, .net, scala, OO, Solid, Patterns
The target audience: Developers and architects who care about good quality. Those who want to improve their design based on TDD and those who want to improve their TDD practices based on design.
ESPN.com and its related digital properties serve tens of thousands of requests per second from sports fans around the world. Learn how they use a combination of page- and application-level caching to do so with extremely low latency and a slim hardware footprint. Find out about the technology stack that allows stats and scores to get from the field to the web -- usually before they even show up on your TV. Deep dive on various critical pieces of the ESPN technology stack including: live scoring "push" updates; dynamic content management; and personalized preferences that follow you on the site, your phone, or your TV. Finally, learn how ESPN is advancing the fan experience with cache push and XMPP.
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.
by Russ Miles
We've spent 10 years now breaking a fundamental rule of Lean Thinking. By chasing increased, and valuable, agility in software development we've often forgotten that the actual development is only one small part of the software delivery system. In many ways we're all guilty of local optimising for the problems we were left with in actual software development, and largely ignoring the harder problems of how to improve the whole software delivery pipeline such that we define and deliver more real value.
But it's not all bad news. Through lean thinking and visualising the whole system of software delivery there are now real tools and practices appearing that bring the whole system of software delivery together. This talk will share the secrets of how lean thinking and the emerging Agile Operations practices of DevOps and Continuous Delivery are to bring continuous improvement to the whole software delivery system.
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 Bob Ippolito
In order to build low-latency and high availability services over HTTP, Mochi Media has migrated to an eventually consistent data model. Riak provides the foundation, but does not provide any strategy to resolve conflicts with concurrent updates other than "last write wins" or "build it yourself". Rather than waiting for someone else to do it, we built our own abstraction that simplifies the process of building it yourself.
statebox is the open source library that we've built for automatic conflict resolution of several eventually consistent data structures such as sets, dictionaries, and counters. It also provides facilities to develop your own, given that certain constraints are satisfied. In this session you'll learn about the implementation of statebox and the applications we have built with it.
by Jez Humble
Large organizations are notoriously bad at disruptive innovation involving software. This is due both to organizational barriers and a lack of good engineering practices. In this presentation Jez will take a scientific approach to innovation in software development, using examples from organizations such as Amazon and HP.
Jez will begin by discussing the fundamentals of innovation, using the lean startup methodology. He will then tackle organizational barriers to innovation: traditional project management practices, silos between departments, and reporting structures. Good engineering practices are crucial to rapid delivery of high quality software, and so Jez will discuss the importance of continuous delivery to teams working on strategic software projects. Finally he will discuss how compliance and governance can be managed effectively while still delivering valuable software.
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.
by Robert Johnson
Social networking has dramatically changed the way we interact with web, and as a result dramatically changed the way data is stored and served. Social data at Facebook is an enormous graph of small objects that are tightly interconnected. Every page we serve is a view of this graph customized to a specific viewer at a specific time. The graph changes constantly with users' ever increasing appetite for realtime interaction. These properties of the data lead to new challenges, and new architectures to handle them. I'll be talking about some of the general approaches we take to social data at Facebook and some of the specific systems we've built to handle it.
In the software development industry, we spend a lot of time talking about good design and not nearly enough time talking about design as it is practiced normally. Every code base bears the mark of thousands of micro and macro code design decisions. In the end these decisions give code bases form and the form that they culminate in is rarely what we call beautiful.
In this talk, Michael Feathers will outline the forces that lead to the sort of code we find in the industry and discuss how we might alter our notions of beauty in design in response to the bare facts about how our actions give code shape..
by Jyoti Bansal
There's been a generational shift in how Java and .NET enterprise applications are created: they have been broken down from a monolithic architecture into multiple services, and they’re highly interconnected and distributed. How can developers and Operations teams adapt to these changes?
This talk will discuss the 4 Big Things that application professionals need to design for NOW:
- Cloud- Most every application built will have some part of its service in the cloud
- Big Data- With the advent of NoSQL, Hadoop, and distributed caches, how should we now approach the data layer?
- DevOps- Developers won't just be responsible for the code, but how it's deployed. How does that affect the Ops side of things?
- Failure is an option - Distributed systems won't just invite but demand failure, so how can failure become part of the initial design?
by David Pollak
Programming any moderately complex system presents significant technical and managerial challenges. Complex systems that can be composed from many disparate pieces into a large whole, yet be governed by simple rules are more maintainable and easier to build. Describing the relationships among the pieces of the system and allowing the computer to determine the optimal way to compute dependencies when predicates have changed allows for more composable systems that can be understood by a broad range of people, both technical and non-technical. Spreadsheets, Excel, are a tangible demonstration of this mode of programming, and other functional programming languages such as Scala and Haskell support building complex systems via composition. Please join David Pollak, Founder and Distinguished Committer on the Lift Web Framework, as he explores predicates, dependencies, functional languages and programming for the real-time cloud.
by James Sutton
It's well known that Lean improves factory production. It's less well known that Lean improves knowledge-work in general. Of course, software is the ultimate knowledge work; many projects work on nothing but knowledge!
Lean helps software development gain deep insight into project workflow...something we've never had power tools for doing before. This insight allows developers to address evolving problems more quickly and accurately than ever before. "Kanban" is the main tool for workflow visibiity. Kanban is also neutral to development process, so it works well on everything from Waterfall to Scrum.
We will discuss why Kanban works so well in software, since understanding the "why" helps one implement it more effectively. We'll also touch on why Kanban is great for improving the culture of a group that uses it...the most-important benefit of Kanban. As Peter Drucker once said, "culture eats strategy for breakfast."
Lean is of course much bigger than Kanban. Other Lean ideas and tools have been extremely effective at improving software productivity and quality. They complement Kanban and bring software to a whole new level. Some are controversial even among Lean software proponents. This talk will introduce a few of these as well.
by Mark Little
The traditional role of middleware in the data center has been challenged to expand and meet the ubiquitous computing demands becoming more prevalent. The way applications are built, deployed, integrated and managed must accommodate the rapidly evolving mobile and cloud paradigms, without sacrificing security or performance. Red Hat is at the epicenter of driving the standards and technologies with its JBoss middleware portfolio to enable developers, architects and IT executives increase return on their existing IT investment and spur innovation in next generation application environments.
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 Charlie Fineman
Stubhub is the largest live event ticket marketplace in the world. A key to our continued growth has been our ability to create innovative ticket and event “finding” experiences, on our site, on affiliate sites, and most recently, on mobile devices. This was all done using open source technologies such as SOLR, ActiveMQ, and CXF, along with a little XSL and some home grown magic. During a typical hour, we serve more than half a million complex pages on our site, in addition to more than 2 million API calls powering widgets on affiliate sites across the web. In this talk, Charlie will present the basic building blocks (as well as some stumbling blocks) that support the continuing evolution of StubHub.
How could a big glob of complicated Greasemonkey script be considered beautiful? What if it saved a company millions of dollars, let them rocket past their competitors and only cost $40 dollars to produce?
Our notion of beautiful code is incomplete when it ignores the business context of code. An elegant software solution to a problem must handle many competing forces, only one of which is technical beauty.
Genuine professionals must work in sync with business, not foolishly produce poorly-designed working code or blindly following rigid rules about “clean code”. A Sufficient Design is one that fits the business context perfectly. It may be technically elegant, good, mediocre or even poor. The art is to set quality levels to be in sync with the business context and to adjust that quality level in response to business context changes.
In this talk I’ll share real-world stories and lessons learned about Sufficient Design.
Visa technology processes billions of financial transactions around the world each year. With millions of merchants depending on Visa to fuel the lifeblood of their business, the platform architecture and technologies -- integrated and invented -- must be reliable and able to massively scale. Learn how major enterprises like Visa have architected very complex integrations incorporating leading edge technologies such at Hadoop, memcached, Ruby on Rails, and many others to deliver innovative technology solutions for a rapidly evolving market. Davies has direct experience with the integration of recent acquisitions CyberSource and Playspan into Visa and scaling both the network as well as people.
by Rick Simmons
Kanban, like all Lean-Agile approaches, is based on fundamental principles from which specific practices are derived. Together these provide mechanisms to foster improvement and manage the follow of work. One of the identifying characteristics of a mature Kanban team is its ability to leverage core concepts to foster the emergence of more evolved practices.
So principles and practices are complimentary, and coaching new teams on both of these aspects is important. As coaches, we want to provide a solid starting point that the team can apply to its work. We also want to create a basis for continued growth.
But in nearly all contexts, available time for coaching is limited, and teams are anxious to start. So, how should we launch a new team? What are the critical things to consider? What are the most important concepts?
My colleagues and I have developed a launch process that we deliver in two days, which we’ve validated in dozens of engagements and with our peers. In this session, I’ll describe the launch process and provide an outline for what to cover, how to balance concepts and mechanics, and how to set the team on a trajectory of improvement.
Platform-as-a-Service (PaaS) is gaining interest, both in true public cloud as well as on-premise private cloud. The reason is that PaaS can add significant value to a cloud environment and build a strong framework for developers to take advantage of more than just hosting an image in a cloud.
Stratos is an open source project that provides a complete Cloud PaaS that is not only running on the web, but available as a full Open Source distribution for use in public, private or hybrid cloud. In this session we will explore how Stratos provides a full Platform-as-a-Service (PaaS): multi-tenant, elastic and metered. Stratos enables users to quickly build out highly-scalable applications with no lock in. Even more interesting, it allows organizations to build out their own PaaS – whether on the public cloud or on a Eucalyptus, vmWare, OpenStack or Ubuntu Private Cloud. We will dig into the challenges of multi-tenancy, elasticity and metering, and show how to get started with running and managing Stratos.
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.
Webmachine is a system for easily and declaratively building well-behaved HTTP applications. It is based on a very different execution model than most frameworks, with sets of resources defined by collections of functional predicates over those resources. This aproach makes it easy to focus on writing the core of your application and also helps you to get the harder parts of HTTP right. Steve will discuss Webmachine's unusual Web programming model and demonstrate the simplicity and power that this model provides.
14th–18th November 2011