by David Rowan
You guys have won. Software is, as Mark Andreessen recently declared,
eating the world. You are the emperors and are cutting through and
reinventing industries one by one. But... let's think about what comes
next. What should your bigger legacy be? What should your minds and
skillset be focused on now in order to solve the bigger, more meaningful
problems that beset us? And how can the coder approach lead the world into
an era of abundance, of iterative trouble-shooting, of optimal management
of our resources - both physical and intellectual - in order to generate
the greatest happiness for the greatest number?
by Alex MacCaw
Web developers are still stuck in the request/response mindset. I call it the 'click and wait' approach - where every UI interaction results in a delay before another interaction can be performed. That's the process they've used their entire careers so it's no wonder most developers are blinkered to the alternatives.
Speed matters; a lot. Or to be precise, perceived speed matters a lot. Speed is a critical and often neglected part of UI design, but it can make a huge difference to user experience, engagement and revenue. This has been proven time and time again in UI studies.
Yet, despite all this evidence, developers still insist on using the request/response model. Even the introduction of Ajax hasn't improved the scene much, replacing blank loading states with spinners. There's no technical reason why we're still in this state of affairs, it's purely conceptual.
However, there's a solution to the problem, a revolution in the way developers think about user interfaces. Asynchronous UIs, where every action is non-blocking and instant. There are no loading messages or ajax spinners. Requests to the server should be decoupled from the interface.
by Diana Larsen
Going “Agile” can confer a number of benefits to an organization, but all too often those promised benefits aren’t fully delivered. Do you have the visibility you need to understand progress and make timely market-focused decisions? Do your teams ship on a frequency your customers can, and want, to accept? Does innovation flourish in and across teams? How about reduced cycle time? A model of the predictable stages of agile team competency helps managers and leaders define the benefits they’re getting, determine the benefits they really want, and plan next steps. Join Diana Larsen in an exploration of ways leaders can use the model to analyze and monitor progress of Agile competence in teams.
by Iris Classon
It really doesn’t matter how long you’ve been in this industry or which position you hold, understanding generation n00b and the value it brings should be mandatory for you. After asking a stupid question daily on the blog and interviewing hundreds of n00bs, employers, and teachers I’ve collected for you some rather intriguing and invaluable advice. In this unique narrated short film session I plan to shock, share and shine some light on your most valuable asset: gen. n00bs & stupid questions
by Drew Neil
Vim's modal editing model was conceived to meet the constraints of computing in the 1970s. The arrival of the mouse made intuitive point-and-click user interfaces the norm. While this was a boon for the novice computer user, it was a backward step for the power user. For a touch typist, there is no quicker way of editing text than with the keyboard.
This session won't teach you much in the way of practical hands-on advice - for that, see my Vim masterclass. Instead, it will challenge your preconceptions about Vim, and inspire you to give it a second look. We'll draw analogies with the mechanics of video games such as Quake and Street Fighter II. We'll look at patterns in the game of chess, and see how they relate to the task of editing text. And we'll learn what Vim users have in common with Scrabble players.
by Tim Berglund
In this session, we'll talk about Cassandra's data model, look at its query idioms, talk about how it functions in a cluster, and look at use cases in which it is an appropriate data storage solution for large-scale systems.
We will discuss pros and cons of implementing your application as a Web application vs. a native mobile application. The talk presents Open Web Platform / HTML5 features of Chrome on Android, as well as remote debugging capabilities.
Akka is a unified runtime and programming model for scaling both UP (utilizing multi-core processors) and OUT (utilizing the grid/cloud). With Akka 2 this will be taken to a whole new level with its “Distributed by Design”. Akka 2 provides location transparency by abstracting away both these tangents of scalability by turning them into an operations and configuration task. In this talk you will learn what Akka is and how it can be used to solve hard scalability problems.
by Ryan McGeary
We hear a lot about how strong communication and collaboration are key to a successul project. We spend a lot of time focusing on stand-up meetings and pair programming, but there are other very effective means of keeping the team on the same page that not only avoid daily interruptions but also provide long-term benefit. Learn how your team can improve your own collaboration with just a bit of discipline and relatively low overhead.
by Brian Foote
Over the last generation or so, software development has changed profoundly, but some of these changes occurred so slowly they have barely been recognized.
Software was once built by skilled but peculiar artisans, who meticulously crafted their original, green-fields commissions from first principles. Today, their frontiers are gone, and the very few of us build anything new from the ground up. Instead existing resources are rehashed, recombined, and remixed to produce “new” mash-ups based up the work of others. It’s collaborative, this 21st century scavenging, and it has become the state-of-the-art approach to software development.
These changes in the way we produce software have much in common with the changes that have transformed the music industry over the last thirty years. The garage band era of original composition has given way to the direct borrowing of scraps of other people’s pieces and a cavalier disregard for traditional originality.
This session will explore how software developers in the age of sampling have as much in common with contemporary high-tech music “producers” as they do with traditional engineers.
by Glenn Block
If I told you that you can build node.js applications in Windows Azure would you believe me? Come to this session and I’ll show you how. You’ll see how take those existing node apps and easily deploy them to Windows Azure from any platform. You’ll see how you can make yours node apps more robust by leveraging Azure services like storage and service bus, all of which are available in our new “azure” npm module. You’ll also see how to take advantage of cool tools like socket.io for WebSockets, node-inspector for debugging and Cloud9 for an awesome online development experience.
Marcus discussed the concept of being a Subject Matter Expert in the iOS field. Marcus will walk us through what a client expects of you and what you can expect of the client. Marcus will also discuss many situations that he has run into as a SME and how he responded to them.
by Vicent Martí
With over 2 million and a half repositories, GitHub is the world's largest source code host. Since day one, we've faced an unique engineering problem: making terabytes of Git data always available, either directly or through our website. This talk offers a hopefully insightful view into the internals of Git, the way its original design affects our scalable architecture, and the many things we've learnt while solving this fascinating problem.
The Developer Tools built into Google Chrome provide powerful ways to understand, debug, and profile web applications. Most developers are familiar with its basic inspection and debugging tools, but some of its most valuable features, like the timeline and memory analysis tools, are lesser known. This talk will provide an overview of the Chrome dev tools and an in-depth demonstration of some of the lesser-known features.
In this talk, we'll look at several continuous integration techniques you can use to get more value out of your Jenkins installation. The topic will cover the "validated merge" feature to make your builds unbreakable, the "fingerprinting" feature to build audit trail of your artifacts, and the "pipeline" feature to better visualize how your changes are verified by Jenkins, and so on.
This talk will benefit existing Jenkins users the most, although the concepts discussed here should equally apply to other continuous integration servers as well.
by Frank Kim
Learn how your organization can fall prey to malicious attackers. Using real-world case studies you'll see exactly how hackers exploited and embarrassed several well-known companies. See first hand how real attackers abuse common coding mistakes to exploit issues like SQL Injection and Command Injection. Then learn how attackers further their goals using social engineering and basic network security tactics. Analyzing these events provides enormous insight into what works and what doesn't when building, maintaining, and defending your app. Hearing these stories will plant a security seed in your mind that may change everything about the way you develop applications.
PHP won the early battles for the web because it is online crazy glue. Testing applications written in PHP can be challenging without some guidance as there is lots of info on how to use testing tools but very little info on how to build your application in such a way that it can be easily tested.
This talk will cover strategies that can be used to shape your application in such a way that you'll be making production pushes multiple times a day with complete confidence.
This session will cover some concepts necessary for testing: the power of loosely-coupled systems, environmental consistency, dependency injection, automation and pragmatic test choices
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.
A distributed version control system lets projects spread like fire in dry grass- and if the aim is to make the flame spread, it should be able to reach even the device resting in your pocket. Developing a Git client for Android threw up a bunch of interesting challenges; from low-level bug-hunting in the source of Android to unusual UI tricks. This talk describes those challenges, the curious bugs found, and the resulting Grand Tour of open-source projects; patching Android and even Git itself.
I've been teaching programming for a few years now, and I've come to realize that the harder a languages is to teach, the more poorly designed it is. In this talk I'll lay out the things that languages do to make themselves unteachable, and show how that connects back to bad design by the designers. Of particular blame is the object oriented programming paradigm and how it seems to defy simple description in every language.
by Dennis Gustafsson
Sprinkle was released simultaneously on Android and iOS in August 2011 and has been downloaded more than four million times to date. It includes realistic fluid simulation which was a technical challenge to bring to mobile devices. A lot of time was spent on performance optimization both on the CPU side and on the GPU side to get the game running smoothly on low-power devices. Some of the techniques used are presented in this session.
If you've ever used it, you've probably fallen in love with Github Pull Requests.
This is the story about adding automatic Pull Request testing to Travis CI. We will explore the depths of Git, GitHub and Travis CI. Expect to learn something about Git internals, undocumented APIs, distributed systems and real world usage of hypermedia. And why it all matters.
When you open or update a Pull Request on GitHub, Travis CI is now able to automatically test the merged version and leave a comment indicating whether all tests still pass or not. This feature allows you to really make use of the GitHub Merge Button without having to fear breaking your master branch. Adding this feature to Travis was not as trivial as it seemed in the beginng. Let me take you on a journey through what actually happens, from opening that Pull Request to travisbot leaving a comment on your blog.
by jim mccarthy
A culture is the set of shared attitudes, values, goals, and practices that describes a group. Our era is increasingly characterized by an emergent “software culture". Culture hacking is itself a distinct kind of culture engineering. Good culture hacking will tend to protect personal freedom and extend openness. As our many cultures become hacked we will grow enormously in effectiveness, and ambition. This will lead to an era of widespread and abundant greatness, an era of magnificence.
Why rebels must defy and disrupt entrenched institutions—and three essential tactics for their success
by Tim Berglund
by Diana Larsen
Liftoff – it's the unexplored, often ignored, Agile software development project practice. Liftoff gives impetus to your projects in a way that starts the project team, and the business, on the trajectory to success. Project sponsors, product managers, and product owners use these critical meetings to inform, inspire, and align the people who do the work with the definition of the work to be done.
As the first act of the flight, a rocket launch requires an entire set of systems to successfully lift the vehicle into orbit – not just the vehicle itself, but all the systems needed for smoothly moving off the ground into space. Likewise, your project needs its entire set of supporting systems in place to begin a successful journey to high performance, hyper-productivity, and high value delivery.
In this talk, Diana Larsen explores ways to accomplish Liftoff, including the vital step of chartering the project. She’ll share real-life stories of how others have effectively started their projects; a variety of team activities to fuel your Liftoff; and a framework for effective, "just enough" Agile chartering.
by Chris Beams
The Spring family of projects have long been some of the most important tools in the enterprise Java developer's toolkit. Very often though, Spring is characterized as being too dependent on XML-based configuration. This session will take a deep look at how Java applications can be configured entirely in code, eliminating Spring-, JPA- and even Servlet-related XML. We'll also look beyond efforts in the core Spring Framework and explore how higher-level Spring projects like Spring Data and Spring Integration take advantage of code based configuration.
by Greg Young
What if I told you that the new Event Store (OSS geteventstore.com) is an ACID compliant database with only 24 bytes of mutable data? This session will look deep inside the Event Store and architectural decisions and trade offs made in the development of it.
by Matthew Heusser
Software Development tends to be tribal -- the developers vs. the testers, the Agilistas vs. the waterfallists, the context-driven school vs. the certification folks, and so on. Matt Heusser will explain how and why these associations spring up, how to to take the best from a tribe -- and to know when to break from the pack. He will also discuss tribes in the workplace, how groupthink happens, and how technologists can use disobedience to fuel improvement in product, process, and reputation.
5th–9th November 2012