Many of you may have an architect title, take on the role of an architect, or even aspire to be an architect, but are you thinking like an architect? Architectural thinking is learning to look at a problem or task from an architect's point of view. In this session we will look at many facets of architectural thinking, including how requirements shape the architecture, component-based thinking, how to make architecture decisions, and what feasibility and vitality means to an architect.

Agenda:

• expectations of an architect
• technical breadth vs. depth
• how requirements shape the architecture
• making architecture decisions
• component-based thinking

Just as developers use design patterns in software development, architects use well-defined architecture patterns to get a head start on defining the characteristics and shape of the architecture for a system. In this session we will explore some of the more common architecture patterns and use concrete real-world examples to demonstrate how the patterns work. I will also go over the pros and cons of each pattern and discuss how requirements and operational aspects can drive which patterns to use. Using the right architecture pattern for your system is critical, because as we all know, once in place the architecture is very hard to change.

Agenda:

• Why use architecture patterns?
• Layered Architecture Patten
• Event Driven Architecture Pattern
• Microkernel Architecture Pattern
• Space-based Architecture Pattern

In the past I have presented quite a few fun sessions about software development anti-patterns - things we repeatedly do while developing code that produce negative results. In this session, I will use the same “pattern” as with my other anti-pattern talks and introduce and discuss many of the common software architecture anti-patterns. These are perhaps more significant than the development anti-patterns because they are harder to refactor. Therefore, knowing these anti-patterns ahead of time will save you time, trouble, and perhaps even your job!

Agenda:

• Introduction
• A detailed look of the most common architecture anti-patterns

Service-Oriented Architecture (SOA) has become an ugly word in the industry. Not only is everyone more confused than ever about what SOA is, but the tooling and products surrounding SOA has made it into a ubiquitous buzzword that has little or no meaning these days. That said, SOA as an architecture pattern is still very much alive and solves many issues within a service-based architecture approach. So what is SOA from an architecture standpoint? In this product-free session we will take a detailed look at SOA from an architecture pattern point of view, understand how abstraction plays a part in SOA, and also understand the implementation aspects of the pattern. At the end of this session we will look at a few service bus considerations, including dealing with single point of failure scenarios, performance bottleneck issues, and service bus roles and responsibilities.

Agenda:

• architecture pattern elements
• forms of abstraction
• pattern implementation (no products!)
• service bus considerations

Since writing the second edition of the O'Reilly JMS 1.1 book I've spent a lot of time speaking and writing about AMQP (Advanced Message Queuing Protocol). While I'm still excited about AMQP, I'm also excited about another area of messaging - the recently released JMS 2.0 specification. I'll begin this live coding session with a high-level summary of what has changed with the JMS 2.0 specification release. Then, through live coding I will provide you through a first-hand look at the new simplified API and the new features of the latest JMS specification that not only make it easier to develop messaging applications, but also make it more suitable for enterprise-level messaging. There is a lot happening in the messaging space right now - climb on board this session to see what all the buzz is about!

Agenda:

• specification summary
• openmq 5.0 configuration
• jms 2.0 simplified api
• jms 2.0 new messaging features

Now that Java is supporting lambda expressions, it's time to hone our skills to make use of them. Lambda expressions can help create concise code, however, it takes more than learning the syntax to put them to good use.

In this presentation we will learn the idiomatic use of lambda expressions, explore the ways in which we can use them to solve common tasks, and look into libraries and APIs that make use of them in Java.

Java 8 brings support for lambda expressions and functional style of programming. With that, the design concepts and the patterns we're used to in Java enjoy a makeover.

Come to this presentation to learn about how the familiar patterns transform and shine in Java 8.

In this session, we will take a look at Angular - a new MVC framework by Google. We will discuss some of the terminology that Angular offers, and see how we can use that to develop highly interactive, dynamic web applications. See “Detail” for a list of topics I cover and the Github repo URL

This is an intro-level talk we will take a look at Angular and developing rich web applications. Angular embraces HTML and CSS, allowing you to extend HTML towards your application, and uses plain JavaScript which makes your code easy to reuse, and test.

Note: This is an intro level talk. It is targeted towards developers who are curious about Angular and want to learn about the fundamental features and concepts in Angular.

Topics Covered -

• Bootstrapping an AngularJS application using ng-app
• ng-init and the evaluation {{ }} directive
• A brief look at $rootScope
• ng-model
• Controllers, Dependency Injection, and the View-Model ($scope)
• Looping using ng-repeat
• Forms using ng-form, form validation and submission in AngularJS
• Angular provided filters
• Making AJAX requests using $http

GitHub URL - https://github.com/looselytyped/angudone-backend/tree/solutions

JavaScript will celebrate it's 19th birthday in 2014. For a language that has been around for such a while it has seen very few, if any changes to the language itself. Well all that is about to change with ECMAScript.next (or ECMAScript 6). ECMAScript 6 modernizes JavaScript syntax, while bringing in features such as modules for better namespacing, class as a first class construct, and a variety of additional operators thus ensuring that JavaScript is ready for the next era of large scale modern web applications.

In this session we will take a look at some of the features that ECMAScript 6 brings to the table and see what kind of browser support is available for it.

In this session we will look at some JavaScript patterns, and how you can use them within your code.

No longer can you think of JavaScript as a kiddie-scripting language. JavaScript has now been promoted to a first-class citizen within your application - and with this, comes the need to think of better abstractions, code re-use - even thinking of establishing a common vocabulary to discuss approaches to writing better, cleaner and ultimately more maintainable JavaScript code.

It was over 10 years ago that Spring hit the scene and made a big impact in the enterprise Java development ecosystem. Now that Spring 4.2 is available (and Spring 5 on the way), there's a lot of new features and a lot that you may not know about yet.

Whether you're already working with Spring 4 or are anxious to make a move up, there's plenty of new tricks Spring has in store for you. We'll explore them all in this overview of everything that's new in Spring.

In this session, we'll see how to build real Spring applications using Spring Boot. We'll also look under the covers to see what makes Spring Boot tick.

Spring offers a number of configuration options: XML configuration, Java configuration, and Groovy configuration to name a few. To some degree, component-scanning and autowiring help eliminate some explicit configuration. But in general most Spring applications require some essential “bootstrap” configuration to enable key functionality. What's the right way to build Spring applications when there are so many choices?

What if I told you that configuration was optional?

Spring Boot is an exciting new programming model for Spring that makes it extremely easy to create stand-alone, production-ready Spring applications. Rather than writing lots of code to satisfy the needs of a framework, Spring Boot helps you focus your coding efforts on your application. Spring Boot takes an opinionated approach to configuring Spring, making it possible to create Spring applications with little or, in some cases, no Spring configuration at all!

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.

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.

Encryption is a powerful tool for privacy. At least that is what we're meant to think.

If you consider encryption to be a black box of magic, you should probably attend this talk.
If you think encryption will protect your secrets, you should probably attend this talk.
If you have (or haven't) been following the news, you should probably attend this talk.

The truth is, encryption can be an effective way of making it harder for people to steal your secrets. But it isn't magical, it isn't fool proof and, depending on how you are using it, may be completely useless. It is a hard topic that we'll only touch the surface on, but there are very few topics that are more crucial for our industry and profession to understand better than encryption. You don't have to understand the math (although that will help), but you do have to understand what it will and won't do for you*.

*and how implementations of it may have been intentionally compromised

You understand the Web. Why do you do REST so wrong?

Doing REST “right” isn't a matter of conformance or purity. It isn't about pleasing hard-to-please Restafarian personalities. It's about understanding that WYBIWYG (What you Build is What You Get). Decisions have consequences. You are free to design and implement whatever you like, but you need to understand the consequences of your choices.

REST, as defined by Roy Fielding's thesis, is a collection of architectural constraints designed to yield certain properties in deployed systems. When you take shortcuts, you simply will not receive all the benefits of loose-coupling, evolvable, flexible, scalable systems. URLs are not enough. HTTP is not enough. To fully embrace the world of REST, you must understand Hypermedia. The good news is that you already do, you've apparently just forgotten.

Here's the thing though. REST is not an endpoint, it is just a beginning. Come to this talk to hear how the story starts. We will take a deep dive into why the Web works, the implications for building Hypermedia-driven REST APIs and start to look at what this means in practice.

For over 10 years, Spring has been the go-to framework for developing powerful Java server applications. Increasingly, however, modern applications are placing heavier demands on the client side, expecting applications to be available anywhere, anytime, and on any device. In a client-rich world, where does Spring fit it?

In this session, we'll explore Spring's role in modern applications where the client can be on someone's desk or in someone's hands. We'll see how to take advantage of various Spring features and libraries to create a rich and responsive application that can run on a variety of devices.

The basics of developing for the Android platform will be explored, from setting up the SDK to using the Android Studio IDE and the generated Gradle build files. No previous experience is required, other than a basic knowledge of Java.

After discussing how Android fits into the marketplace, we'll look at creating applications, how to use activities, and working with layouts.

Building on the the previous talk, we'll add intents, customized layouts for alternative configurations, talk about the activity lifecycle, use logging, and more.

We'll deploy to both emulators and connected devices, and change input styles.

This session will move beyond the basics cover Android persistence mechanisms, accessing RESTful web services, and more. We'll look at shared preferences, basic file I/O, and the Sqlite database. We'll also show how to operate off of the UI thread to access data from remote servers.

The application will access JSON data on a remote server, parse the data, and update the user interface based on the response.

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.

We make many assumptions when we develop our applications. Many of these assumptions no longer hold true when we start to build applications for the cloud. Cloud platforms also introduce architectural possibilities that do not exist in traditional deployment settings. This session will examine five architectural patterns that we can apply to our applications in order to prepare them for the unique characteristics of cloud environments.

We'll cover the following patterns:

• Microservice
• API Gateway
• Stateless / Shared-Nothing
• Configuration / Service Consumption
• Fault Tolerance

Examples will focus on the application of these patterns using Java/Spring and Cloud Foundry-based PaaS platforms, but should be applicable to any language/framework/PaaS platform combination.

Even with the recent explosion in alternative languages for the JVM, the vast majority of us are still writing code in “Java the language” in order to put bread on the table. Proper craftsmanship demands that we write the best Java code that we can possibly write. Fortunately we have a guide in Joshua Bloch's Effective Java.

In his foreward to the first edition, Guy Steele writes about the importance of learning three aspects of any language: grammar, vocabulary, and idioms. Unfortunately many programmers stop learning after mastering the first two. Effective Java is your guide to understanding idiomatic Java programming.

Effective Java is organized into 78 standalone “items,” all of which will be impossible to cover in one session. Instead I've chosen a subset of the most important techniques and practices that are commonly missed by today's Java programmers. You'll pick from a menu and decide where we'll head. Regardless of the path we take, you'll leave this session thoroughly equipped to write better Java code tomorrow!

“Docker is an open-source engine that automates the deployment of any application as a lightweight, portable, self-sufficient container that will run virtually anywhere.” Docker creates containers that provide running process with:

• an equal slice of CPU
• a maximum memory quota
• its own process ID (PID) namespace
• its own network interface
• its own private root filesystem

It does this by leveraging low-level Linux kernel primitives like cgroups and namepaces. The end result is a portable application container that can run anywhere Docker can run, including on VMs, bare-metal servers, OpenStack clusters, public instances, or combinations of the above.

Containers are an excellent way to package your application such that it can run consistently everywhere you want to run it, a fantastic step toward Continuous Delivery. In this session we'll look at how to use Docker to package, deploy, and run Java applications and other services. We'll also compare Docker to another container solution, Warden, which is a key component of the Cloud Foundry PaaS.

Robert Martin assembled the SOLID family of principles to provide a useful guide to help us create object-oriented software designs that were resilient in the face of change. In recent years, the need to write highly-concurrent software in order to leverage increasingly ubiquitous multicore architectures, as well as general interest in more effectively controlling complexity in large software designs, has driven a renewed interest in the functional programming paradigm. Given the apparent similarity in their goals, “What is the intersection of SOLID with functional programming?” is a natural question to ask.

In this talk, we'll explore this intersection. We'll begin with a tour of the evolutionary patterns associated with enterprise software and programming paradigms, as well as take a look at the ongoing quest for best practices, the goal being to elucidate the motivation for examining this intersection of SOLID and functional programming. We'll then walk through each of the SOLID principles, examining them in their original object-oriented context, and looking at example problems and solutions using the Java language. Then for each principle, we'll examine its possible intersection with the functional programming paradigm, and explore the same problems and solutions using the Clojure language. We'll close by examining the transcendent qualities of the SOLID principles and how they can make any design simpler, regardless of the programming paradigm employed.

For much of the last two years I've delivered a two-part series at NFJS shows entitled “Effective Java Reloaded.” For all pracical purposes, it is an ala carte style rehash of the book Effective Java, written by Josh Bloch. One of my favorite parts of the discussion is of Item #15, which tells us to “Minimize Mutability.” If we turn this inside out, we're actually saying that we want to MAXIMIZE IMMUTABILITY. When we do this, we reap many benefits, such as code that is easier to reason about and that is inherently thread-safe. This can carry us a long way in the direction of program correctness and decreased complexity. However, when we start to program with immutability, several major questions arise.

First, the necessity of using a separate object for each distinct value, never reusing, or “mutating” an object, can quickly cause performance concerns. These concerns are amplified when we're talking about large collections such as lists and maps. These problems are largely solved by what we call “persistent data structures.” Persistent data structures are collections from which we create new values, not by copying the entire data structure and apply changes, but by creating a new structure which contains our changes but points at the previous structure for those elements which have not changed. This allows us to work with data structures in a very performant way with respect to time and resource consumption. We'll examine persistent data structures, their associated algorithms, and implementations on the JVM such as those found in the TotallyLazy library.

Second, because all of an immutable object's state must be provided at the time of construction, the construction of large objects can become very tedious and error prone. We'll examine how the Builder pattern can be applied to ease the construction of large objects, and we'll examine Builder implementations in Java and Groovy.

Third, we run into problems when we start to use frameworks that expect us to program in a mutable style. A prime example is Hibernate, which expects our persistent classes to follow the well-worn JavaBean convention, including a no argument constructor and getters and setters for each property. Such a class can never be mutable! So how do we program with frameworks such as Hibernate and yet still minimize mutability? The key is found in not letting frameworks dictate the way that you design your code. Just because the framework require something, don't let it force you to make the wrong decision. Use the framework as a tool to write your code, don't let your code be a tool of the framework. We'll examine strategies for doing exactly that.

You should come away from this talk better equipped to program in a way that minimizes mutability and maximizes immutability.

Java 8 is finally released. We haven't seen this number of changes to Java the language since Java 5. This session will provide a review of the changes to Java 8 with a focus on the language changes such as the addition of lambdas which will either have you excited for a language feature which allows you to express what you want vs. how you want it or will have you concerned about readability in your code base.

This session will introduce the changes of Java 8 including language changes such as:

• type inferencing
• type Optional
• lambdas
• streams
• new collections
• filters
• maps
• laziness
• parallelism
• working with resources

and will provide details of the JVM changes such as:

• PermSpace
• MetaSpace

So your server is having issues? memory? Connections? Limited response? Is the first solution to bounce the server? Perhaps change some VM flags or add some logging? In todays Java 6 world, with its superior runtime monitoring and management capabilities the reasons to the bounce the server have been greatly reduced.

This session will look at the Java monitoring and management capabilities, which includes the ability to make VM argument changes on the fly. This session will dive into the different memory compartments and how they are used by the JVM. Final this session will explore the different GC options and how they affect response times and throughput.

Introduction to Go

Introduction to Go… language of the cloud

Java EE 7 is around the corner and the horizons for Java EE 8 are emerging. This session looks into the key changes the community can expect. The goal of this session is to foster interest and discussion around these changes.

Some of the changes discussed include retiring EJB 2 entity beans and JAX-RPC, greater alignment with CDI, WebSocket/HTML 5 support, a standard API for JSON processing, the next version of JAX-RS, an overhaul of JMS, long-awaited concurrency utilities, batch processing in Java EE and much, much more.

Domain-Driven Design (DDD) promises to simplify enterprise application development and is gradually gaining traction as an alternative to traditional four-tier architectures originally popularized by J2EE. As the name implies, DDD is an architectural approach that strongly focuses on materializing the business domain in software. This session demonstrates first-hand how DDD can be implemented using Java EE via a project named Cargo Tracker.

Part of the Java EE Blue Prints, Cargo Tracker seamlessly maps concepts like bounded contexts, layered architectures, entities, value objects, aggregates, services, repositories and factories to realistic code examples. The Cargo Tracker project also embraces popular practices adopted by the DDD community such as Object Oriented Analysis, Domain Models, Test Driven Development, Agile Refactoring, Continuous Integration, Object Relational Mapping, Dependency Injection and Cross-Cutting Concerns, incorporating these concepts into a realistic Java EE application.

The cost of integrating information isn't cheap. Well, at least it isn't if you do it wrong. Chances are, you're doing it wrong.

The single most difficult aspect of data integration is the effort to achieve consensus. It isn't just that we are disagreeable people. It's also that it is a fantasy that there is a “common model” or a “global truth”. Different groups and individuals see the world differently and have different needs from information systems. Language, and therefore what we call things, isn't simply reflective of reality. It plays a constructive and interpretive role.

The problem is that our technologies force us to make choices about world views and pretend that things aren't changing constantly. This yields fragile systems and high impedance to change that cascades through our organizations. This translates to expensive, rigid and difficult to extend failure to give the business what they want.

Our friend Tim Berners-Lee and his Happy W3C Merrymakers have given us a set of technologies to help us solve these problems though. We forget that the Web he designed was not the public Web, but one to solve integration needs for complex organizations like CERN. The HTML bit that we have gotten so excited about is but a small part of the vision. We will introduce RDF and SPARQL as enabling technologies. They do not necessarily replace what you already have, but they do make it possible to share information with people you've never talked to: Collaboration without Coordination.

Webs of documents are fabulous enough. Webs of data will blow your mind.

A table is a fixed structure. A tree is as well. A graph can go on forever and be extended at any time by anyone.

The Web is an unbounded graph. It is our definition of scale. What happens when we start to use it as the basis of sharing information, not just documents. This does not necessarily mean the public Web (although it is certainly appropriate for that as well). It simply means thinking of information as a web of linked entities through discoverable relationships.

Linked data is a way of doing this, but it is also an established project connecting billions of entities from disparate, unrelated sources. How does that even work? What can you do with such a thing? And what does that mean for your organization?

By building on the ideas introduced in the Data Integration talk, we will explore how webs of data built on standards can change everything.

The surge of interest in the REpresentational State Transfer (REST) architectural style, the Semantic Web, and Linked Data has resulted in the development of innovative, flexible, and powerful systems that embrace one or more of these compatible technologies. However, most developers, architects, Information Technology managers, and platform owners have only been exposed to the basics of resource-oriented architectures.

This talk, based upon Brian Sletten's book of the same name, is an attempt to catalog and elucidate several reusable solutions that have been seen in the wild in the now increasingly familiar “patterns” style. These are not turn key implementations, but rather, useful strategies for solving certain problems in the development of modern, resource-oriented systems, both on the public Web and within an organization's firewalls.

Enough with the darn JavaScript frameworks already! There's nothing wrong with a judicious use of this ubiquitous programming language, but it's gotten a little out of hand. What if there were an evolvable future state of declarative and encapsulated user interface elements that was available today in most modern browsers?

There is! The Polymer Project is a young but impressive glimpse into where things should go.

It's goals are:

• Use the platform
• Everything is an element
• Eliminate boilerplate

This talk will introduce you to:

• The Polymer Project
• The strategy for supporting today's browsers with tomorrow's technologies
• Application frameworks that build upon these core technologies
• Custom visual and non-visual elements
• The underlying W3C Specifications that engender all of this

Many software developers point their career towards ascending to the gilded rank of Architect…but what does it mean to actually be one? While many of us labor under false pretense of abject technical decision making, the reality is often very different. You'll code less, spending more time on activities that lack an objective green/red bar. But you'll also an opportunity to impact far more than one project.

In this talk, I'll speak to my own journey. We'll touch on influencing coworkers, the importance of communication and the importance of cup of coffee.

Many software developers point their career towards ascending to the gilded rank of Architect…but what does it mean to actually be one? While many of us labor under false pretense of abject technical decision making, the reality is often very different. You'll code less, spending more time on activities that lack an objective green/red bar. But you'll also an opportunity to impact far more than one project.

In this talk, I'll speak to my own journey. We'll touch on influencing coworkers, the importance of communication and the importance of cup of coffee.

By now, the importance of having a mobile solution is obvious to just about every seat in the organization…but how do develop expertise? How do we work through the inevitable politics and organizational issues? What about the technical questions about hybrid vs. web vs. native?

Before you think about a mid life career change, spend some time listening to what we did in one large company. We may not have had all the right answers, but we learned a few things along the way.

By now, the importance of having a mobile solution is obvious to just about every seat in the organization…but how do develop expertise? How do we work through the inevitable politics and organizational issues? What about the technical questions about hybrid vs. web vs. native?

Before you think about a mid life career change, spend some time listening to what we did in one large company. We may not have had all the right answers, but we learned a few things along the way.

Architecting and developing user interfaces used to be relatively easy, pick a server side framework, define a standard monitor resolution and spend your days dealing with browser quirks. But today, the landscape presents us with a plethora of screen sizes and resolutions covering everything from a phone to a tablet to a TV. How does a team embrace this brave new world knowing that the future will introduce even more volatility to the client space?

This talk will walk you through this brave new world. We'll discuss the deluge of devices the typical application must deal with today as well as looking at the plethora of client side rendering technologies. This isn't strictly a front end problem though, we need to reconsider how we've built our server side solutions as well; modern applications rely on RESTful web services delivering data to a diverse set of clients. The development landscape has changed, this talk will prepare you to face these challenges.

The sea change in HTML 5 is likely to shift the pendulum away from today's thin-client based server-side web frameworks like Struts 2 and JSF to JavaScript powered next generation rich clients. With strong support for REST, WebSocket and JSON, Java EE 7 is well positioned to adapt to this change.

In this heavily code driven session, we will show you how you can utilize today's most popular JavaScript rich client technologies like AngularJS, Backbone, Knockout and Ember to utilize the core strengths of Java EE using JAX-RS, JSR 356/WebSocket, JSON-P, CDI and Bean Validation.

Reactive programming is gaining some good attention recently. If you wonder what this is all about come to this presentation for a practical introduction.

Reactive Programming, what is it, what does it solve, how to use it today?

Almost every example of an agile project involves a single team and while many successful projects are delivered that way, most enterprise software requires the interaction of several teams. But how do we scale agile beyond a single team? What practices translate and which ones don't? In this talk we'll discuss some of the issues you'll encounter as you move agile beyond a single group and how you can keep multiple stakeholders happy. While it isn't as simple as having a “scrum of scrums” it isn't as hard as replacing every line of COBOL.

Almost every example of an agile project involves a single team and while many successful projects are delivered that way, most enterprise software requires the interaction of several teams. But how do we scale agile beyond a single team? What practices translate and which ones don't? In this talk we'll discuss some of the issues you'll encounter as you move agile beyond a single group and how you can keep multiple stakeholders happy. While it isn't as simple as having a “scrum of scrums” it isn't as hard as replacing every line of COBOL.

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.

Inspired by success stories from companies such as Amazon and Netflix, many organizations are moving towards microservice architectures at a brisk pace. This session provides a thorough overview of the pros and cons for microservice architectures, when it is applicable, and some nascent best practices.

Microservice architecture is important because it’s the first architecture to fully embrace the Continuous Delivery and DevOps revolutions. In this session, I cover the motivations for building a microservice architecture (including making the distinction between “regular SOA” and microservices), some considerations you must make before starting (such as transactions versus eventual consistency), how to determine service partition boundaries, and ten tips to dowse you towards success. I also discuss the role of polyglot development, enterprise governance, how data and databases fit into this new world, and tooling to help ensure consistency between core services like logging and monitoring. This session provides a thorough overview of the pros and cons for microservice architectures, when it is applicable, and some nascent best practices.

The first part of the Continuous Delivery workshop covers the differences between continuous integration, continuous deployment, and continuous delivery). It also introduces the deployment pipeline_, along with usage, patterns, and anti-patterns. This part concludes with some applied engineering principles.

Releasing software to actual users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours—sometimes even minutes—no matter what the size of a project or the complexity of its code base. The workshop materials are derived from the best selling book Continuous Delivery and creating in collaboration with the authors and other of my ThoughtWorks colleagues. Continuous Delivery details how to get fast feedback on the production readiness of your application every time there is a change—to code, infrastructure, or configuration.

The first part of the workshop describes the technical differences between related topics such as continuous integration, continuous deployment, and continuous delivery. At the heart of the workshop is a pattern called the deployment pipeline, which involves the creation of a living system that models your organization's value stream for delivering software. I discuss the various stages, how triggering works, patterns and anti-patterns, and how to pragmatically determine what “production ready” means. This session also covers some agile principles espoused by the Continuous Delivery book, including new perspectives on things like developer workstations and configuration management.

Continuous Delivery relies on a variety of interlocking engineering practices to work efficiently; this session covers three related topics. First, I cover the role of testing and the testing quadrant. Second, I specifically cover version control usage and offer alternatives to feature branching like toggle and branch by abstraction. Third, I describe some incremental release strategies, along with their impact on other stages of project lifecycle.

Releasing software to actual users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours—sometimes even minutes—no matter what the size of a project or the complexity of its code base. The workshop materials are derived from the best selling book Continuous Delivery and creating in collaboration with the authors and other of my ThoughtWorks colleagues. Continuous Delivery details how to get fast feedback on the production readiness of your application every time there is a change—to code, infrastructure, or configuration.

Continuous Delivery relies on a variety of interlocking engineering practices to work efficiently; this session covers three related topics. First, I cover the role of testing and the testing quadrant, including the audience and engineering practices around different types of tests. I also cover some best practices around testing, including testing ratios, code coverage, and other topics. Second, I specifically cover version control usage and offer alternatives to feature branching like toggle and branch by abstraction. Generally, I talk about building synergistic engineering practices that complement rather than conflict one another. In particular, I discuss why feature branching harms three other engineering practices and describe alternatives. Third, I describe some incremental release strategies, along with their impact on other stages of project lifecycle.

Two big stumbling blocks for Continuous Delivery adaptation are interactions with operations and the keepers of data. First in this session, I cover operations, DevOps, and programmatic control of infrastructure. Second, I discuss how to incorporate databases and DBA's into the Continuous Integration and Continuous Delivery process.

Releasing software to actual users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours—sometimes even minutes—no matter what the size of a project or the complexity of its code base. The workshop materials are derived from the best selling book Continuous Delivery and creating in collaboration with the authors and other of my ThoughtWorks colleagues. Continuous Delivery details how to get fast feedback on the production readiness of your application every time there is a change—to code, infrastructure, or configuration.

Two big stumbling blocks for Continuous Delivery adaptation are interactions with operations and the keepers of data. First in this session, I cover operations, DevOps, and programmatic control of infrastructure using tools like Puppet and Chef. I also discuss the explosion of tool alternatives in this space, and cover some current-day best practices. Second, I discuss how to incorporate databases and DBA's into the Continuous Integration and Continuous Delivery process. This includes database migrations, strategies for enhancing collaboration between application development and data, and database refactoring techniques.

Successful projects require any number of practices but if you don't know who you're building it for or what you're supposed to build, failure is a distinct possibility. How do we capture the who and what? Personas and story maps are two effective techniques that you can leverage. After discussing the basics, we'll break into small groups and you'll have a chance to actually try building a set of personas as well as a story map.

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.

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.

Back in the day, web developers had to rely on their wits and a plethora of alert statements - to say our toolkit was spartan would be an understatement. But with the increased importance of web front ends and the rise of JavaScript MVC frameworks, a modern web developer toolkit is finally emerging.

We've evolved from text editors to full fledged IDE's with code completion and refactoring tools but our toolchain doesn't end there. With multiple testing libraries, mocking frameworks, test drivers and even code coverage tools, today's web developer gets to walk downhill on a sunny day.

This session explores how NoSQL solutions like MongoDB, Cassandra, Neo4j, HBase and CouchDB can be used in a Java EE application with or without a JPA centric facade.

Although the primary focus is on EclipseLink NoSQL, we will also cover Hibernate OGM, EasyCassandra, Morphia, etc as well as seeing how NoSQL can be used natively via basic CDI injection.

Developers are flocking to client side frameworks and, as a result, there are more and more JavaScript libraries attempting to solve the rich internet application problem. In a space where new libraries seem to spring up weekly, what framework should you choose for your next project? While there is consensus around basic ideas like Model View Whatever, there are some strong philosophical differences amongst the various libraries. In this talk, we'll look at the similarities and the differences of some emerging JavaScript libraries discussing why you need to be aware of this rapidly evolving aspect of software development.

Developers are flocking to client side frameworks and, as a result, there are more and more JavaScript libraries attempting to solve the rich internet application problem. In a space where new libraries seem to spring up weekly, what framework should you choose for your next project? While there is consensus around basic ideas like Model View Whatever, there are some strong philosophical differences amongst the various libraries. In this talk, we'll look at the similarities and the differences of some emerging JavaScript libraries discussing why you need to be aware of this rapidly evolving aspect of software development.

Becoming more agile

Becoming more agile

Gradle has fast become one of the de-facto build tool in the Java ecosystem. Gradle offers a powerful DSL to configure your builds. Whether you have a simple build, or a complex build with many moving parts, Gradle's DSL and extensible API can help you make your builds easier, and possible.

In this sessio we will start from the ground up. We will write our first Gradle script and examine Gradle's configuration vs. execution phases. We will see how Gradle uses plugins to add on functionality for free to your build and end with a look at the Gradle Plugin API to see how easy it is to write your own plugins for better reuse.

Gradle has fast become one of the de-facto build tool in the Java ecosystem. You might have used Gradle to build your project without realizing how much more Gradle has to offer. Up-to-date checking, automatic clean, file operations such as copy, move and zip and so much more are just some of the features that Gradle offers right out of the box.

In this session we will explore some of these features and how we can use them within our own builds.

In this session we will look to see how we can refactor our learning - what tools, and methodologies can we use to help us learn quicker and better - how we can create a store that gives us quick access to information when we really need it.

We all work in an industry in which not only do the tools that we use change ever few years, but one in which we have to shift the very paradigms these tools are built on! Even the most trivial of projects entails tens of different toolkits, frameworks, and languages coming together, and somehow we need to know how to leverage each one. How does one keep up? Despite all our years in schools, and our in-born nature to learn, we often are never taught how to learn. How can we learn faster, and retain even more?

In this session we will take a look at various tools and techniques available to us and see how we can make our learning effective.

Find yourself overwhelmed with hundreds of to-dos? Is your hard-drive littered with dozens of killer ideas that you started with enthusiasm and then just fizzled away? Do you feel like you are moving as fast as can but only getting to the wrong place quicker? Well perhaps this session will help.

There are various techniques and strategies available to us today that aim to help with exactly this conundrum - from Getting Things Done ™ to Personal Kanban. Unfortunately it is often easy to be extremely productive using these systems, but not very effective. After all, it's not about getting things done, but getting the RIGHT things done. In this talk we will discuss not only how to get things done, but also attempt to figure out what it is you actually need to be doing.

In this session, I will attempt to show you how you can leverage various strategies to be more effective, knock to-dos out and have fun while doing it. If time permits we will close with an overview of the tools that are available to you, and how you can use these to become a to-do list ninja :)

cloud architecture… an architectural walk through cloud services and components

high level
Data Centers / VDC
CDN
Monitoring
Load Balancing
Queue
Storage (s3, etc)
DNS
Search
Routing
(Amazon + Open Source) example: CloudSearch vs ElasticSearch
Security

low level
HAProxy
Nerve
synapse
queues
compute
dns

cloud architecture… an architectural walk through cloud services and components

high level
Data Centers / VDC
CDN
Monitoring
Load Balancing
Queue
Storage (s3, etc)
DNS
Search
Routing
(Amazon + Open Source) example: CloudSearch vs ElasticSearch
Security

low level
HAProxy
Nerve
synapse
queues
compute
dns

There is nothing better than looking at real-world examples to understand project failures and project successes. This session is intended to be an open conversation, based closely to a birds of a feature (BOF) session, however it will have a series of “that happened to me” topics throughout discussed from the perspective of technology.

Discussed will be a clients dating back from 2005. The actually client and there name will not be revealed, but the industry, the contraints and some of the outcomes will.

As Tech Leaders, we are presented with problems and work to find a way to solve them, usually through technology. In my opinion this is what makes this industry so much fun. Let's face it - we all love challenges. Sometimes, however, the problems we have to solve are hard - really hard. So how do you go about solving really hard problems? That's what this session is about - Heuristics, the art of problem solving. In this session you will learn how to approach problems and also learn techniques for solving them effectively. So put on your thinking cap and get ready to solve some easy, fun, and hard problems.

Agenda:

• the checklist
• visual representations
• you know what happens when you assume…
• you gotta start somewhere
• the world is flat
• hey! keep it clean!
• perception can be reality