Most of the time when people talk about agile software development, they talk about project and planning practices and never mention actual development practices. This talk delves into best development practices for agile projects, covering all of its aspects.
Most of the time when people talk about agile software development, they talk about project and planning practices but never mention actual development, as if development where an afterthought when writing software. This talk bills into the real details of how to do agile development. I discuss best practices like continuous integration, pair programming, how developers should interact with story cards, how to handle enterprise concerns like integration with other software packages, and a slew of other topics related to agile software development.
A Technology Radar is a tool that forces you to organize and think about near term future technology decisions, both for you and your company. This talk discusses using the radar for personal breadth development, architectural guidance, and governance.
ThoughtWorks Technical Advisory Board creates a “technology radar” twice a year, a working document that helps the company make decisions about interesting technologies and where we spend our time. ThoughtWorks then started conducting radar-building exercises for our clients, which provides a great medium for technologists company-wide to express their opinions about the technologies they use every day. For companies, creating a radar helps you document your technology decisions in a standard format, evaluate technology decisions in an actionable way, and create cross-silo discussions about suitable technology choices. This session describes the radar visualization and how to conduct a radar building session for yourself. After a brief introduction, the bulk of the workshop consists of attendees building a radar for the group, following the same procedure you'll use when you do this exercise at your company. At the end, we'll have created a unique Radar for this event and practiced doing it for yourself.
You've read that the relational model is old and busted, and there are newer, faster, web-scale ways to store your application's data. You've heard that NoSQL databases are the future! Well, what is all this NoSQL stuff about? Is it time to ditch Oracle, MySQL, and SQL Server in favor of the new guard? To be able to make that call, there's a lot you'll have to learn.
In this session, we'll take a whirlwind tour of several representative non-relational data stores, including Cassandra, MongoDB, and Neo4J. We'll learn the very different ways they represent data, and we'll see their unique strengths and weaknesses in various kinds of applications. Along the way, we'll learn why new technologies must be introduced to address today's scaling challenges, and what compromises we'll have to make if we want to abandon the databases of our youth. We'll review what ACID means, think about query idioms, and talk about the CAP theorem. It's an exciting time to be storing and retrieving data, and the opportunity is now before us to learn things we could ignore just a few years ago. Come to this session for a solid introduction to a growing field.
Hadoop is a MapReduce framework that has literally sprung into the vernacular of “big data” developers everywhere. But coding to the raw Hadoop APIs can be a real chore. Data analysts can express what they want in more English-like vocabularies, but it seems the Hadoop APIs require us to be the translator to a less comprehensible functional and data-centric DSL.
The Cascading framework gives developers a convenient higher level abstraction for querying and scheduling complex jobs on a Hadoop cluster. Programmers can think more holistically about the questions being asked of the data and the flow that such data will take without concern for the minutia.
We'll explore how to set up, code to, and leverage the Cascading API on top of a Hadoop sample or production cluster for a more effective way to code MapReduce applications all while being able to think in a more natural (less than fully MapReduce) way.
During this presentation, we'll also explore Cascading's Clojure-based derivative, Cascalog, and how functional programming paradigms and language syntax are emerging as the next important step in big-data thinking and processing.
Want to go deep on a popular NoSQL database? Cassandra is a scalable, highly available, column-oriented data store in use at Netflix, Twitter, Reddit, Rackspace, and other web-scale operations. It offers a compelling combination of a rich data model, a robust deployment track record, and a sound architecture, making it a good choice of NoSQL databases to study first.
In this session, we'll talk about Cassandra's data model, look at its query idioms, talk about how to deploy it, and look at use cases in which it is an appropriate data storage solution. We'll study its origins in the Amazon Dynamo project and Google's BigTable, and learn how its architecture helps us achieve the gold standard of scalability: horizontal scalability on commodity hardware. You'll leave prepared to begin experimenting with Cassandra immediately and planning its adoption in your next project.
Domain Specific Langauges seems like a cool idea, but where's the payoff? This talk provides an overview of how to build both internal and external DSLs (including the state of the art tools), stopping along the way to show how this is practical to your day job.
This talk defines of DSLs (Domain Specific Languages), distinguishes the types of DSLS (internal and external), and shows examples of building DSLs of several kinds. It shows how to utilize DSLs for externalizing configuration (which you're already doing, whether you realize it or not), how to make your code readable to humans, how DSLs make developer tools better (and how to use DSL techniques to build your own tools), and how DSLs can provide your users unprecedented flexibility and power, by building DSLs customized to their job. This talk provides a good foundation for the subject if you've never seen anything about it, but keeps the focus on practical goals.
Some systems are too large to be understood entirely by any one human mind. They are composed of a diverse array of individual components capable of interacting with each other and adapting to a changing environment. As systems, they produce behavior that differs in kind from the behavior of their components. Complexity Theory is an emerging discipline that seeks to describe such phenomena previously encountered in biology, sociology, economics, and other disciplines.
Beyond new ways of looking at ant colonies, fashion trends, and national economies, complexity theory promises powerful insights to software development. The Internet—perhaps the most valuable piece of computing infrastructure of the present day—may fit the description of a complex system. Large corporate organizations in which developers are employed have complex characteristics. In this session, we'll explore what makes a complex system, what advantages complexity has to offer us, and how to harness these in the systems we build.
Programming concurrency has turned into a herculean task. I call the traditional approach as the synchronized and suffer model. Fortunately, there are other approaches to concurrency and you can reach out to those directly from your Java code.
In this presentation we will discuss the actor based concurrency and also the software transaction memory. We will then develop examples using AKKA and compare the power of these approaches in contrast to the traditional approach.
Traditional collections on the Java platform focused on providing thread-safety at the expense of performance or scalability. More modern data structures strive to provide performance without compromising thread-safety. Some of them require you to adopt to a different semantics or programming model. In this presentation we will explore some data structures that can help reach both thread-safety and reasonable performance.
Concurrent collections, immutable collections, operations on and performance of lists, blocking queues, and tries.
Quite a few languages have raised to prominence on the JVM. A frequently asked question is “How do I integrate my Java code with these?” This session answers that very specific question.
Learn how to integrate code written in Java, Clojure, Scala, and Groovy. We will discuss both language level integration and architectural boundaries.
You're serious about improving the quality of your code base, but with 10,000 lines of code, where do you start and how do you ensure the greatest ROI for the re-work your team members will perform?
Sonar is an open source tool that brings together the best of breed static and dynamic analysis of Java projects. The result is a unified view of problematic areas of your code on a time-line basis, allowing the team to attack the problems with the best ROI, and maintain a more watchful eye for positive and risky trends in the codebase in the future.
This talk will show you Sonar from the ground up and explain 10 critical metrics that affect your code's flexibility, stability, and durability.
Scala, the hybrid functional, fully object-oriented language has evolved over the years. In this presentation we will talk about what has changed in this language in the recent release and look at some cool things you can do with this very powerful language.
Key enhancements and changes in Scala.
Does your application transmit customer information? Are there fields of sensitive customer data stored in your DB? Can your application be used on insecure networks? If so, you need a working knowledge of encryption and how to leverage Open Source APIs and libraries to make securing your data as easy as possible. Cryptography is quickly becoming a developer's new frontier of responsibility in many data-centric applications.
In today's data-sensitive and news-sensationalizing world, don't become the next headline by an inadvertent release of private customer or company data. Secure your persisted, transmitted and in-memory data and learn the terminology you'll need to navigate the ecosystem of symmetric and public/private key cryptography.
Cryptography at first seems like a daunting topic. But after a basic intro and the leverage of the Java Cryptography Extension (JCE), it seems downright feasible to add encryption and decryption capabilities to your application.
Developers weren't satisfied with just the JCE and its plug-in concepts though. Over the last few years, framework architects have made strides in either wrapping or re-writing the approachable JCE in more convenient APIs and fluent interfaces that make effective and accurate crypto down right simple.
Explore three of these libraries – Jasypt, BouncyCastle and KeyCzar – and how they can be leveraged to make your next Java cryptography and data security effort a simple exercise and not a tribulation.
Jasypt, BouncyCastle and KeyCzar are three open source frameworks that bring unique new crypto algorithms such as elliptic curve cryptography to the enterprise developer, remove repetitive ceremonious setup and tear down coding, and add high level adapters to the Spring and Hibernate frameworks.
Many development shops have made the leap from RCS, Perforce, ClearCase, PVCS, CVS, BitKeeper or SourceSafe to the modern Subversion (SVN) version control system. But why not take the next massive stride in productivity and get on board with Git, a distributed version control system (DVCS). Jump ahead of the masses staying on Subversion, and increase your team's productivity, debugging effectiveness, flexibility in cutting releases, and repository redundancy at $0 cost. Understand how distributed version control systems are game-changers and pick up the lingo that will become standard in the next few years.
In this talk, we discuss the team changes that liberate you from the central server, but still conform to the corporate expectation that there's a central master repository. You'll get a cheat sheet for Git, and a trail-map from someone who's actually experienced the Subversion to Git transition.
Lastly, we'll even expose how you can leverage 75% of Git's features against a Subversion repository without ever telling your bosses you are using it. Be forewarned that they may start to wonder why you are so much more effective in your checkins than other members of your team.
Git is a version control system you may have been hearing a bit about lately. But simply hearing more about it may not be enough to convince you of its value. Getting hands on experience is what really counts. In this workshop, you'll bring your Windows, Mac or Linux laptop and walk through downloading, installing, and using Git in a collaborative fashion.
The workshop style of this class will allow you to observe and discover the value of this new version control tool first hand. You'll be cloning, creating, commiting, and pushing repositories by the conclusion of this session.
git
is on your PATH
(in the environment variable list of paths)With the rise of multi-core processors, and their growing ubiquity (on client machines, to say nothing of the server machines on which Java applications most frequently execute), the need to “program concurrently” has risen from “nice-to-have” to “mandatory” requirement, and unfortunately the traditional threading-and-locking model is just too complicated for most Java developers–even the brightest of the lot–to keep track of with any degree of reliability. As a result, numerous new solutions are emerging, each of them with their own strengths and weaknesses, leaving the Java developer in a bit of a quandary as to which to examine.
In this presentation, we'll look at Akka, a framework/platform specifically aimed at building high-throughput, concurrency-friendly applications in either Java or Scala (or both), with a slew of additional add-on modules to handle issues like persistence, communication (pub-sub, REST, and more), and more. By the time we're done, you'll be able to start looking into using Akka on your own projects, and have a good feel for what your projects would look like when Akka-ized.
The first in a series of talks that are part of an arc covering next-generation information-oriented, flexible, scalable architectures. The ideas presented apply to both external and internal-facing systems.
The REpresentational State Transfer (REST) architectural style has emerged as a winning strategy for building scalable, flexible, resilient systems that lead with an information focus. Far from being the simple “Web Services through URLs” idea many people have about them, REST-based systems require a new perspective, a fair amount of consideration and the discipline to look beyond simple point-to-point interactions.
The benefits are exciting and provide a gateway to a whole new world of information technology. This first talk will be an introductory session covering the basics of the REST architectural style.
The second in a series of talks that are part of an arc covering next-generation information-oriented, flexible, scalable architectures. The ideas presented apply to both external and internal-facing systems.
People already familiar with REST (or who have attended the first session) will be walked through the deeper topics of building Level 3 Hypermedia-based RESTful systems, security, content negotiation, etc.
The fourth of a series of talks that are part of an arc covering next-generation information-oriented, flexible, scalable architectures. The ideas presented apply to both external and internal-facing systems.
The Web of Documents we are so familiar with is being extended with the technologies of the Semantic Web. Information will be freed from its containers and connected regardless of where it comes from. Building on the concepts of REST services and the Web Architecture, we will introduce the Resource Description Framework (RDF) as the basis of a new collection of tools for information sharing and integration. Once the information is woven together, we will want to query it and produce new information resources with technologies like the SPARQL query language.
People already familiar with REST and the Web (or who have attended the REST sessions) will be given both conceptual and technical examples of how and why these technologies are laying the foundation of future information systems.
The fifth in a series of talks that are part of an arc covering next-generation information-oriented, flexible, scalable architectures. The ideas presented apply to both external and internal-facing systems.
Once we have a flexible and extensible data model like RDF, we will want to find ways to weave it into our documents to make them easier to organize, find and extract value from on the Web. This talk will highlight techniques for adopting RDFa but will also motivate attendees to dig deeper by showing them how it is already being used by the biggest names on the Web. Improve your search results and allow your customers to leverage relevant information for their own purposes.
You understand how important it is to be on the Web. Come learn how important it is to be on the Web of Data.
Emergent design is a big topic in the agile architecture and design community. This session covers the theory behind emergent design and shows examples of how you can implement this important concept.
This session describes the current thinking about emergent design, discovering design in code. The hazard of Big Design Up Front in software is that you don't yet know what you don't know, and design decisions made too early are just speculations without facts. Emergent design techniques allow you to wait until the last responsible moment to make design decisions. This talk covers four areas: emergent design enablers, battling things that make emergent design hard, finding idiomatic patterns, and how to leverage the patterns you find. It includes both proactive (test-driven development) and reactive (refactoring, metrics, visualizations, tests) approaches to discovering design, and discusses the use of custom attributes, DSLs, and other techniques for utilizing them. The goal of this talk is to provide nomenclature, strategies, and techniques for allowing design to emerge from projects as they proceed, keeping you code in sync with the problem domain. This talk shows lots of examples of how to make this concept work in your environment.
Most teams manage database change using an ad-hoc system of SQL migration scripts manually applied to various development, staging, and production servers. Some even contrive automated processes, but rarely does this surplus build engineering deliver value directly to the customer. We should be writing applications, not build tools.
In this session, we'll take a look at a ready-to-use, open-source database refactoring tool called Liquibase. Liquibase enables developers to make database changes with confidence, share those changes in a predictable way with other team members, and apply them to automated QA builds, staging servers, and production environments. It provides a credible path to agile database development, and it integrates well into popular build tools. It's a key enabler of the culture of database responsibility that most teams are missing.
Take one ugly legacy schema, a toolbox full of simple database refactorings, and a world-class schema refactoring tool, and you've got 90 minutes of workshop that will equip you to bring a culture of database responsibility to your team.
In this workshop, we'll start with a live schema in need of some help, and slowly improve it in a controlled fashion using Liquibase. We'll see how to create and alter tables, add constraints, drop columns, control changes in stored procedures, and more. You should come away with a solid understanding of how to use the tool and how to integrate it into your team's development, build, and deployment processes.
Attendees should already have a conversational understanding of Liquibase, or have attended Scripting the Schema with Liquibase session. Please bring a laptop or be prepared to pair with a friend.
Automated functional testing is very critical to ensure the code we write is relevant and continues to provide direct business value as it evolves. Business analyst and customers can help develop these tests and programmers can help maintain these. Easyb is a great tool for creating such automated tests.
In this sessions we will explore the key features and strengths of Easyb and how you can use it to create automated tests of your user stories.
In just 90 minutes, we'll install Gradle and develop a range of build scripts. Whether you're just looking to improve your builds or to create sophisticated project automation scripts, get some hands-on experience with the framework that won a Springy at SpringOne2GX for “Most Innovative Product/Project”.
Gradle is a Groovy based convention over configuration build/project automation framework that allows you to develop elegant, powerful build scripts quickly and efficiently. This will be a chance to get some hands-on experience so you can compare Gradle to your current build tool.
Some developers assume that agility and usability are mutually exclusive - in reality, they are extremely complimentary; if you squint, you might have a hard time telling the difference between agile practices and good user interface design. This usability talk is aimed squarely at developers giving you the tools you need to develop UIs that won't make your users yack. We'll discuss the importance of observation, personas, paper prototyping, usability testing and the importance of good moderators. In addition, we'll map the various aspects of user interface design to a typical agile iteration.
Some developers assume that agility and usability are mutually exclusive - in reality, they are extremely complimentary; if you squint, you might have a hard time telling the difference between agile practices and good user interface design. This usability talk is aimed squarely at developers giving you the tools you need to develop UIs that won't make your users yack. We'll discuss the importance of observation, personas, paper prototyping, usability testing and the importance of good moderators. In addition, we'll map the various aspects of user interface design to a typical agile iteration.
Day in and day out we are subjected to poorly designed applications. From those we experience directly to the time we waste waiting on others who are struggling with systems that seem like they were built to hinder the user. It doesn't have to be like this and many users are waking up and demanding better applications. Are you prepared to deliver? After this workshop, you will be. When you're done, you'll have the tools you need to make sure your application helps your users kick ass!
Usa-what now?
While most developers are schooled in algorithms and programming languages, they often lack a grounding in the fundamentals of usability; we'll start by exploring what usability is dispelling many of the myths surrounding this misunderstood aspect of software. We'll show why usability matters and help you see how it can make the difference on your projects.
The who - developing pragmatic personas.
We can't build a great UI without knowing who we're building it for. Personas are a time tested technique to help teams understand their users and facilitate building the right interface. While personas are often backed by extensive ethnographic research, they don't require months and months of effort. We'll explore the use of pragmatic personas to see how they can simplify the task of interface design. As an exercise, we'll develop personas for our application.
The what - figuring out just what to build.
Of course just knowing who we're building for is only part of the picture, we have to know what our users are trying to do. Wether you favor use cases, user stories or more traditional requirements documents, at the end of the day our customers are using our application to further some other goal. In this section we'll discuss tasks and scenarios showing how they contribute to the overall design process. We'll write up a set of user goals expanding them into tasks that will help us design a set of interfaces.
The how - designing rocking good interfaces.
Want to know the secret to designing great interfaces? We'll talk about the importance of iteration; just as our code is rarely right on the first try, neither are our interfaces. To facilitate the iterative process, we'll discuss the vital importance of paper prototyping. That's right, paper and pencil are your best tools. We'll also talk about why some designs are better than others discussing the heuristics that are second nature to the experienced designer. We'll also discuss design guidelines talking about how to make sure yours aren't just a dusty document sitting in a rarely visited corner of the LAN. We'll sketch up a variety of approaches focussing on quick and dirty designs that allow us to explore a plethora of options.
Testing our design - making sure we're on the right path.
Just as we test our code, we must test our interfaces. While we may not have UIunit at our disposal, testing our UIs is just as important as testing our code. From recruiting users to preparing the space, we'll discuss how to get ready for a test. We'll talk about the various roles in a user test from the all important moderator to playing computer and taking notes. User tests can be very stressful, we'll discuss ways to put our customers at ease. We'll also discuss the best way to communicate the results of testing to the rest of your team. We'll prepare a deck to test a given scenario. We'll take that deck and test it with our “customers.” Of course we can also desk check our interfaces using standard heuristics - we'll look at some existing applications discussing what was done right and what could be done better.
Sure, Ajax might not be the hardest thing you'll have to do on your current project, but that doesn't mean we can't use a little help here and there. While there are a plethora of excellent choices in the Ajax library space, jQuery is fast becoming one of the most popular. In this talk, we'll see why. In addition to it's outstanding support for CSS selectors, dirt simple DOM manipulation, event handling and animations, jQuery also supports a rich ecosystem of plugins that provide an abundance of top notch widgets. Using various examples, this talk will help you understand what jQuery can do so you can see if it's right for your next project.
Once we've established a solid understanding of just what jQuery can do out of the box, we'll delve deeper into the plugin space. jQuery is designed to be extended and while odds are there's a plugin that meets your needs, sometimes only a homegrown solution fits. Starting with a couple of very simple examples, we'll work our way up to more full fledged widgets.
The word just came down from the VP - you need a mobile app and you need it yesterday. It needs to be polished and have that design stuff too. Oh and it needs to be on all the major platforms in time for the big marketing push next month. After a moment of panic, you wonder if it's too late to become a plumber but don't worry, there's hope! More and more developers are falling in love with the “write less do more” library and for good reason; it simplifies the job of today's front end engineer. But did you know jQuery could also help you with your mobile needs as well? That's right, jQuery Mobile is a touch optimized framework designed to provide a common look and feel across a wide variety of today's mot popular platforms. In this session, we'll take a look at all that jQuery Mobile has to offer and we'll convert a native application to an HTML5, jQuery Mobile masterpiece.
In this session, we'll take a look at:
You love Groovy and you're a believer in cloud computing. For a larger project you might choose Grails and hosting on Amazon EC2, but what if you want to take advantage of the nearly massless deployments of a cloud provider like the Google App Engine? You could make Grails work, but it's not always the best fit. Enter Gaelyk.
Gaelyk is a lightweight Groovy web application framework built specifically for the Google App Engine. In this session, we'll talk through the simple abstractions it offers, then show how easy it is to code and deploy a useful application to the cloud.
Geb is a Groovy based framework for automated acceptance testing of web applications - think “Selenium on steroids”. Learn about how Geb uses the Page model to make acceptance tests less brittle and strategies for getting the maximum value out of your acceptance tests.
We'll look at how easy it is to install and get started with Geb and will then work on developing well structured Geb tests that allow for good acceptance test coverage without being too brittle.
What's the point attending a conference unless you do something with the knowledge you gain? In this session we look at practical strategies for selecting new technologies and proven approaches for driving adoption back at the office.
From the technology adoption lifecycle and the importance of community to “the knowing doing gap” and technology adoption patterns, we'll look at a range of practical case studies that illustrate proven techniques for selecting and adopting new technologies for your team.
Testing is a great way to introduce Groovy into an organization. It allows you to try out the language without having to change your production environment. Spock is the premier Groovy based testing framework for developing elegant, powerful tests - quickly and efficiently.
Learn how to get started with Spock and some of the different types of testing that it supports - from Behavior Driven Development style specifications to efficient data driven tests.
With the rise of the NoSQL movement, a whole new crop of different ways to store data suddenly became available to the Java developer. Unfortunately,what didn't come with them was an owner's manual. CouchDB, for example, was the first of the NoSQL databases to be named as such, and offers features not found in the traditional RDBMS: A distributed, robust, incremental replication document-oriented database server with bi-directional conflict detection and management, accessible via a RESTful JSON API, stored ad-hoc and schema-free with a flat address space, that is both query-able and index-able, featuring a table oriented reporting engine that uses JavaScript as a query language. (With a list of buzzwords like that, what's not to love?)
In this session, we'll look at CouchDB, how to set it up, store data to it, retrieve data from it, and in general figure out where it fits within your next project.
Keynote on lessons we can learn from our civilizations and evolution.
keynote
The Java Virtual Machine is home to several different languages beyond Java, many of which mix ideas (paradigms) together to create a flexible language. Languages which support these different paradigms can be awkward and hard to understand how to use at first.
But if we tear apart the paradigms, examine each one and its advantages and disadvantages, then we can go back to bringing them all back together to create some truly elegant and powerful software designs. It all begins with understanding what software design paradigms are.
With the forthcoming release of Java7, a number of things come to fruition, both in the Java language and in the libraries, and it's important for Java developers to know what those features are, and how they change the game of writing Java code–or not.
In this presentation, we'll go over those changes, JSR by JSR, and discuss where and how they may affect your next project.
Building an application is not the straightforward exercise it used to be. Decisions regarding which architectural approaches to take (n-tier, client/server), which user interface approaches to take (Smart/rich client, thin client, Ajax), even how to communicate between processes (Web services, distributed objects, REST)… it's enough to drive the most dedicated designer nuts. This talk discusses the goals of an application architecture and why developers should concern themselves with architecture in the first place. Then, it dives into the meat of the various architectural considerations available; the pros and cons of JavaWebStart, ClickOnce, SWT, Swing, JavaFX, GWT, Ajax, RMI, JAX-WS, , JMS, MSMQ, transactional processing, and more.
After that, the basic architectural discussion from the first part is, with the aid of the audience in a more interactive workshop style, applied to a real-world problem, discussing the performance and scalability ramifications of the various communication options, user interface options, and more.
Fred Brooks said, “How do we get great designers? Great designers design, of course.” So how do we get great architects? Great architects architect. But architecting a software system is a rare opportunity for the non-architect.
The kata is an ancient tradition, born of the martial arts, designed to give the student the opportunity to practice more than basics in a semi-realistic way. The coding kata, created by Dave Thomas, is an opportunity for the developer to try a language or tool to solve a problem slightly more complex than “Hello world”. The architectural kata, like the coding kata, is an opportunity for the student-architect to practice architecting a software system.
In this session, attendees will be split into small groups and given a “real world” business problem (the kata). Attendees will be expected to formulate an architectural vision for the project, asking questions (of the instructor) as necessary to better understand the requirements, then defend questions (posed by both the instructor and their fellow attendees) about their choice in technology and approach, and then evaluate others' efforts in a similar fashion. No equipment is necessary to participate–the great architect has no need of tools, just their mind and the customers' participation and feedback.
Agile has matured to the point of mainstream success. Even large companies have discovered that it helps them build better quality software faster. But the agile practices that are mainstream today have been around for a long time. What is the next wave of innovation in the Agile world going to bring?
Agile software development works because of feedback loops, and to
make it better (or repair what's broken), you identify missing
feedback loops, or replace broken ones. This talk uncovers two
feedback loops missing from most projects. The first uses Behavior
Driven Development & Cucumber to incorporate business
analysts, testers, subject matter experts, and developers one one
platform for requirements definition and verification. The other
anemic feedback loop in many organizations involves the last mile to
production: you have error prone, horrific manual releases that
everyone hates. Continuous Delivery delivers proven techniques
and tools to make “Done” better.
Alistair Cockburn has described software development as a game in which we choose among three moves: invent, decide, and communicate. Most of our time at No Fluff is spent learning how to be better at inventing. Beyond that, we understand the importance of good communication, and take steps to improve in that capacity. Rarely, however, do we acknowledge the role of decision making in the life of software teams, what can cause it to go wrong, and how to improve it.
In this talk, we will explore decision making pathologies and their remedies in individual, team, and organizational dimensions. We'll consider how our own cognitive limitations can lead us to to make bad decisions as individuals, and what we might do to compensate for those personal weaknesses. We'll learn how a team can fall into decisionmaking dysfunction, and what techniques a leader might employ to healthy functioning to an afflicted group. We'll also look at how organizational structure and culture can discourage quality decision making, and what leaders to swim against the tide.
Software teams spend a great deal of time making decisions that place enormous amounts of capital on the line. Team members and leaders owe it to themselves to learn how to make them well.
“The Google Guava project contains a host of new features/classes for use by the Java programmer. Intended as a drop-in supplement for the standard JDK APIs, Guava provides features like immutable and forwarding collections, some concurrency utilities, more support for primitives, and so on.
In this session, we'll go over the Guava library, looking at what it provides, when you might seek to use it, and what the overheads and consequences of using it would be.”
“What will it cost?” “When will it be done?“. Unfortunately, almost a decade after the agile manifesto was written, these are still questions we have to answer on a regular basis.
In this session we'll cover a range of practical techniques for improving your requirements gathering and increasing the accuracy of your project estimates while also setting realistic expectations for your project stakeholders based on practical experience in specifying, quoting and delivering over four hundred applications over the last ten years.
This session covers a wide range of patterns that have been proven to help with doing a better job of capturing requirements, more accurately estimating the likely scope of work and managing stakeholder expectations in advance.
Android is a new mobile development platform, based on the Java language and tool set, designed to allow developers to get up to speed writing mobile code on any of a number of handsets quickly. In this presentation, we'll go over the basic setup of the Android toolchain, how to deploy to a device, and basic constructs in the Android world.
Attendees should be intermediate to advanced Java developers, as no time will be spent on Java basics, just the Android parts. Attendees are encouraged to bring laptops to the session (and your Android-based device, if you have one) to fill out code as we go, but the limited time frame means a focus on fast delivery of content and example code; have your fingers warmed up (and the SDK downloaded!) before you get here. (Latest Android SDK will also be on a USB key for attendees' use, in case attendees haven't had a chance to download & install.)
Games? What do games have to do with good business-oriented applications? Turns out, a lot of interesting little tidbits of user-interface, distribution, and emergence, found normally in the games we play, have direct implications on the way enterprise applications can (or should) be built.
Come to this session, find out some intriguing things about what’s going on in the game industry, but more importantly, how ideas from the gaming world can turn around and answer some thorny problems in the business world.
“From Wikipedia: “A physics engine is computer software that provides an approximate simulation of certain simple physical systems, such as rigid body dynamics (including collision detection), soft body dynamics, and fluid dynamics, of use in the domains of computer graphics, video games and film.
Their main uses are in video games (typically as middleware), in which case the simulations are in real-time. The term is sometimes used more generally to describe any software system for simulating physical phenomena, such as high-performance scientific simulation.”
In this presentation, we'll look at some of the physics engines available, and how to use them from within Java for a variety of purposes (most of which will be game-oriented, but can easily be extrapolated into other, more business-focused, scenarios).
Kanban. What is it? It is most certainly not just moving sticky notes around on a board. Far from that, it is a method for gradual, evolutionary improvement of existing software processes. That's right, existing software processes. There is no “Kanban Development Process.” Think you're “doing Kanban?” Think again.
In this session we'll examine the byproducts of the “Kanban method” and its use of a WIP-limiting, pull-based mechanism for managing a software team's work. Next, we'll examine “A day in that Kanban life” in order to get our minds around how a Kanban system works. We'll then step back in time and examine the roots of Kanban in the lean manufacturing methods used at Toyota. We'll also walk through a little queuing theory to understand why Kanban systems work. Finally, we'll walk through Kanban thought-leader David Anderson's “Principles of the Kanban Method.”
You'll leave this session equipped to start a Kanban change initiative in your team, along with the tools to make it successful.
One of the first principles of lean software development is the elimination of waste. Shigeo Shingo identified seven types of manufacturing waste in his “A Study of the Toyota Production System.” Later, the Poppendieck's translated these to seven wastes of software development.
The seven wastes:
In this session, we'll examine each of these wastes and look at some of their common manifestations, both in our coding practices and in our development methodologies. We'll also examine strategies for eliminating each of these wastes from our development efforts.
You've got your build automated using Ant/Maven/Gradle and you're building and running your unit test suite every time you check-in. That's easy. In fact, with Jenkins you can do this in under 5 minutes.
However, if we want to move beyond “mere” Continuous Integration to Continuous Delivery, there are many other areas in which we need to achieve “push button” automation. This talk will survey many of these areas and tie everything together with an integrated case study at the end.
In this talk, we'll look at:
Today's web application developers and testers have a host of options at their disposal for building automated user acceptance tests. This session will be a “shootout” of sorts between several of the popular available frameworks:
We'll briefly examine the feature set of each of these tools and look and their pros, cons, and appropriate usage patterns. We'll then take a few web application screens and utilize each of the tools to implement a test scenario. I'll allow you, the session attendees, to declare the winner, and then follow up with my recommendations.
Some apps are little more than CRUD. The interesting projects are those with essential complexity in the domain. In this presentation we'll show how ideas from Domain Driven Design, Domain Specific Modeling and Domain Specific Languages can be used to more effectively design, refine and maintain the code at the heart of complex applications.
As the complexity of your applications grow, how can you find, protect, refine and maintain the core of your application so that you can keep the code supple despite an ongoing onslaught of custom business requirements? From DDD to DSLs this session looks at practical strategies for keeping complex applications under control.
Domain Specific Languages can provide an order of magnitude productivity benefit when used properly. Learn how to refactor from a traditional API through internal DSLs to external DSLs and how to handle real world requirements like IDE support, testing and DSL evolution. In this session we'll show how you can refactor a language from an API all the way to an external DSL in less than a day.
You've heard about DSLs. Learn how to cut through the buzz and practically apply them to create more maintainable applications.
This session will survey a wide range of tools across the Java space. We'll look at utilities such as VisualVM, jstatd, jps, jhat, jmap, Eclipse Memory Analyzer, jtracert, btrace and more.
Open Source is not just a suite of libraries you consume within your application, but now reaches into the space of tools to help you troubleshoot and improve your applications. The price of these tools eliminates barriers to their use and their open source nature allows you to mix and match them into compositions that work well for your application's unique debugging needs.
These tools will help you peel away layers of your application to expose bugs and performance ceilings. We'll interactively analyze the heap and garbage collection cycles of both local and remote applications, take snapshots of heap, query the heap for heavy usage, leaks and augment running code without a reboot and without breaking a sweat. After attending, you'll never look at Java debugging the same way again.
People are confused about the status of HTML 5. Is it ready? Is it not? What is part of the spec and what isn't? We'll talk about the situation in the “HTML 5 and the Kitchen Sink” discussion, but as always, the proof is in the pudding. We will introduce the most exciting new features of HTML 5 and its related technologies and build examples that use them.
We will work with real code covering:
The new input elements
Editable content
Canvas Element and its related 2D APIs for drawing and animation
Audio and Video elements and how to use fallbacks for codec coverage
Browser native drag and drop
Local storage
Web Workers
Websockets
The Geolocation API
Web DB (SQL in the browser!)
This workshop will assume no special knowledge of HTML 5 and should be accessible to any web developers.
Bring your laptops. This is a hands-on workshop.
People are confused about the status of HTML 5. Is it ready? Is it not? What is part of the spec and what isn't? We'll talk about the situation in the “HTML 5 and the Kitchen Sink” discussion, but as always, the proof is in the pudding. We will introduce the most exciting new features of HTML 5 and its related technologies and build examples that use them.
We will work with real code covering:
The new input elements
Editable content
Canvas Element and its related 2D APIs for drawing and animation
Audio and Video elements and how to use fallbacks for codec coverage
Browser native drag and drop
Local storage
Web Workers
Websockets
The Geolocation API
Web DB (SQL in the browser!)
This workshop will assume no special knowledge of HTML 5 and should be accessible to any web developers.
Bring your laptops. This is a hands-on workshop.