A little old lady once challenged a well-known scientist’s explanation on the structure of the universe, countering that the world is really a flat plate supported on the back of a giant tortoise. The scientist rebutted the little old lady’s challenge with one of his own by asking what the tortoise was standing on. The little old lady’s sly reply was that it’s, “turtles all the way down.” So too is software architecture “turtles all the way down”.

In this session, we cover a broad range of topics that include challenging traditional practices of software architecture, examining what it takes to bring down the ivory tower, probing the paradoxical aspects of architecture’s goal, and investigating the inextricable link between temporal decisions and structural flexibility. From the highest level applications and services to the code that exists in the bowels of the system, and everything in between, we explore how an effective software architecture must be turtles all the way down. In the end, we will all have gained deep insight to the value of agile architecture.

The modularity patterns provide us with proven design techniques to develop a modular software architecture that is extensible, reusable, maintainable, and adaptable. In this session, we’ll explore 9 of the 18 modularity patterns.

This session introduces and examines the following patterns:

• Manage Relationships
• Module Reuse
• Cohesive Modules
• Acyclic Relationships
• Levelize Modules
• Physical Layers
• Container Independence
• Independent Deployment
• Levelize Build

The modularity patterns provide us with proven design techniques to develop a modular software architecture that is extensible, reusable, maintainable, and adaptable. In this session, we’ll explore the remaining 9 modularity patterns.

This session introduces and examines the following patterns:

• Published Interface
• External Configuration
• Default Implementation
• Module Facade
• Abstract Modules
• Implementation Factory
• Separate Abstractions
• Colocate Exceptions
• Test Module

OSGi was once heralded as a contender for most important technology of the decade. Today, most developers have heard of OSGi, but few are using it to develop their enterprise software applications.Is OSGi failing? Who is using it? And what exactly are its benefits?

In this session, we'll explain the benefits of OSGi, and show that it's not just for the middleware vendor. We'll learn how you can use OSGi without making significant changes to how you write your software applications. We'll explore the OSGi ecosystem, including platforms that support OSGi. Through code examination, we'll see how the Spring framework allows us to leverage OSGi in a non-invasive way. We'll discover how OSGi encourages Polyglot programming on the Java platform. And we'll take a brief glimpse into the future of modularity on the Java platform. You'll walk away with a much better understanding of OSGi, its strengths and benefits, how to use it effectively, as well as the myths surrounding its use.

Modularity is coming to the Java platform! Java 8 will introduce the Jigsaw module system. OSGi is here today. Don’t wait to start designing modular software. Contrary to popular belief, you don't need a framework or a new runtime to start building modular software applications. You can start today. Learn how!

In this session, we'll examine what it means to develop modular software on the Java platform. We'll examine the goals and benefits of modular software, and explore the patterns of modular architecture that help us develop modular software systems. With just a few easy steps, we'll see how to transform our software from a huge monolith to an extensible system of collaborating software modules. By examining an existing software system, we'll see first hand how we can increase software modularity with minimal disruption. You'll walk away not just with a much deeper understanding of the benefits of modular software, but also a migration roadmap for refactoring existing applications to increase their modularity. In other words, you'll see how to get ready today for the application platform of tomorrow.

After almost a decade and several significant releases, Spring has gone a long way from challenging the then-current Java standards to becoming the de facto enterprise standard itself. Although the Spring programming model continues to evolve, it still maintains backward compatibility with many of its earlier features and paradigms. Consequently, there's often more than one way to do anything in Spring. How do you know which way is the right way?

In this session, we'll explore several ways that Spring has changed over the years and look at the best approaches when working with the latest versions of Spring.

In this presentation, we'll see how to use Spring to create, secure, streamline, hyperlink, and consume REST APIs.

In modern applications, there are a diverse array of clients consuming content from the web. Each of these clients has unique capabilities and limitations, therefore demanding presentation of the application to be tailored to each device. As a result, presentation logic is often pushed into the client itself, leaving the application to serve a common data-oriented lightweight API to be consumed by each client.

In this session, I'll show you how to secure your Spring application with Spring Security 3.2. You'll see how to declare both request-oriented and method-oriented security constraints. And you'll see how SpEL can make simple work of expressing complex security rules.

Although we may invite guests into our homes and give someone a ride in our car, we locks and alarms on our homes and our cars to keep uninvited and malicious visitors out. Similarly, we allow people to use the applications that we develop, but we probably want to control the access that they have.

Security is an important aspect of any application. And while we could program security rules into the web controllers and methods in our application, we'd find ourselves cluttering our business logic with repetitive security code. Security is a cross-cutting concern–begging to be handled with aspect-oriented techniques.

Spring Security is an authentication and access-control framework based on Spring that provides security aspects. With Spring Security, you can declare who is allowed to access your application and what they're allowed to see, keeping your application logic focused and uncluttered with security details.

For a long while, we've built applications pretty much the same way. Regardless of the frameworks (or even languages and platforms) employed, we've packaged up our web application, deployed it to a server somewhere, and asked our users to point their web browser at it.

But now we're seeing a shift in not only how applications are deployed, but also in how they're consumed. The cost and hassle of setting up dedicated servers is driving more applications into the cloud. Meanwhile, our users are on-the-go more than ever, consuming applications from their mobile devices more often than a traditional desktop browser. And even the desktop user is expecting a more interactive experience than is offered by simple page-based HTML sites.

With this shift comes new programming models and frameworks. It also involves a shift in how we think about our application design. Standing up a simple HTML-based application is no longer good enough.

In this session, we'll discuss what the next generation of applications looks like, exploring such things as the mobile web and cloud computing. We'll also dig into some of the technologies and practices such as REST, OAuth, and JavaScript microframeworks that enable us to move forward.

In this session, we'll survey a handful of popular JavaScript libraries, frameworks, and tools that make developing rich applications in the browser a snap. Among those considered will be Spine, Backbone, Sammy, and Knockout, seeing how each stacks up to each other and (in some cases) how they can even be used together.

The pendulum has swung. For years we have developed round-trip web applications where the bulk of processing and content generation are performed server-side and simply displayed in a web browser. However, modern applications target a variety of clients and it's becoming increasingly important for the browser to handle more than content rendering and simple form validation. These applications leverage the capabilities of modern browsers to provider a richer and more responsive experience.

Using continuous integration, we will explore how to take an existing build, test, deploy process and shorten the time from code to deploy from days to minutes .

Bootstrap your current build into a build always process providing rapid feedback. We will show the basic of a continuous build process and how quickly you can add in continuous inspections, tests and deployment to increase collaboration, quality and productivity. We will explore how to take an existing build, test, deploy process and shorten the time from code to deploy from days to minutes .

Although Agile has proven to provide incredible benefits in software development and delivery, it is not foolproof, nor a “Silver Bullet.” Plenty of factors need to be considered before attempting this highly disciplined approach.

Learn from the mistakes other organizations have made and discover which pitfalls to avoid to ensure that your first attempt at applying an Agile approach will be met with a successful outcome. This hour-long web seminar will explore these areas and provide clear steps your team and organization should consider to provide a clear set of tools to maximize the opportunity for best results possible.

The Executable Specification is a result of implementing a set of practices that allow frequent change in software products to ensure that the right product is delivered economically. We'll explore how mature Agile Team's go from User Stories to Executable Specifications by implementing practices that foster collaboration, shared understanding and liberal automation to achieve living documentation that supports the team.

We'll collaboratively walk through a evolving example of how software can be created by utilizing an executable specification to document the the software requirements and confirm it completeness.

Where do defects come from? Technical debt is often one of our biggest challenges as poor design and defects are built up over time by cutting a corners here and there. We will discuss some key technical metrics that can shine light on these defects before they get out of control and find those that are out of control and worth your attention now.

We'll explore how the psychological effect of simply measuring technical metrics and making them visible can have immense impacts on reducing the occurences going forward.

Mobile devices are now outselling PCs and Android mobile devices are leading the way. Learn how to develop for this popular and important platform. This session will provide the information you need to configure the Android development platform and begin writing native applications.

No Android experience necessary. If you already know Java and Eclipse that would be helpful but, if not, you'll still get a good understanding of the development process for Android (and you can learn Java later if you want to continue building Android apps).

This presentation will cover the following topics:

• Android IDE and SDK
• Creating an App
• Testing and Deploying an App

Creating the right development environment for building Android apps should be the primary concern of a team embarking on native app development. Constructing a comprehensive build process integrating unit testing should be one of the development teams primary goals.

This session will show you how to leverage a number of mature and powerful tools to make creating your Android development process more effective.

You'll see how to use tools provided with the Android SDK to do logging, unit testing and UI testing. We'll cover some third party tools and services like Robotium for more readable unit testing. You'll see how Spoon can be used to produce HTML output and screenshots. Finally, we'll type it all together with Gradle will also be discussed.

This presentation is ideal for anyone about to join and team that needs to do Android development the right way.

The following topics are included in this presentation:

• Unit testing in the Dalvik Virtual Machine
• Taking advantage of Android Logging
• UI testing
• Integrating the build environment with Gradle

Mobile devices are fast becoming one of the preferred platforms for enterprise development and Android is the fastest selling mobile device. Prepare yourself for developing powerful business apps on Android by attending this presentation. We'll explore many of the most useful features of the Android architecture. You'll learn how to use databases, AsynTask processes and specialized views like ListView. You'll be ready to start building the new generation of mobile applications.

This presentation is intended for someone who has already built an Android app and has been introduced to the development environment. We will cover some additional topics that are important for development more sophisticated apps.

The following topics are included in this presentation:

• Storing and Retrieving Data
• SQLite Database
• Asynchronous Tasks
• ListViews and Adapters

An introduction to CoffeeScript as a drop in replacement for JavaScript and a tour of how it can impart structure to what has traditionally been a most disorganized part of our Web Applications.

An introduction to CoffeeScript as a drop in replacement for JavaScript and a tour of how it can impart structure to what has traditionally been a most disorganized part of our Web Applications.

In this session we'll venture into the lesser known JQuery (and JavaScript) techniques used to created components/widgets and mini-frameworks. Come and fill your client-side tool belt with new tools and techniques to make your web applications better.

In this session we'll venture into the lesser known JQuery (and JavaScript) techniques used to created components/widgets and mini-frameworks. Come and fill your client-side tool belt with new tools and techniques to make your web applications better.

In this session you'll learn about Jasmine, a behavior-driven development (BDD) framework for testing JavaScript code. Come and learn how to raise the bar for your client side testing using the BDD mindset.

In this session you'll learn:

• A bit about BDD and how it will lead you to better software
• How to test non-DOM-dependent JavaScript
• How to Jasmine can ease you in-browser testing (DOM dependent)
• How to run client-side tests from the command line and integrate them into your build/CI environment

This workshop is aimed at Java and Java EE developers looking to understand and apply a Rule Engine to solve problems typically and painfully addressed with traditional programming techniques.

In this workshop you will learn how to build lean applications using Test-Driven Development Techniques in conjunction with jBoss’ Drools Rule Engine to streamline, simplify and minimize the maintenance burden of a growing application in a rapidly changing business environment

Workshop Requirements

• Eclipse IDE - Juno

• The Drools IDE is part of the JBoss Tools family of plugins
  Select “Help” » “Install New Software…”
  Next to the “Work with:” field, select “Add…”
  Enter:
 http://download.jboss.org/drools/release/5.4.0.Final/org.drools.updatesite/ 
 with a name like “JBoss Tools”

• Code samples are hosted on Git. A Git Enable Eclipse installation is preferred but we can always use git from the command line

This workshop is aimed at Java and Java EE developers looking to understand and apply a Rule Engine to solve problems typically and painfully addressed with traditional programming techniques.

In this workshop you will learn how to build lean applications using Test-Driven Development Techniques in conjunction with jBoss’ Drools Rule Engine to streamline, simplify and minimize the maintenance burden of a growing application in a rapidly changing business environment

Workshop Requirements

• Eclipse IDE - Juno

• The Drools IDE is part of the JBoss Tools family of plugins
  Select “Help” » “Install New Software…”
  Next to the “Work with:” field, select “Add…”
  Enter:
 http://download.jboss.org/drools/release/5.4.0.Final/org.drools.updatesite/ 
 with a name like “JBoss Tools”

• Code samples are hosted on Git. A Git Enable Eclipse installation is preferred but we can always use git from the command line

Groovy isn't designed to replace Java – it just makes Java cleaner and easier to develop. This presentation will look at various tasks Java developers need to do and demonstrate ways Groovy can help.

Topics will include building and testing applications, accessing both relational and NoSQL databases, working with web services, and more.

This is the first in a new series on resource-oriented systems. The goal of the series is to provide practical guidance on the design and implementation of next generation systems that are flexible, extensible, high-performance and future-friendly. The talks are designed to work as arc, building upon each other, but they should also stand alone. The first topic is a guided walk through of building quality REST APIs.

We will focus on the architecture of the Web and how it can help us model and manipulate our important business concepts. We will discuss the role of stable identifiers, intentional representation design, hypermedia affordances and architectural consistency. The goal is not to be “RESTful”, the goal is to build systems that display the properties we require.

This talk will be accessible for people new to REST, but also different enough that those who have attended previous REST talks will learn new things.

This is the second in a new series on resource-oriented systems. The goal of the series is to provide practical guidance on the design and implementation of next generation systems that are flexible, extensible, high-performance and future-friendly. The talks are designed to work as arc, building upon each other, but they should also stand alone. This second talk is an introduction to the use of Semantic Web technologies to enable collaboration without coordination.

REST is a means to an end, but it is not a satisfactory end state. It usually pushes complexity to the client in ways that make data integration difficult across multiple sources. The W3C Semantic Web initiative introduces us to new technologies for linking resources and querying across them in powerful new ways. We will learn about the RDF model, what it brings to the table and how we can use it connect information regardless of where and how it is stored. We will use the SPARQL protocol and query language to ask powerful questions of arbitrary resources. We will also see how we can create new information just by asking for it.

This is the third in a new series on resource-oriented systems. The goal of the series is to provide practical guidance on the design and implementation of next generation systems that are flexible, extensible, high-performance and future-friendly. The talks are designed to work as arc, building upon each other, but they should also stand alone. This third talk will introduce you to RDFa, one of the most exciting technologies estimated to be used on at least 25% of the indexed Web.

We understand that documents contain information, but it is usually only accessible to humans if they know where and how to find them. What if we could automatically extract arbitrary information about arbitrary domains and connect it to information held elsewhere? What if we could use the information in a document to help us organize our content better? What if this embedded information could help external search engines index the public Web better and improve your rankings?

This talk will show you how to weave and extract information in HTML, XHTML and arbitrary XML using standard tools such as RDFa. In the process, you will learn how to free the information so that it may be reused in powerful and unanticipated ways.

If you're not terrified, you're not paying attention.

Publishing information as webs of data does not require us to just give it away. We have a series of tools and techniques for managing identity, authentication, authorization and encryption so we only share content with those we trust.

Before we tackle Web Security, however, we need to figure out what we mean by Security. We will pull from the worlds of Security Engineering and Software Security to lay the foundation for technical approaches to protecting our web resources.

This is the fifth in a new series on resource-oriented systems. The goal of the series is to provide practical guidance on the design and implementation of next generation systems that are flexible, extensible, high-performance and future-friendly. The talks are designed to work as arc, building upon each other, but they should also stand alone. This fifth talk will introduce you to the idea of leveraging popular open source visualization libraries (such as D3.js) to highlight features of integrated resources.

A picture is said to be worth more than a few words. Visualization is a strategy for conveying complex relationships, concepts and unexpected situations. It is an exciting time in the data visualization space because of all the new libraries, but the combination of rich data and rich visualization tools is even more compelling. Once our information is available in resource-oriented systems, we can visualize not only individual sources, but merged content as well.

Technical Debt can creep up on a project very quickly and ultimately create a technical crisis. Sonar can help you see how far gone your project may be and if you are continuing to head toward a crisis.

In this workshop we will discuss how the simple act of making technical debt visible to the developer, team, manager and organization can have a positive affect on the reversal of technical debt.
We will look at how to measure & visualize the seven axes of code quality:
Architecture & Design
Comments
Complexity
Coding Rules
Duplications
Potential Bugs
Unit Tests

We will show how to visualize measures these seven axes of code quality. These measures can help identify where to focus our limited time and attention to make the biggest impact on technical debt.
Used appropriately these measures can drive powerful conversations on reversing the current negative trends in your technical debt.

The word just came down from the VP - you need a mobile app and you need it yesterday. Wait, you've never built a mobile app…it's pretty much the same thing as you've built before just smaller right? Wrong. The mobile experience is different and far less forgiving. How do you design an application for touch? How does that differ from a mouse? Should you build a mobile app or a mobile web site? This workshop will get you started on designing for a new, and exciting, platform. Whether that means iPhone, Android, Windows Phone or something else, you need a plan, this talk will help.

We'll look at some popular web sites discussing what we would do differently in a mobile context and then take a look at the actual mobile experience to see what other designers actually did. Using paper, we'll work though a design or two of our own. We'll wrap up discussing various methods of creating a mobile app - should we use the web or build something native? What about shell apps? While we might not have all the answers, at the end of this workshop you'll know what questions to ask when thinking through your own situation.

Workshop Requirements

This workshop is more analog than digital - a laptop is not required. A pen or pencil though, is!

The word just came down from the VP - you need a mobile app and you need it yesterday. Wait, you've never built a mobile app…it's pretty much the same thing as you've built before just smaller right? Wrong. The mobile experience is different and far less forgiving. How do you design an application for touch? How does that differ from a mouse? Should you build a mobile app or a mobile web site? This workshop will get you started on designing for a new, and exciting, platform. Whether that means iPhone, Android, Windows Phone or something else, you need a plan, this talk will help.

We'll look at some popular web sites discussing what we would do differently in a mobile context and then take a look at the actual mobile experience to see what other designers actually did. Using paper, we'll work though a design or two of our own. We'll wrap up discussing various methods of creating a mobile app - should we use the web or build something native? What about shell apps? While we might not have all the answers, at the end of this workshop you'll know what questions to ask when thinking through your own situation.

Workshop Requirements

This workshop is more analog than digital - a laptop is not required. A pen or pencil though, is!

You may have noticed today's web applications involve more than a few lines of JavaScript. You've probably also figured out JavaScript lacks certain…features…that make writing non-trivial applications more challenging. How do we resolve this conundrum? Luckily for us, we can leverage libraries like Backbone add some structure to our code. Backbone brings the concepts of the model view controller pattern we've applied to the server for years to the browser.

In this workshop, we'll introduce the idea of asynchronous user interfaces and show how Backbone helps us write that style of application. We'll work our way up from the bottom building a simple application along the way. We'll create models, we'll use a templating library (or two) and we'll also explore Underscore - a JavaScript utility belt you can use right now today without committing to building MVC style web applications.

If you're struggling to manage an increasing amount of JavaScript or you want to build more responsive web applications, this workshop can help!

Workshop Requirements

For this workshop you should have:

• Laptop
• Text editor or IDE
• One or more “modern” (Chrome, Safari, etc) browser

Optionally, you can have Git installed but it isn't required. Before the workshop, take a minute to setup the code somewhere on your laptop. The code is on github:

https://github.com/ntschutta/backbone_workshop

You can clone the repo from there or simply download a zip if you prefer. That's it! See you in Florida!

You may have noticed today's web applications involve more than a few lines of JavaScript. You've probably also figured out JavaScript lacks certain…features…that make writing non-trivial applications more challenging. How do we resolve this conundrum? Luckily for us, we can leverage libraries like Backbone add some structure to our code. Backbone brings the concepts of the model view controller pattern we've applied to the server for years to the browser.

In this workshop, we'll introduce the idea of asynchronous user interfaces and show how Backbone helps us write that style of application. We'll work our way up from the bottom building a simple application along the way. We'll create models, we'll use a templating library (or two) and we'll also explore Underscore - a JavaScript utility belt you can use right now today without committing to building MVC style web applications.

If you're struggling to manage an increasing amount of JavaScript or you want to build more responsive web applications, this workshop can help!

Workshop Requirements

For this workshop you should have:

• Laptop
• Text editor or IDE
• One or more “modern” (Chrome, Safari, etc) browser

Optionally, you can have Git installed but it isn't required. Before the workshop, take a minute to setup the code somewhere on your laptop. The code is on github:

https://github.com/ntschutta/backbone_workshop

You can clone the repo from there or simply download a zip if you prefer. That's it! See you in Florida!

Technology changes, it's a fact of life. And while many developers are attracted to the challenge of change, many organizations do a particularly poor job of adapting. We've all worked on projects with, ahem, less than new technologies even though newer approaches would better serve the business. But how do we convince those holding the purse strings to pony up the cash when things are “working” today? At a personal, how do we keep up with the change in our industry?

This talk will explore ways to stay sharp as a software professional. We'll talk about how a technology radar can help you stay marketable (and enjoying your career) and how we can use the same technique to help our companies keep abreast of important changes in the technology landscape. Of course it isn't enough to just be aware, we have to drive change - but how? This talk will consider ways we can influence others and lead change in our organizations.

Have you ever wondered what goes on inside the virtual machines and
interpreters that we use every day?

In this session, you'll see some of the inner workings of Python, PHP, Java, and JavaScript and learn that at the lowest level these languages really are not as different as they may seem.

An overview of the basic parts of a virtual machine and interpreter that compares and contrasts the different approaches taken by different modern languages.

In part II of VMs and Interpreters, you'll dive into the inner workings of the Java Virtual Machines. You'll learn how your Java code is translated from Java source code to byte code and ultimately machine code.

You'll also see tools for viewing Java byte code and measuring performance changes caused by VM optimizations.

This session will cover the…

• Java class file format
• Java byte code
• JVM Compiler & Runtime Optimizations

Unlike earlier languages, Java had a well-defined threading and memory model from its inception, and over the years additional packages have been added to the standard library to help solve concurrency problems.

Despite all this, Java's memory model still remains poorly understood and
its concurrency libraries under utilized.

In this talk, we'll discuss concurrency in detail starting from the low-level
of the hardware up to the high-level of concurrent collections and Java 7's
new parallel fork join library.

Update: We'll be using Android Studio and Gradle for this workshop

The smartphone has been the current platform of choice for Android development but we are now in the “year of the tablet” and it is time to upgrade your skills. Even though you think you know Android programming, you still need to learn the unique techniques for developing for tablet.

We'll analyse the UI patterns important on tablets (like Action Bars). And you'll learn how to use the specialized classes (like Fragments) that were created especially for tablets.

The following topics are included in this presentation:

The Tablet Marketplace
Tablet UI design
Optimizing layouts for larger screens
Dips, Sips and pixels
Action Bars
Fragments
Side Navigation
3rd Party Libraries

This is a revised and updated version of the previous talk, with current thinking from practice and the literature. The talk presents why conflicts with your manager are inevitable based on differences in priorities and perspectives, and how to plan for them. The goal is to show you how to build the loyalty relationship that allows you to get what you need when you need it.

Topics covered will include diagnosing communication styles, lessons from game theory, working within the organizational hierarchy, and lessons on how to build a relationship with your manager that still allows you the freedom to express yourself and what you really want.

This talk could be called, “Why Nate Silver Was Right”. Nate's correct predictions during the 2012 US elections made him famous, but he actually used very straightforward, simple concepts that can be applied in a variety of business settings. This talk reviews his techniques, and includes an overview of Bayesian statistics, which allow you to use a priori estimates to refine your forecasts over time.

Topics will include pre- and post-processing data, judging similarities, available tools and technologies, and an (uncertain, of course) forecast of the future.

While many developers have embrace simpler NoSQL variants (like MongoDB and CouchDB). Cassandra is possibly at the forefront of the NoSQL innovation, providing a level of reliability and fine tuning not found in many of the competitors offerings.
In this session we'll learn why you should consider Cassandra DB for your next large-data project and how to build a Cassandra based application from the ground up, taking advantage of virtualization techniques to emulate a complex multi-machine environment.

While many developers have embrace simpler NoSQL variants (like MongoDB and CouchDB). Cassandra is possibly at the forefront of the NoSQL innovation, providing a level of reliability and fine tuning not found in many of the competitors offerings.
In this session we'll learn why you should consider Cassandra DB for your next large-data project and how to build a Cassandra based application from the ground up, taking advantage of virtualization techniques to emulate a complex multi-machine environment.

Workshop Requirements

• Java 7
• Python
• Code Editor (IDE or simple text editor)
• Groovy
• Gradle
• Cassandra Server
• CQLSH (CQL Shell)

View Casandra Installation Details »

Languages that support both dynamic typing and closures radically simplify the standard design patterns. This presentation will demonstrate how many of the common patterns in Java simply vanish in Groovy, and how much simpler they are even when they remain.

Patterns will include Adapter, Factory Method and Abstract Factory, Builder, Decorator, Singleton, Proxy, Visitor, and as many more as time allows.

Often we avoid testing the most important things simply because they are hard to test,
but doing so runs the risk that these untested bits of code may fail at the worst
possible moment.

In this talk, we'll explore some creative (and crazy) ways to test some of the hardest
problems including:

• Network failures
• Transactions
• Optimistic concurrency
• Race conditions
• Legacy code

Some come to Agile assuming it involves less discipline than their traditional methods, but this is a misperception. Today, the need for discipline in software development is greater than it ever was. Agile answers that need, arriving at discipline through the Team. Agile Teams must collaborate to develop strong discipline in both planning and execution.

We'll discuss how teams can obtain Agile discipline to achieve one of our core principles of delivering “working software” frequently. We'll explore some of the key Agile planning and engineering practices like continuous planning, Test-Driven Development, Continuous Integration and Acceptance testing. We'll look at the discipline involved in these practices, their inter-relationship, and the benefits they realize in delivering value to the customer.

We know agile methods are proven on small teams, but really…almost any process works with a team of one. As the team scales, however, the challenges mount. In this session, we focus on proven practices that help large software development teams in excess of 100 developers maintain agility. We also explore how to scale agile across the enterprise.

Come learn about ways to increase transparency on large projects, structure the development team, garner the important feedback you need from customers, and avoid the lack of rhythm so common on large teams. We’ll explore how large teams can conduct effective code reviews, maintain a consistent architectural vision, take advantage of automation, and build a development process that is sustainable on large teams. In lieu of focusing on specific agile methods in this session, we turn our attention to practices that the development team can leverage today to get started on the road to increased agility.

The Spock framework brings simple, elegant testing to Java and Groovy projects. It integrates cleanly with JUnit, so Spock tests can be integrated as part of an existing test suite. Spock also includes an embedded mocking framework that can be used right away.

In this presentation, we'll look at several examples of Spock tests and review most of its capabilities, including mock objects and integration with Spring.

The Gradle build tool is one of the most successful projects in the Groovy ecosystem because it addresses a difficult problem – every major build is a custom build. Gradle builds are written in Groovy, so the full power of the language is available if you need it. Gradle supports Maven project structure and repositories and uses Ivy dependency management without being bound by their normal constraints. With major systems like Grails, Hibernate, and the Spring Framework moving to Gradle, this is a technology worth taking the time to understand.

This talk will cover the basics of Gradle both through simple examples and by examining the build files for major open source projects.

Join Kirk for a discussion on all things relative to software architecture.

Don't miss it!