Cloud continues to grow in importance in even the most conservative companies’ IT strategies. Because of this, even experienced software architects must confront a new world in which many of our normal architectural assumptions no longer hold. Before we create architectures that leverage cloud infrastructure, we need to rebuild our mental model of infrastructure around the appropriate concepts and principles. The purpose of this session is to do just that.

In this session we’ll:

• tour the current cloud infrastructure landscape
• explore the key business and technology motivators for adopting cloud
• explore the unique aspects of cloud infrastructure that violate our traditional assumptions
• examine the risks associated with adopting cloud infrastructure
• navigate some of the key tradeoffs involved with cloud architecture choices
• overlay traditional architecture patterns and examine their suitability to cloud
• define a cloud native architecture that is optimized to exploit the uniqueness of the cloud environment

The learner should leave this session prepared for deeper dives into cloud native architecture patterns and migration strategies.

NOTE: We'll cover roughly 50% of the material in Part 1.

Cloud continues to grow in importance in even the most conservative companies’ IT strategies. Because of this, even experienced software architects must confront a new world in which many of our normal architectural assumptions no longer hold. Before we create architectures that leverage cloud infrastructure, we need to rebuild our mental model of infrastructure around the appropriate concepts and principles. The purpose of this session is to do just that.

In this session we’ll:

• tour the current cloud infrastructure landscape
• explore the key business and technology motivators for adopting cloud
• explore the unique aspects of cloud infrastructure that violate our traditional assumptions
• examine the risks associated with adopting cloud infrastructure
• navigate some of the key tradeoffs involved with cloud architecture choices
• overlay traditional architecture patterns and examine their suitability to cloud
• define a cloud native architecture that is optimized to exploit the uniqueness of the cloud environment

The learner should leave this session prepared for deeper dives into cloud native architecture patterns and migration strategies.

NOTE: We'll cover roughly 50% of the material in Part 1. If you come to only Part 2, we'll be starting in the middle.

Now that we’ve been equipped with an understanding of how software architectures can exploit the unique aspects of cloud infrastructure environments, it’s time to construct a pattern catalog that can guide our decision making as we journey from concepts and principles to concrete implementations. The software industry has long been motivated by the promise of a “component marketplace” from which we can draw commodity components which can be composed via standardized mechanisms to create powerful systems. These systems are often compared to the myriad of possible creations that can be produced using Lego pieces. The power in the Lego “architecture” is found in the amazing diversity of individual pieces that are composed via a universal system of compatibility. Cloud native architectures approximate the same power via Lego-like patterns.

In this two-part series, we’ll divide the cloud native patterns into two categories:

1. Bricks - how we design cloud native services
2. Mortar - how we compose cloud native systems

In part one we’ll study “Brick Patterns” from the following categories:

• Externalized Configuration
• Externalized State
• Externalized Channels
• Runtime Reconfiguration
• Continuous Delivery via Multi-Version Concurrent Execution
• Brick Telemetry

The learner should leave this session prepared to design and implement cloud native “bricks” that can be composed via any “master builder” of cloud native solutions.

Now that we’ve been equipped with an understanding of how software architectures can exploit the unique aspects of cloud infrastructure environments, it’s time to construct a pattern catalog that can guide our decision making as we journey from concepts and principles to concrete implementations. The software industry has long been motivated by the promise of a “component marketplace” from which we can draw commodity components which can be composed via standardized mechanisms to create powerful systems. These systems are often compared to the myriad of possible creations that can be produced using Lego pieces. The power in the Lego “architecture” is found in the amazing diversity of individual pieces that are composed via a universal system of compatibility. Cloud native architectures approximate the same power via Lego-like patterns.

In this two-part series, we’ll divide the cloud native patterns into two categories:

1. Bricks - how we design cloud native services
2. Mortar - how we compose cloud native systems

In part one we’ll study “Mortar Patterns” from the following categories:

• Service Discovery
• Edge Gateways
• Fault Tolerance
• Event-Driven Systems
• Contract Management
• Integration Telemetry

The learner should leave this session prepared to compose cloud native solutions from any available collection of cloud native “bricks.”

If you’ve been following along, you’ve realized by now that cloud native architectures are fundamentally different than most traditional architectures. Most of the cloud native architectures that we can see in the wild have been built by relatively young companies that began from a zero-legacy state. Architects in more mature organizations are faced with the daunting challenge of building modern systems that exploit the unique characteristics of cloud infrastructure while simultaneously attempting to migrate legacy systems into those same environments, all the while “keeping the lights on.”

Much of the last two years of my career have been spent helping Fortune 500 companies devise cloud native migration strategies, and I’ve built a increasingly large catalog of patterns that have proven useful across multiple systems and industry verticals. In this session we’ll dive into those patterns and more, including:

• the utility of cloud native maturity models
• the cloud continuum: cloud ready, cloud friendly, cloud resilient, cloud native
• the app continuum: evolving toward distributed systems
• criteria for selecting applications to migrate
• the occasionally palatable perils of “lift and shift”
• applying the Strangler Pattern
• leveraging strategic domain-driven design: bounded contexts, context maps, and anti-corruption layers
• insulating from “irreplaceable” legacy systems of record with hexagonal architecture

The learner should leave this session with a tool belt suitable for attacking an upcoming cloud native architecture migration effort.

In this presentation, we'll build, test, and deploy an image-processing pipeline using Amazon Web Services such as Lambda, API Gateway, Step Functions, DynamoDB, and Rekognition.

We'll take a look at some of the following topics:

• Describing serverless deployments with SAM
• Testing lambda functions with SAM Local
• Interacting with AWS API's from lambda functions
• Configuring IAM policies for lambda functions
• Describing workflows of functions with Step Functions
• Deploying with Cloud Formation

On the 2017 tour, I introduced the notion of “serverless” and Functions as a Service (FaaS) platforms. We understood the motivation for serverless computing, compared serverless to other cloud-native infrastructure approaches, navigated some architectural tradeoffs, and took a whirlwind tour of the Big 3 FaaS providers.

In this 2018 edition of the talk, we’ll still cover a few of the same themes to bring new folks up to speed, but we’ll also look at what’s changed in this ecosystem over the past year, take a look at new or enhanced features, offerings, runtimes, and programming models, and examine what use cases are becoming popular for serverless computing. We’ll also look at how tradeoffs have evolved, and definitely throw in a few demos.

JavaScript is a very powerful and ubiquitous language. At the same time, it is also a language that is often misunderstood and misused. Better quality code greatly reduces the effort and time to maintain software. So, there is a good incentive to improve quality of code.

In this presentation we will cover two things. We will discuss dos and don'ts for programming with JavaScript. Then we will look at a set of tools that can help keep an eye on our code and prompt us to improve the quality.

We can often easily tell when the performance of the code is poor, but, it is not easy to figure out where things are going wrong. Guessing where the problem may be is not only frustrating, but also may keep us away from the real problem area.

In this presentation we will take a look at tools that can help us to gain useful insights into the performance of client side code and identify issues in a more intelligent manner.

Tools/libraries/frameworks that rely on modern JavaScript heavily make use of metaprogramming capabilities that is relatively new in the language.

In this presentation we will learn about the metaprogramming API, the benefits it provides, and how to benefit from this programming facility.

Reactive Programming in gaining a lot of excitement. Many libraries, tools, and frameworks are beginning to make use of reactive libraries. Besides, applications dealing with big data or high frequency data can benefit from this programming paradigm. Come to this presentation to learn about what reactive programming is, what kind of problems it solves, how it solves them. We will take an example oriented approach to learning the programming model and the abstraction.

Reactive Programming
Nature of Problems
Programming API
The Reactive Programming Abstraction
Examples

Big data applications have entire different demands than typical CRUD applications that have ruled the enterprise for decades. When dealing with high frequency and high volume of data, we have to reach to a different set of tools than we have been used to.

The objective of this presentation is to first discuss the issues with dealing with big data and high performance computing. Then we will take a look at libraries and tools that can more easily help us address those issues.

Distributed and parallel computing have been around for a while. The problem is not new, but solutions have generally been complex. Over the years several solutions have come along to ease the pain. Spark is a wonderful programming API and a tool that can ease the pain of creating distributed, high concurrent, performing code.

In this presentation we will take an example oriented approach to creating applications that make use of Spark. We will learn how to create the code to use Spark, how to configure and manage the number of threads, and how to distribute the computations.

Every developer takes pride in the code they write, as they should. But, we know not all code are created equal. Not all of us create good quality code all the time. So, putting aside personal biases, how can we measure the quality of code.

In this presentation we will look at both qualitative metrics and also quantitative metrics and tools that can benefit software developers create maintainable better quality code.

In this example-driven presentation, you'll learn how to leverage Spring Boot to accelerate application development, enabling you to focus coding on logic that drives application requirements with little concern for code that satisfies Spring's needs.

For over a decade, Spring has sought to make enterprise Java development easier. It began by offering a lighter alternative to EJBs, but continued to to address things such as security, working with various sorts of databases, cloud-native applications, and reactive programming. And, along the way, Spring even took steps to make itself easier to use, offering Java-based and automatic component configuration. Even so, there's still a lot of near-boilerplate code required to develop Spring applications.

Enter Spring Boot. Spring Boot's primary purpose is to make Spring easier to work with. It achieves this in three ways:

• Automatic configuration : Considering what's on the runtime classpath as well as other factors, Spring Boot can automatically configure components in a Spring application context.
• Simplified dependency management : Taking advantage of transitive dependency resolution at build-time, Spring Boot offers several “starter” dependencies, focused on specific characteristics of an application, that transitively bring in libraries to enable development of those characteristics.
• Runtime insight : Spring Boot offers insight into the inner workings of a running application via REST endpoints and/or JMX MBeans to better understand what makes a running application tick.

All together, Spring Boot lets you focus on fulfilling your application's requirements without worrying about writing code that satisfies the needs of a framework.

In this session, you'll learn how to take your Spring Boot skills to the next level, applying the latest features of Spring Boot. Topics may include Spring Boot DevTools, configuration properties and profiles, customizing the Actuator, and crafting your own starters and auto-configuration.

TBD

In this session, you'll learn how to use Spring Data to rapidly develop repositories for a variety of database types, including relational (JPA and JDBC), document (Mongo), graph (Neo4j), and others (Redis, Cassandra, CouchBase, etc).

For decades, relational databases and SQL have enjoyed their position as the leading choice for data persistence. Even though many alternative database types have emerged in recent years, the relational database is still a top choice for a general purposes data store and will not likely be usurped from its position any time soon. When it comes to working with relational data, Java developers have several options.

But relational databases are not a one-size-fits-all solution. Thankfully, there are many options for data persistence, including relational, document, graph, key-value, and column-store databases, each presenting their unique way of handling data suitable for different problems.

Spring Data makes it easy to work with various databases by offering a programming model that is consistent, regardless of which type of database you're working with. And regardless of the database you're dealing with, you will find that Spring Data eliminates a lot of boilerplate code.

In this session, you'll see how to take Spring Data's automatic repository generation to a whole new level. We'll look at ways to model data and manipulate Spring Data to produce repositories and APIs that are more than just CRUD layers on top of a database.

TBD

Kafka has captured mindshare in the data records streaming market, and in this presentation, we knock on its door and see what lies behind. What is the draw? What makes it an attractive addition? How does it compare to Message Queues and other message streaming services?

We will do a thorough introduction into what is Kafka. We will also discuss Consumers, Producers, Streams. Integration with ZooKeeper, and discuss the performance aspect of using Kafka.

Java 8 is pretty great, but mix in JavaSlang (now called Vavr) and get ready for some functional programming excitement.

JavaSlang is a project that decorates Java with immutable data structures, better Optionals, tuples, and more. Now with JavaSlang (Vavr) we can really bring in some more power to functional programming and Java. We will even discuss some new concepts like for comprehensions, Try, and Either!

Rich Hickey once said programmers know the benefits of everything and the trade offs of nothing…an approach that can lead a project down a path of frustrated developers and unhappy customers. As architects though, we must consider the trade offs of every new library, language, pattern or approach and quickly make decisions often with incomplete information. How should we think about the inevitable technology choices we have to make on a project? How do we balance competing agendas? How do we keep our team happy and excited without chasing every new thing that someone finds on the inner webs?

As architects it is our responsibility to effectively guide our teams on the technology journey. In this talk I will outline the importance of trade offs, how we can analyze new technologies and how we can effectively capture the inevitable architectural decisions we will make. I will also explore the value of fitness functions as a way of ensuring the decisions we make are actually reflected in the code base.

Development teams often focus on getting code to production losing site of what comes after the design and build phase. But we must consider the full life cycle of our systems from inception to deployment through to sunset, a discipline many companies refer to as site reliability engineering.

While your organization may or may not have an SRE team, you have someone playing that role and we can all benefit from looking at the principles and practices that we can bring to bear on our projects. In this talk, I will introduce the concepts of SRE and how you can adopt these ideas on your applications.

By now I bet your company has hundreds, maybe thousands of services, heck you might even consider some of them micro is stature! And while many organizations have plowed headlong down this particular architectural path, your spidey sense might be tingling…how do we keep this ecosystem healthy?

In this talk, I will go beyond the buzzwords into the nitty gritty of actually succeeding with a service based architecture. We will cover the principles and practices that will make sure your systems are stable and resilient while allowing you to get a decent night's sleep!

Back in the day, it used to be so simple. Our projects had a main.js file that contained a few hundred lines and every so often the corporate communication department would ship out some new CSS files. But now things are not quite so easy. With more and more single page apps containing thousands or hundreds of thousands of lines of JavaScript, we're going to need a bigger boat.

In this talk I will explore various options you can deploy on your projects to tame the mass of code that lives on the front end of our applications. From NPM to Gulp to Webpack, this talk will help you establish a front end pipeline.

By the end of this conference you will have learned many new tools and technologies. The easy part is done, now for the hard part: getting the rest of the teamand managementon board with the new ideas. Easier said than done.

Whether you want to effect culture change in your organization, lead the transition toward a new technology, or are simply asking for better tools; you must first understand that having a “good idea” is just the beginning. How can you dramatically increase your odds of success?

You will learn 12 concrete strategies to build consensus within your team as well as 6 technique to dramatically increase the odds that the other person will say “Yes” to your requests.

As a professional mentalist, Michael has been a student of psychology, human behavior and the principles of influence for nearly two decades. There are universal principles of influence that neccessary to both understand and leverage if you want to be more effective leader of change in your organization.

In this session we discuss strategies for getting your team on board as well as when/how to approach management within the department and also higherup in the organization.

In Part 1, you learned the core principles of influence and persuasion. How to we take this back to the office and apply what we've learned?

We dive deep in to specific strategies to get both the team and the business on board with your ideas and solutions. We cover several realworld patterns you can follow to be more effective and more persuasive. Part 1 was conceptual, part 2 is practical.

On the NFJS tour, there are questions that seem to come up again and again. One common example is “How do we determine which new tools and technologies we should focus our energy on learning?” another is “How do we stop management from forcing us to cut corners on every release so we can create better and more maintainable code?” which, after awhile becomes “How can we best convince management we need to rewrite the business application?”

There is a single metaanswer to all these questions and many others.

It begins with the understanding that what we as engineers value, and what the business values are often very different (even if the ultimate goals are the same) By being able to understand these different perspectives it's possible to begin to frame our arguments around the needs and the wants of the business. This alone will make any engineer significantly more effective.

This session picks up from where “Stop writing code and start solving problems” stops discussing what is value, how do we align the values of the business with the needs and values of the engineer.

Think back over your career as a software developer. How many great–and I mean truly great–software developers have you worked with? The chances are you can count them on one hand? Developers with 20-30 years experience can rarely name more than two or three. What does it take to be considered truly great? Michael can certainly tell you what NOT to do… from cold, bitter experience.

Ego Driven Development is a humorous and brutally honest look at a career spanning nearly two decades. We dive into war stories, train wrecks and so many misguided attempts at greatness. There is a path to becoming a truly great software engineer, but it's not always where we first look.

This session covers two critical soft skills for architects:

• creating clear, concise documentation of software architecture, both structure and decisions
• presenting architectural ideas as clearly as possible

New architects find soft skills like creating lucid documentation and building compelling presentations challenging. This presentation covers a variety of ways to document ideas in software architecture, ranging from diagramming techniques (that aren't UML) to Architecture Decisions Records and ultimately to presentations. The second part of the talk leverages patterns and anti-patterns from the Presentation Patterns book to help architects build clear and concise representations of their ideas.

Stories and lessons from architecture, design, process, and other sources, each illustrating important principles and pitfalls for modern architects.

Those who cannot remember the past are condemned to repeat it.  –George Santayana

The past is never dead. It's not even past. –William Faulkner

Most developers pursue the Latest and Greatest with intense fervor, yet the history of engineering, including software projects, contains rich lessons that we risk repeating ad nauseam. This session recounts a variety of stories of projects that failed architecturally…and why. Ranging from the Vasa in 1628 to Knight Capital in 2012, each story tells of a mistaken interpretation of some architectural fundamental principle and the consequences–some good, some less so. I I also look at the common threads for these stories, which resonates with problems many companies have but don't realize.

• Pets. Com
• San Francisco project
• The Vasa
• F16
• Sagrada Familia
• Tacoma Narrows Bridge
• null
• Ada
• Serialization
• Knight Capital
• Ariane 5
• Webvan
• Chandler project

Prerequisite: If you are unfamiliar with Kubernetes be sure to attend: Kubernetes Koncepts (1 of 2)

Aha moments with apps in containers can be quite liberating. The mobile space is saturated with “there's an app for that”. For us, we now expect “there's a container for that”. “Write once, run anywhere” (WORA) has changed to “Package once, run anywhere” (PORA). The growing community of containers is riding up the hype curve. We will look at many ways to assemble pods using architecture patterns you already know.

Your software package delivery and installation is no longer an rpm, deb, dmg, jar, war, native executable or a run script, it is simply an image that has a common run container command.

During the presentation, we will explore some examples on Katacoda.

Prerequisite: If you are unfamiliar with Kubernetes be sure to attend: Kubernetes Koncepts

At the 2009 Agile conference, J.B.Rainsberger declared “Integration tests are a scam”. I agree. Come see some compelling reasons why consumer-driven contract testing is a much better approach. Particularly for microservices.

We will explore different testing techniques on Kubernetes, including an important one called “Consumer-Driven Contracts”.

After a brief overview of the concepts a live demonstration will show you how to:

1. set up a Pact Broker on Kubernetes
2. write a consumer that defines and publishes Pact contracts
3. deploy and run a few Spring Boot microservices on Kubernetes
4. connect microservices to a database and public data source
5. verify the consumer pacts against a producer
6. find API defects and fix them

This is the droid you are looking for. Within this droid are hundreds of rules designed to review your code for defects, hotspots and security weaknesses. Consider the resulting analysis as humble feedback from a personal advisor. The rules come from your community of peers, all designed to save your butt.

We will explore techniques on how to add these checks to your IDE, your build scripts and your build pipelines.

Too much chatter in your pull requests? See how the analysis tools teach best practices, without ego or criticism, to a spectrum of developers. As a leader see how to develop an effective code quality intern program around this technique. We will also see some techniques to use Kubernetes to obtain reports and dashboards right on your local machine and from your continuous integration pipeline.

You have some modular code with a REST API. You are on your way to Microservices. Next, you package it in a container image that others can run. Simple. Now what? Your service needs to log information, needs to scale and load balance between its clones. Your service needs environment and metadata way outside its context. What about where the service will run? Who starts it? What monitors its health? What about antifragility? Updates? Networking? Oh my.

Don't get flustered. We will explore how Kubernetes simplifies the complexity of distributed computing.

This session will help you understand the terms, architecture and the mechanics of the Kubernetes tools. You will understand how to target your applications to a seemingly complex distributed compute platform.

In this session we will take a look at building applications with Angular. We will build a very simple application from the ground up, and attempt to understand the approach of Angular, as well as understand some of the terminology that Angular introduces.

This session will focus on the Angular 10

TypeScript, Components, Annotations/Directives, Observables, Reactive Stores, Model-Driven forms … Oh my! Angular, much like AngularJs (1.x.x), despite being a powerful platform for building rich client side applications, comes laden with both new terminology, and a “newer” approach to writing client side code.

In this session, as we build a simple application, we will attempt to tease apart these concepts, slowly building our understanding towards how these pieces come together, and how we can leverage them to build rich client side application.

Details

• Quick overview of what Angular has to offer, how it is different from Angular 1.x
• A glance at the project we are going to build, and all the important files that angular-cli generates
• Create our first component
• Proceed with creating a component hierarchy to display all hard coded data

Along the way we will see how to use the Angular style guide to follow conventions adopted by the Angular community at large, and some ways to use the angular-cli tool.

In this session we will take a look at building applications with Angular. We will build a very simple application from the ground up, and attempt to understand the approach of Angular, as well as understand some of the terminology that Angular introduces.

This session will focus on the Angular 10

TypeScript, Components, Annotations/Directives, Observables, Reactive Stores, Model-Driven forms … Oh my! Angular, much like AngularJs (1.x.x), despite being a powerful platform for building rich client side applications, comes laden with both new terminology, and a “newer” approach to writing client side code.

In this session, as we build a simple application, we will attempt to tease apart these concepts, slowly building our understanding towards how these pieces come together, and how we can leverage them to build rich client side application.

Details

• Using in-build pipes in Angular
• Create our own pipe
• Create the necessary infrastructure to allow for HTTP Calls to the backend
• Load all the containers using Ajax
• Introduces routing, and update the homepage to navigate to these routes

Along the way we will see how to use the Angular style guide to follow conventions adopted by the Angular community at large, and some ways to use the angular-cli tool

In this session we will explore the router that ships with Angular. We will see how to leverage its power and flexibility to build real world applications.

Angular ships with a powerful new router. One that allows you to manage your application state, allow for things like nested and child views, as well as loading modules on demand. If you have complex workflows and you wish to learn the new way of navigating your Angular application, this is the session for you.

In this session we will explore how the dependency injector works in Angular2.

Angular has always leverages DI, and along with all the benefits that come with DI. In Angular2 (much like Angular1) there is no escaping the dependency injection mechanism. Though like everything else in Angular2, there is more here than meets the eye. We will take a deep dive into Angular's DI in this session, first seeing some of the benefits of DI, and some of the gotchas

In this session we will get acquainted with Docker. We will discuss what docker is, how to install it, and how to start using Docker. We will also explore some of the benefits of containerizing your applications.

Containers are taking over the world. Containers provide a means to have hermatic builds of your software, allowing for truly immutable testing, and delivery of your software. Docker is one of many containerization technologies, and in this session we will take a brief look at Docker and what it has to offer.

In this session we will dive deeper into Dockerfiles. We will explore the DSL that Dockerfiles provide to allow for the automation of image creation.

Dockerfiles provide a means to automate the creation of images, and consequently the containers within which our applications run. The Dockerfile, though minimal, provides us with everything we need to package our software, and enable it to run. In this session we will dive deep into the Docker DSL, and explore the many commands that it provides, and along the way explore some differences between similar commands, and some gotchas.

Machine Learning is a huge, deep field. Come get a head start on how you can learn about how machines learn.

This talk will be an overview of the Machine Learning field. We’ll cover the various tools and techniques that are available to you to solve complex, data-driven problems. We’ll walk through the algorithms and apply them to some real but accessible problems so you can see them at work.

This open source machine learning framework from Google has taken off. Come learn what you can do with it in your own organization.

TensorFlow is a powerful data flow-oriented machine learning framework developed by Google's Brain Team. It was designed to be easy to use and widely applicable on both numeric, neural network-oriented problems as well as other domains. We'll cover the over view as well as apply it to several fun, realistic problems.

Encryption is great, especially when it works.

You put a lot of trust that the encryption offered by browsers, frameworks and libraries is giving you the protection you need to exchange sensitive information over the web. E-commerce, remote shells, bearer token-based authorization schemes and more would not be possible without technologies like the Transport Layer Security (TLS). Come listen to how it works, how it breaks and how you can become more confident that it does what you think it does.

For the last 20-30 years, there has been a never-ending set of solutions for building cross-platform desktop applications. Most of them suck. Electron is one that doesn't.

It is a new solution that forms the basis of the Atom Editor, Microsoft's Visual Studio Code, the Slack app and more.

Come see what happens when you combine the best of the Web, Node.js and Chromium to provide attractive, modern, flexible, useful, consistent cross-platform desktop applications.

Electron grew out of the work on the Atom Editor from GitHub. Developers familiar with JavaScript, Node and Web Development will be comfortable with an engine that uses the same technologies as they move to the Desktop. At the same time, the Chromium engine, which has support for modern technologies such as WebGL, WebRTC and desktop-integration hooks, as well as HTML 5 and CSS, rounds out the platform. The strength of the Web mixed with native desktop integration hooks and the performance and flexibility of Node strikes the right balance for avoiding sucky cross-platform applications.

What happens if web applications got really fast?

We are increasingly able to do more in the browser because of faster networks, optimized JavaScript engines, new standard APIs and more. There is a new initiative to allow a binary format called WebAssembly that will provide a compiled, cross-platform representation that will take us to the next level. Complex business applications and 3D video games will alike will benefit from this new standard. Come hear about what it can do for you.

Hypothesis and data driven development ties together current thinking about requirements, Continuous Delivery, DevOps, modern architecture, and engineering techniques to help rethink building software.

Agile development claims to abhor “Big Design Up Front”…yet what is that giant backlog building session but BDUF in other clothing? Back in the olden days of software development, we were forced to speculate on what users want, then build it. We were basically running a buffet. But what if we could switch to à la carte? With modern engineering practices like Continuous Delivery, we can shift our perspective and start building by hypothesis rather than speculation. This talk shows the full spectrum of software development, from ideation through execution and deployment, through the lens of modern software engineering practices. I discuss building a platform using feature toggles, canary releases, A/B testing, and other modern DevOps tools to allow you to run experiments to see what your users really want. By building a platform for experimentation, product development shifts from up-front guessing to market driven. This talk unifies the practices of modern architecture, DevOps, and Continuous Delivery to provide a new approach to feature development. This talk also demonstrates how to undertake major architectural restructuring with zero regression failures by relying on data and the scientific method.

An evolutionary architecture supports incremental, guided change along multiple dimensions.

For many years, software architecture was described as the “parts that are hard to change later”. But then microservices showed that if architects build evolvability into the architecture, change becomes easier. This talk, based on my upcoming book, investigates the family of software architectures that support evolutionary change, along with how to build evolvable systems. Understanding how to evolve architecture requires understanding how architectural dimensions interact; I describe how to achieve appropriate coupling between components and services. Incremental change is critical for the mechanics of evolution; I cover how to build engineering and DevOps practices to support continuous change. Uncontrolled evolution leads to undesirable side effects; I cover how fitness functions build protective, testable scaffolding around critical parts to guide the architecture as it evolves.

The software development ecosystem exists in a state of dynamic equilibrium, where any new tool, framework, or technique leads to disruption and the establishment of a new equilibrium. Predictability is impossible when the foundation architects plan against changes constantly in unexpected ways. Instead, prefer evolvability over predictability. This keynote illustrates how to achieve evolutionary architectures and how to retrofit existing systems to support better evolution.

Understand Java from a functional programming point of view. This part covers the basics of lambdas and streams, emphasizing functional programming by transforming collections using the stream approach.

Also includes method references and static and default methods in interfaces.

Functional features in Java, including parallel streams, the java.util.function package, the Optional data type, and reduction operations.

The talk also covers the new date and time package based on Joda time, as well as collectors and implementing the Collector interface.

Java SE 8 introduces many new features that can simplify your code. Using streams, lambdas, and the new Optional type all change the way we write Java. In this presentation, we'll work through a series of examples that show how to rewrite existing code from Java 7 or earlier using the new Java 8 approach.

Examples will include replacing anonymous inner classes with lambdas, switching from iterating over collections into transforming streams, using immutables wherever possible, lazy evaluation, and more.

Java is now on a six-month release schedule, with new features being added all the time. This talk summarizes the features that have been added to Java, including collection factory methods, private methods in interfaces, records, the enhanced switch statement, and more. The goal is to show not only what has been added, but why and where to use them.

Additional topics will include Local Variable Type Inference, the new HTTP client, the pattern matching, and text blocks. This talk will be updated throughout the year as more features are added to new releases.

Continuous delivery is not a pipe-dream technology, reserved only for the “cool kids” at hip tech startups. Although it's not easy, many concepts are within reach of most teams. That being said, it require more than simple technology changes. Attend this session to learn the fundamental concepts of CD, how to build your CD pipeline with Gradle and Jenkins, and recommendations on tools and best practices.

No prior knowledge is assumed and this talk will start from first principles.

Part one begins with a detailed overview of what CD is (and isn't) and how to build a business case for CD. Making both the technical case and business case for CD is vital as it's necessary to get the entire organization on board with the changes required.

Part two is a deeper dive into building a continuous delivery pipeline with Gradle and Jenkins (although the broader concepts can be applied to the tooling of your choice) You'll see how easily Gradle integrates with Java and how to leverage configuration management and gradle plugins to build all of your quality gates.

Gradle is the build tool of choice in the open source world, and rapidly becoming the standard in industry as well. Anyone who works with Gradle on a Java project knows the basics of the Java plugin and how to write simple tasks in Groovy. Gradle can do much more, however. This talk will demonstrate how to write your own custom task classes and how to create Gradle plugins from them. Other Gradle features will be demonstrated as well, including file manipulation, incremental builds, generating the Grade wrapper, and resolving conflicts in dependencies.

Gradle Inc also provides a free build scan capability to analyze build files. This too will be demonstrated, as well as profiling your build, determining dependencies, and more.

Serialization is important for anything Big Data. We need to send information over the wire and we need to do so efficiently. This core concept presentation covers various serialization techniques and libraries. That way you can use Akka, Kafka, Spark, and various MQs efficiently

For this presentation, we will focus on three topics: Core Java Serialization, Apache Avro, and Google's Protocol Buffers. We will review serialization and deserialization ease of use, review performance, and how to integrate with Akka, Kafka, Spark.

Many have already seen what Reactive Streaming can do: RXJava, Akka Streams, Project Reactor. Now reactive streaming is a part of the canonical package for Java and now we can handle asynchronous pipelines with boundaries and make better well thought out applications

This presentation introduces you to the core components of Reactive Streams: Publisher, Subscriber, and Processor. We will discuss when to use Reactive Stream and how to avoid complicated scenarios like Backpressure. We will also cover some of the core problem spaces and how to overcome.

This session we discuss Akka/HTTP which wraps around the Akka's actor systems and Akka reactive streams to create scalable and resilient RestFUL web services.

Akka/HTTP is a full stack client and server API to produce and consume HTTP services. In this session, we discuss the philosophy of Akka/HTTP, setup, and some common approaches. This presentation will be presented in both Scala and Java.

If you’ve spent any amount of time in the software field, you’ve undoubtably found yourself in a (potentially heated) discussion about the merits of one technology, language or framework versus another. And while you may have enjoyed the technical debate, as software professionals, we owe it to our customers (as well as our future selves) to make good decisions when it comes to picking one technology over another.

In this talk, I will explore what criteria we should consider when comparing technologies, how we can avoid burning platforms as well as what to do when we’ve reached a dead end. We will also apply these techniques to a current technology or two.