Your current filters are…
Breaking news: Google to unveil World News at GOTO Amsterdam. The whole world will be on alert when Google presents a new programming language "Dart" in the opening keynote. Join us and GOTO Amsterdam and get all the details.
by Alex Russell
Target audience: Front end developers.
by Ola Bini
The Java ecosystem is experiencing an interesting time, both with large technical changes but also a changed political landscape. Oracle is a very different company than Sun, and that's been obvious from such things as how the Java Community Process has been handled, and also in interactions with projects such as Hudson and Android. So is Java still relevant? Is it the platform or the language we are interested in, and what will have to be done to future proof these technologies? This presentation will take a critical look at both the technical and political landscape of Java, and also look at what kind of changes in process might be necessary. You will leave knowing a bit better what might be coming next, and how it will impact you.
by Dave Thomas
In this talk we describe the huge opportunity for innovation in Legacy systems! We argue there has never been a better time for creative legacy renovations which leverage new hot technologies – languages; data bases; web; cloud and Agile practices. Many talented developers turn up their noses or run away in fear from what they see as baroque environments with arcane tool chains. Talent panic often pushes for a grand rewrite using modern technology. Sadly experience shows the grand rewrite has too much risk and way too little business value. Hence given legacy investments the only option is innovation!
We illustrate legacy innovations via several case studies spanning a wide spectrum of legacy systems including: mainframe IT; Unix products; military systems; telecom; data banks and multi-vendor EAI and EAP applications. We explain the appropriate practices, teams, and tools to achieve high impact renovations by inserting new technology. We discuss appropriate investments in training, tooling and practices for different legacy environments. We look at approaches to ensuring lasting high value relationships between legacies and bleeding edge technology.
by Fred George
The Agile movement shifted the relationship between clients and developers in a profound way. In waterfall processes, clients specified large amounts of functionality, then nervously faded into the background until the fateful day-of-delivery. With Agile, developers strove to engage with clients continuously, and deliver much more frequently against their needs. A new trust was established.
At the Forward Internet Group in London, we are implementing a second major shift between clients and developers. The trust of the clients in developers evolves into a broader trust of the developers to deliver business value without resorting to a series of well-defined stories. In essence, the business has empowered the developers to do what they think is right for the business. This model, popularized by Facebook, has several labels, but the one we prefer for our flavor is Programmer Anarchy.
We will start with stock Agile, and begin to apply environmental factors that led us to drop "standard" Agile practices. We will also watch as well-defined Agile roles evaporate completely as other environmental factors are applied. Finally, we will arrive at Programmer Anarchy, an organization often following none of the standard Agile practices, having no BA or QA roles, and even missing any managers of programmers.
We will summarize our environmental factors, and postulate on the required and optional factors.
We will make bold, controversial assertions. We will back up these assertions with actual experiences.
Keywords: Agile, post-Agile, Anarchy, Empowered, Forward, No managers, No testers, No business analysts
Target Audience: Agile practitioners (developers and coaches) will be interested in this talk as we subscribe to the Agile principles but few of the practices. Management will find the enabling factors enlightening, giving them ideas they may apply to their existing teams.
by Rik Arends
We have come full circle. We can now write our software entirely in the browser. Think google docs, for software development. In this talk i want to go through what is and will be possible when we move software development into the browser. Cloud hosting, collaboration and accessible everywhere. Cloud9 IDE is a complex web-application written with HTML5 and Node.JS technologies, and as developers we are using Cloud9 to create Cloud9 itself. For the more advanced developers i will also briefly dive into the technology and systems behind the IDE that make all this possible.
Keywords: Cloud9 IDE, Node.JS, HTML5, software development, cloud, collaboration
Target Audience: (Web) Software Developers, Architects and managers interested in developer infrastructure.
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 Jez Humble
Deployments gone bad are a leading cause of spending your evening or weekend hunched over a terminal instead of outdoors having fun.
In this talk Jez Humble presents a number of patterns which reduce the risk of releases, including techniques for zero-downtime releases, roll backs, and roll forwards.
He also discusses how to build reliable releases into your delivery process using automated provisioning, deployment, and smoke testing. By the end of the talk, you will understand how to build delivery systems - and teams - that make broken deployments a rare situation which can be fixed at the push of a button.
The “big” in Big Data has led to some confusion as to what the concept is all about. While some Big Data applications are leveraging huge data sets, many are not using large data sets – but rather managing very important sets of data in a distributed fashion. This session will outline how the massive migration of IT into the cloud has led to a need for distributed data platforms like Riak – and also how the distributed nature of the cloud and the Riak platform can help unlock greater potential in how businesses can capture, process and store data in new and innovative ways. Led by examples of various Riak deployments, this talk will look to show that the “Big Data” really means “Big Idea.”
The ASP.NET MVC framework has been around for more than two year now and has been constantly gaining popularity since then. However, despite that fact a lot of MVC developers are not aware of various hidden gems that can make their development experience much easier and nicer. In this session we will go through some of those which were added in the latest version – ASP.NET MVC 3.
Spring Framework 3.1 continues Spring's mission with a focus on flexible Java-based configuration. This session introduces foundational 3.1 facilities such as environment profiles for application contexts, feature specifications within configuration classes, and Spring’s new caching abstraction. Finally, the session will cover Spring’s ongoing support for enterprise Java specifications: in particular Servlet 3.0 support.
Keywords: Java, Spring
Target Audience: Spring Users
In Software, every customer and manager is expecting a high quality product, but that is proving to be harder than it sounds. We put a lot of time and effort in writing tests to prove the software is correct and analyzing its metrics. But do we have the right tools for the job? Are we focusing on the right type of quality and can we do a better job, supported by the right tools?
During this talk we will go into what quality means and how we can categorize quality. Per category we look at the different tools, what they can offer us and why the tools have an important role in our quality-focused infrastructure. Afterwards you will have an impression of the tools on the market which can help you achieve higher quality in your products and you will have an understanding of the purpose of those tools.
Keywords: Quality, Process, Tools, Development Infrastructure, Continuous Integration,
Target Audience: Senior Developers, Architects and IT Managers
by Greg Young
We as developers have many biases that often we need to take a step back from in order to gain perspective. This session will deliberately go after many of our sacred cows and show how they are really just us over-optimizing a belief. All of these lead to a single generalized rule and a strategy for how to avoid these situations.
Keywords: IOC, DRY, Patterns, Frameworks, Insanity
by Karl Krukow
On the server we often speak about so-called "non-functional" requirements of a program or an architecture, e.g., maintainability, extensibility, robustness and performance. We also have technical requirements that focus more on code structure e.g., separation of concerns, modularity, loose coupling, avoiding duplication.
Why are there so large differences in our mindset on the front- and back-ends?
by Jonas Bonér
We believe that one should never have to choose between productivity and scalability, which has been the case with traditional approaches to concurrency and distribution. The cause of that has been the wrong tools and the wrong layer of abstraction and Akka is here to change that. Akka is using the Actors together with Transactional Memory to create a unified runtime and programming model for scaling both UP (utilizing multi-core processors) and OUT (utilizing the grid/cloud). Akka provides location and network transparency by abstracting away both these tangents of scalability by turning them into an operations and configuration task. This gives the Akka runtime freedom to do adaptive automatic load-balancing, cluster rebalancing, replication and partitioning. In this talk you will learn what Akka is and how it can be used to solve hard scalability problems. Akka is available at akka.io (under Apache 2 license).
Currently many business applications are developed using a very database centric approach, often requiring the use of complex and heavy-weight Object-Relational Mappers (ORMs) to make developers productive. Although improvements have been made (through the use of annotations, reflections, conventions) the core issues remain:
Lack of modularity
High coupling to the used ORM and/or underlying database, making it unnecessarily hard to use alternative (NoSQL) or multiple databases
Hard to understand the full application, due to the complexity of the used ORM
Mutability is in-grained, reducing the possibilities for composition and modularity
Limited possibility for abstraction, due to limitations imposed by the ORM on used data types, etc.
In this talk we'll explore the use of an alternative approach usingthe techniques pioneered by Domain-Driven Design (DDD) and especiallyCommand-Query Responsibility Segregation (CQRS): Event Sourcing.
Using Event Sourcing the application can be split into two parts:
Domain logic responsible for generating events (command side)
Reporting, view, integration, etc. logic that consumes the generated events ("query" side).
Through this explicit notion of change (domain events) the developer is put back in control of the application.
Traditional languages such as Java require a lot of ceremony when implementing event sourcing, obscuring the basic simplicity. Using Scala's flexible syntax and support for light-weight classes, immutable data structures and transactional memory only very little support code is needed to build production ready applications using Event Sourcing. We can start simple and scale up to more complexity only when needed. During this talk we'll take a quick tour through thecode you might need to get started.
The goals are to make developers productive while keeping applications understandable and maintainable. This is achieved by:
Putting the developer back into control, instead of a framework
Keeping infrastructure concerns out of your domain code
Manage complexity in a scalable manner. Simple functionality ("CRUD") is easy to implement, while allowing a clear path towards complex behavior and implementation
A simple cost model: the cost of generating, storing, and processing events is clear, as is the cost for querying derived data. With relational databases and ORMs costs are much less clear and often highly dependent on external factors such as configuration, table statistics, etc.
Simple, clearly delineated application components that interact through well-defined interfaces, for both infrastructure and domain code
Mostly immutable data structures with mutation controlled by using Scala's software transactional memory
Some of these concepts were first explored in a series of blog posts and was presentated at ScalaDays in 2011 at Standford University in California.
by Seb Lambla
A lot can be said about productivity when it comes to building web sites and applications. A lot more will be said about the new developer experience that OpenWrap and OpenRasta provide when combined. Come discover how dependency management, templates, tooling and resource-oriented web development combine to provide an innovative way of building sites and services, on .net, today.
To enable Sever-Side-Push in Web-Applications a lot of hacks (aka Comet/Bayeux) have been done in the past. The WebSocket spec fixes that by introducing a bi-directional and full duplex communication channel over a single TCP connection, which can be easily used to extend high-level protocols (such as JMS, AMQP or XMPP) to the browser. This session gives an overview of the WebSocket API and shows how to use with other HTML5 APIs to build powerful and future-proof Web-Applications.
Target Audience: Developers that are interested in the capabilities of WebSocket or want to know how-to bring existing server systems, like JMS or AMQP, to the Web.
by Stuart Marks
This session will describe several new features introduced in Java 7, including a couple of the "Project Coin" language features. These features will be described and their benefits shown by using them to improve an actual piece of code from the JDK. The features to be shown are try-with-resources, more-precise rethrow (which are two language features introduced by Project Coin), and one of the new NIO utilities. The presentation will begin by showing a single method taken from the JDK 6 code base. It will continue by applying the features one by one using NetBeans, including an explanation of the feature and of its significance. Finally, the "before" and "after" code will be compared. The resulting code will be more concise and more correct than the original, showing that the new Java 7 features offer the opportunity to make great improvements to your Java code.
Keywords: Java, Java SE 7, JDK 7, OpenJDK, NIO, Files, Project Coin, Exception Handling
Target Audience: This session should be of interest to any Java programmers who are interested in using Java 7 features to improve their code.
by Peter Maas
As an early adopter of Scala, I quickly noticed its vast potential and decided I want to use it on my next project. It took over two years of workshops, presentations, code examples and perseverance to actually get developers to accept it as a useful tool in their toolbox.
During this presentation I would like to share my learnings. Not in the form of lengthy philosophical discussions about learning curves, productivity or adoption rates but by running through a collection of the various code fragments I used in my quest to interest people in learning a new language. Do built-in parser combinators help? Do Java developers miss tail recursion? How many DSLs do you implement per year? Everybody is tired of annotation-riddled Java… right? Does "just start by writing tests in Scala" work? Is interoperability with Java frameworks straightforward?
The intention of all this is to help other people in their mission to keep innovating on a team or organizational level… and to share some of his love for the Scala language.
Keywords: Scala, Java, Innovation, Change, Tools
Target Audience: Developers, Architects and IT Managers
by Tom Wilkie
The standard Linux storage stack wasn’t designed for write-heavy big data workloads, nor is it well-suited to modern hardware: large, slow SATA disks, SSDs or many cores, leading to significant performance limitations for NOSQL stores and the applications they support.
In this talk, Tom Wilkie will explain how Acunu's Big Data storage engine, Castle, can provide up to 100x performance improvement to Apache Cassandra, the write-optimised second generation distributed database. Castle, an open-source project, is a ground-up overhauling of RAID, file systems, and the POSIX interface, fundamentally . It is released under the GPL and runs as part of the Linux kernel. Tom will also discuss the algorithms involved and real world use cases. Expect graphs, maths and more...
Keywords: Apache, Big data, NOSQL, Cassandra, cloud, performance
Target Audience: software developers, system architects, system engineers, performance managers
by Leif Sørensen, Klaus Bucka-Lassen and Christian Wolfgang
Changing your version control system can be a challenging operation. In this presentation we will talk about migration strategies, in particular how to bridge between 2 quite different version control systems (Mercurial, distributed VCS and ClearCase, centralized VCS), and we'll demonstrate an Open Source Jenkins-based bridge. Bridging allows for a smooth transition and furthermore has the advantage that different processes and projects can run in the world that is most convenient to them. The delivery process for instance can continue to run in ClearCase, whilst the developers increase their productivity by switching to Mercurial.
Keywords: Distributed Version Control System, Mercurial, Subversion, ClearCase, Jenkins, migration, bridging
Target Audience: Source Control Managers and decision makers, developers, system admins
Mobile devices has claimed first place from the browsers in the fragmentation game. Clearly Android is scoring most of the fragmentation points for the team but iOS isn't just idly standing by.
In this presentation we will show you some of the nasty differences we have found between the platforms . We will introduce the BDD framework Cucumber and show you how we use it to ease the pain of testing a lot of Android devices across different manufacturers, screen sizes and Android versions.
The presentation will also contain an introduction to lesspainful.com, our awesome and cost efficient service for testing your Android (and soon to come - iOS) apps.
Hard-core developers have a tendency to think about innovation in terms of writing cool code in cool languages, technical superiority, and implementation qualities such as performance and scalability. Over his career Steve has seen misguided notions like these confuse, upset, and even limit the careers of some very bright technical minds. In this talk, he'll discuss what innovation really is, how it works, and how truly understanding it will help you improve as a developer.
The Conference Party is co-hosted by Atlassian and Basho and will take place at the Irish Pub 'The Tara'.
13th–15th October 2011