Reactive architecture patterns allow you to build self-monitoring and self-healing systems that can react to both internal and external conditions without human intervention. How would you like to design systems that can automatically grow as the business grows, automatically handle varying load (cyber Monday?), and automatically handle (and repair) internal and external errors, all without human interaction? I'll show you how to do this with your current technology stack (no special languages, tools, frameworks, or products). In this two-part session I will leverage both slides and live coding using Java and RabbitMQ to describe and demonstrate how to build reactive systems. Get ready for the future of software architecture - that you can start implementing on Monday.

Part 1 Agenda:

• Reactive systems introduction
• Channel Monitor Pattern (self-awareness)
• Consumer Supervisor Pattern (scalability and elasticity)
• Workflow Event Pattern (error handling)

Reactive architecture patterns allow you to build self-monitoring and self-healing systems that can react to both internal and external conditions without human intervention. How would you like to design systems that can automatically grow as the business grows, automatically handle varying load (cyber Monday?), and automatically handle (and repair) internal and external errors, all without human interaction? I'll show you how to do this with your current technology stack (no special languages, tools, frameworks, or products). In this two-part session I will leverage both slides and live coding using Java and RabbitMQ to describe and demonstrate how to build reactive systems. Get ready for the future of software architecture - that you can start implementing on Monday.

Part 2 Agenda

• Thread Delegate Pattern (scalability)
• Threshold Adjust Pattern (automatic configuration and self-learning)
• Producer Control Flow Pattern (self-healing)

There are many different uses for Apache Kafka. It can be used as a streaming broker, event broker for transactional data, and even a database. This session is about understanding streaming architecture and how to implement it using Apache Kafka. I start this session by talking about some of the streaming architecture patterns, then dive into how Apache Kafka works using the Core API. Using live coding examples in Apache Kafka, I also talk about the differences between Kafka and regular messaging (RabbitMQ, ActiveMQ, etc.) and when you should use each. I end this session by putting everything together, showing an actual streaming architecture using Kafka within a Microservice ecosystem for gathering various metrics for business and operational monitoring and reporting.

Agenda:

• Streaming architecture patterns
• Kafka overview
• Kafka producers and consumers
• Kafka vs. standard messaging
• Streaming examples in a microservices ecosystem

Even though teams are gaining more experience in designing and developing microservices, nevertheless there is still a lot to learn about this highly distributed and somewhat complicated architecture style. Unfortunately, lots of microservices anti-patterns and pitfalls emerge during this learning curve. Learning about these anti-patterns and pitfalls early on can help you avoid costly mistakes during your development process. While anti-patterns are things that seem like a good idea at the time and turn out bad (see martinfowler.com/bliki/AntiPattern.html), pitfalls are those practices that are never a good idea at the time - ever. In this session I will cover some of the more common anti-patterns you will likely encounter while creating microservices, and most importantly describe some of the techniques for avoiding these anti-patterns.

Agenda

• Function-Driven Identification AntiPattern
• I Was Taught to Share AntiPattern
• The Timeout AntiPattern
• Hop on the Bus AntiPattern
• Data-Driven Migration AntiPattern

Even though teams are gaining more experience in designing and developing microservices, nevertheless there is still a lot to learn about this highly distributed and somewhat complicated architecture style. Unfortunately, lots of microservices anti-patterns and pitfalls emerge during this learning curve. Learning about these anti-patterns and pitfalls early on can help you avoid costly mistakes during your development process. While anti-patterns are things that seem like a good idea at the time and turn out bad (see martinfowler.com/bliki/AntiPattern.html), pitfalls are those practices that are never a good idea at the time - ever. In this session I will cover some of the more common pitfalls you will likely encounter while creating microservices, and most importantly describe some of the techniques for avoiding these pitfalls.

Agenda

• Grains of Sand Pitfall
• Where's the Acid Pitfall
• Logging Can Wait Pitfall
• Jump on the Bandwagon Pitfall
• Give it a Rest Pitfall

It seems like all we talk about these days is making our architectures more modular. Buy why? In this session I will discuss the drivers and reasons why it is essential to move towards a level of modularity in our architectures. I will discuss and show real-world use cases of distributed modular architectures (specifically microservices and service-based architecture), and then discuss in detail the core differences between microservices and service-based architecture and when you should consider each. I'll end the talk by discussing the most effective way of migrating to modular distributed architectures.

Agenda:

• Drivers for modularity
• Modular distributed architectures
• Microservices vs. service-based architecture
• The move towards modularity

One of the expectations of any software architect is to analyze the current technology environment and recommend solutions for improvement. This is otherwise known as continually assessing architecture vitality. Too many times software architects fail to regularly perform this task, leading to emergency refactoring efforts to save a troubled system from failure. The question is, what does it mean to assess an application architecture? In this session we will explore static analysis metrics and tools and techniques for leveraging those metrics for determining structural decay. Using a real-world large-scale application, I'll show you how to leverage code metrics to find (and fix) structural decay before it gets you into trouble.

Agenda

• Architecture and structural decay
• Architecturally significant code metrics and what they mean
• Interpreting results and tracking metrics
• Code analysis tools and how to use them
• Real-world hands-on architecture analysis using tools and metrics

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.

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.

This talk will focus on interesting features of Java 8 that go beyond the basics. Topics will include:

• the map, filter, and flatMap methods
• simple reductions
• extracting and combining streams
• using Optional as intended
• grouping and partitioning
• downstream collectors
• the java.time package
• generics in detail

Sample code will be provided to illustrate all the techniques, along with tests and a build file.

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

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.

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.”

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

The verdict is in: Cloud is NOT a fad. If you haven't already, as a software architect you will be called upon to evaluate various cloud services and determine their suitability for your company's use. In this session, we'll examine ten key criteria that you can use to evaluate any cloud service.

During our time together we'll examine the following criteria:

1. Economics: Price/Cost/Unit of Billing
2. Applicability to Business Case
3. Resiliency Requirements
4. Scalability Requirements
5. Security Requirements
6. Regulatory Requirements
7. Degree of Provider “Lock-In”
8. Required “Undifferentiated Heavy Lifting”
9. Differentiating Features
10. Available Tooling

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.

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.

It happens to us all; there are simply days where it seems impossible to get anything done. This session focuses on techniques and tips to get into the zone, stay in the zone and to protect your productivity, even in disruptive environments.

Rather than focusing on any one productivity methodology (e.g. GTD) This talk analyzes the internal and external factors that affect our productivity and offers broader strategies to get back on track.

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.

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.

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

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.

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.

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.

Take a look at your codebase. Go ahead, this abstract will wait. Notice anything? Perhaps a few more lines of JavaScript than years past? JavaScript is no longer an outlier, a language for the interns, something we can just mash together. Today, JavaScript is a first class citizen. As such, we need to treat it will all the care and feeding we extend our server side languages. This talk will introduce you to a set of tools that will help you write bulletproof JavaScript.

Step one, make sure we aren't making any basic mistakes like using == when we really mean ===. To remedy these types of bugs, we'll leverage JSHint to statically analyze our code. In addition to walking through the setup, we'll discuss how to ratchet up the rules as you improve your codebase. Just like Java or C#, we also need to test our JavaScript code. We'll introduce Jasmine, a BDD style testing tool as well as other tools that make help in the testing process. Last but not least, we'll take a tour of Plato, a JavaScript source code visualizer. Taken together, these tools can go a long way to improve your JavaScript code.

The technology space is a lot like the ocean - miss one wave and another will come along shortly; most shiny new things begin with a sizable amount of hype as everyone rushes to play with the new toy. This cycle is often met with a level of disappointment as we quickly discover our new bauble isn't all that and a bag of chips so we rush off to the next best thing ever.

A few short years ago, HTML5 was the new hotness but at the time browser support was spotty at best. Despite the spotlight moving on to something else, browser support has improved markedly and we even have new toys to play with! In this talk, I will walk you through what is possible in today's browser as well as what other new features you might not be aware of. HTML5 may no longer qualify as bleeding edge, but it is still deserving of our attention.

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.

Unlock your latent photographic memory. In this session you'll learn failsafe techniques and systems that allow you to never forget names, appointments, or numbers. In the process you'll be more effective and imaginative at work; improve reading speed and comprehension, and shorten study times.

An improved memory will change your life, literally. In the session we will describe in detail several memory techniques that, with a little practice, will have you remembering virtually anything you want.

JShell, introduced in Java 9, is a great experimentation tool, useful for micro-prototyping, and trying out code snippets. In this presentation we will learn the benefits of the tool, when to use it, and how to put that to real good use during development.

In this example driven presentation we will look at writing snippets, creating functions, defining and redefining variable and methods, creating classes, and configuring the tool to meet your desired level of feedback.

JavaScript is one of the most powerful and yet perilous languages. It is arguably the most ubiquitous language, the king of the client side programming the web. The dynamic nature of the language offers many benefits, but the weak typing and lack of tooling can make changes unpredictable, that is, if we're not careful. Automated testing can greatly alleviate the pains and lead to more fruitful development.

In this presentation we will take look at the tools, but also the approach to automate the tests for JavaScript code. We will start with simple cases at first, but quickly dive into dealing with dependencies, and measuring code coverage.

The way we build and deliver software is changing. We must deliver software more quickly than ever before and traditional approaches to software architecture, infrastructure and methodology do not allow us to meet demand. We’ve reached the limits of agility through process improvement alone, and further increases demand we focus on improving architecture, infrastructure, and methodology simultaneously. 12 Factor is an app development methodology for building modern apps in the modern era.

Building modern apps requires modern methods and 12 Factor is an app development methodology that helps development teams build software by emphasizing development practices that meld together modern architectural paradigms with agile practices like continuous delivery for deployment to cloud platforms. In this session, we’ll examine the 12 Factors and explore how to apply them to apps built using Java.

With Java 9, modularity will be built in to the Java platform…Finally! In this session, we explore the default Jigsaw module system and compare it to the alternative module system, OSGi, on the Java platform.

We will demonstrate the impact that Jigsaw will have on our existing applications and identify what we must do to get ready for Jigsaw. You will also see firsthand how to use the Jigsaw module system and the benefits that support for modularity on the Java platform will have on your applications.

You don't need Node.js or MongoDB to build “full-stack” solutions, but they sure help! This stack is popular for its scalability, its promise of developer productivity, and the capability to develop all components with a single programming language. Not all use cases are a great fit for JavaScript on the server. But love it or hate it, there are valuable lessons and use cases here for all developers.

We'll examine a complete multiuser end-to-end app using HTML5, CSS, and JavaScript. We'll connect it to a simple Node.js instance using WebSocket. We'll wire up a simple document-oriented persistence layer with MongoDB. And we'll do it all using mostly-vanilla JavaScript to illustrate concepts that don't depend on particular frameworks.

You'll leave this session convinced that full-stack JavaScript has “teeth”, and that it's not all just hype. And whether you intend to use JavaScript, Java, Ruby, or a mix of various frameworks on the server, the architecture of a dynamic HTML5 app will be made transparent and straightforward.

HTML5 hasn't fundamentally changed the way we build web applications — JavaScript frameworks did that. Not so with Web Components! Web Components are the most important update to HTML and the Document Object Model in recent years. They have a major impact on client-side architecture, on framework selection, and on distribution and reuse of code.

In this session, I'll explain to you the four Web Components standards, their current state, and why you should care. I'll give several examples of complex applications built in Web Components, and running in all modern browsers — including a rich mobile game.

“There's a new JS framework every week! There's a new JavaScript feature every week! There's a new HTML5 feature every week! We are losing our minds OMG@#$HELPUS!”

Settle down everybody. Shiny new frameworks distract you from the stability offered by the web platform: ES6 is the first major update to JavaScript since 2009, and HTML5 was 18 years in the making! More importantly, few of these innovations significantly change the architecture of web applications — we owe browser innovation and frameworks for that. But since the browser evolved in to a full-blown application runtime, we now need solid front-end architecture, and front-end architects. It's not just about JavaScript, it's about the entire browser platform. And you can't pick frameworks to simplify that platform until you understand its underpinnings.

In this workshop, we will dissect the components of a modern web client into three buckets:

1. Networking: How does data get to and from the client? We will discuss the various underlying APIs and libraries for client-server communication.
2. Rendering: How does the user interface get created and painted? We'll look at the HTML5 APIs for manipulating the DOM, and explain how various frameworks including AngularJS, React, and Polymer regard and manipulate the DOM.
3. Distribution & Maintenance: How does the resulting app get distributed and updated, either on the web or to app stores?

I'll lay the foundations to simplify the complex world of front-end tools, frameworks, and architecture. I'll share patterns to help you manage the complexity of front-end development and back-end integration for modern web clients. And I'll convince you to never again complain about how fast the world of front-end technologies is moving.

Regular Expressions are an undervalued, underutilized tool in the developer toolbox. Few programming technologies have stood a comparable test of time for their capacity to improve developer productivity, to shortcut complex tasks, to reduce dependency on various libraries, and to encourage code reuse. They also help to teach patterns and improve pattern recognition, not only for code, but for programmers themselves. Competency with regexes will make you a better programmer, regardless of your choice of language or platforms. And it will impress your peers, too!

This workshop will teach you the fundamentals of writing, debugging, and testing PCREs (Perl-compatible Regular Expressions) in multiple programming languages. With hands-on examples we will cover regex syntax, metacharacters, assertions, grouping, quantifiers, greed, capturing, balanced matches, and replacing. We'll compose regexes from scratch to parse some common string formats such as URLs, email addresses, and even JSON. Given enough time, we'll even learn look-around assertions, and examine some creating uses of regexes in the field of natural language processing.

Traditional approaches to software architecture do not address the core tenet of all agile practices - feedback! We make many of the most important architectural decisions early in the development lifecycle and fail to get accurate feedback on those decisions throughout implementation. Compounding the problem? Agile methods offer no architectural advice. This session explores several architectural practices that help increase architectural agility.

What’s the goal of architecture? To serve as a blueprint of the system that everyone understands? Possess the flexibility to evolve as new requirements emerge? To satisfy the architectural qualities, including performance, security, availability, reliability, and scalability? Yes. Yes. Yes. At the heart of these three questions are the three pillars of architecture - social, process, and structure. But how do we create software architectures that achieves all of these goals? And how do we ensure no disconnect occurs between developers responsible for implementation and architects responsible for the vision? In this session, we’ll explore several principles to increase architectural agility and provide some actionable advice that will help you get started immediately.

Recently, microservices have take the development community by storm. Though a modern architectural paradigm, the underlying principles of microservices are embedded across many proven traditional architectural approaches, especially modularity. At the end of the day, microservices are just one way to the increase modularity of our software system. But there are others.

In this session we will examine several different ways to modularize large software systems. We'll start with the “modular monolith” and demonstrate how this modular monolith gives us a significant degree of architectural agility to evolve the architecture to microservices by incrementally breaking pieces of the application off and deploying them as microservices.

Microservice architecture is a modern architectural approach that focuses on breaking apart the monolith and building modular services. But the framework we use has a tremendous impact on how we build and deploy services. A new type of framework has emerged that provides a lightweight stack for building microservices.

In this session, we will explore some modern Java micro frameworks for building microservices. Example frameworks you may see include Dropwizard, Spark, Ninja, RestExpress, Play, Restlet, and RestX.

As a developer, your focus was squarely on the “functional requirements” aka the business capabilities your application must meet. But once you step in the architect role, you discover a world inhabited by “the ilities” otherwise known as the non functional or quality attributes of a software system. But how do we know which ilities matter and which ones don't? And much as we may want to turn every knob up to 11, many ilities are inversely related - maximize one and you by definition minimize another.

In this talk we will look at various architectural problems giving participants opportunities to try and balance non functional requirements. We'll discuss the consequences of various approaches as well as how we can best document the inevitable decisions we arrive at.

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.

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.

Today you can't swing a dry erase marker without hitting someone talking about “the cloud”. From the CIO to the project room, the cloud is bound to be a topic of conversation. While there is no denying the buzz worthiness of the term, you probably should take a deep breathe before declaring your entire portfolio will be cloud native by the end of the year. In this talk, I will discuss a practical way of assessing your applications and how to create a thoughtful plan to move applications to the cloud - when it makes sense.

We'll talk about what factors to consider when surveying an application, why some systems shouldn't go to the cloud and what else you need to consider beyond the basics of picking a cloud vendor. Cloud based deployments have tremendous benefits to today's organizations - but as with any new technology, it must be introduced with care.

Modern Android applications use many features that go beyond the basics. This talk will demonstrate the compatibility library, along with many of the popular open source libraries, including:

• ButterKnife
• Dagger
• Retrofit
• EventBus by greenrobot
• Espresso testing
• the Realm database

The talk will also include a discussion of application architectures, like MVP and MVVM.

If time is available, some discussion of reactive architectures using RxAndroid will be included as well.

Being a professional software engineer, it's easy to fall into the belief that one's role in a company is to write code.
Another perspective might be that one's role is to solve problems for the business and that writing code is merely one of several tools available to help solve those problems.

There are numerous problem-solving “anti-patterns” that are rampant in the industry today. “Forewarned is forearmed” as they say. In addition to highlighting these “anti-patterns” with real-life examples and the (sometimes) disastrous consequences, Michael asks some of the difficult questions about our true motivations for our decisions and how our decisions can either positively or negatively affect our team and our organization.

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.

The demands on applications have never been more intense. The users on the web, combined with mobile devices, ask for highly responsive applications. Our customers, thanks to open competition and perceived agility, expect tomorrow's features be delivered today. “Are you done yet” are the dreaded words of the corporate grind.

Tools like Express and Angular have risen to address those demands for speed. While that's wonderful, speed in the absence of discipline is hard to sustain. In this keynote we will discuss the practices that can help alleviate the pains while helping us cope with the demands, the reasons to do so, and the approach we can take to achieve that.

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!

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.

Our jobs usually deal with something other than new code. It is usually old spaghetti and difficult-to-read code. How do we test such code? How do we get through it? How can we surgically remove and make some of this harmful code testable?

This session looks at lousy code, and we talk about some strategies we can do to diagnose, test, apply, and finally refactor to produce something that would promote some sanity in your development process. We can do much with our code to make it better and testable while avoiding extensive mocking. The content of this course is all in Java and JUnit.

Workshop Requirements

• JDK 11+
• Maven 3.8.x
• IDE (I will be using IntelliJ)

Like all languages, Groovy code can be written in many different ways. This talk will review how to write Groovy that follows the most commonly accepted idioms and practices, especially in light of the changes in Java 8. Features demonstrates will include closures, class and method definitions that best accommodate Java integration, testing techniques, and more.

Groovy is, relatively speaking, a mature language on the JVM. Adding it to existing Java systems is easy. Following the recommended practices helps make maintenance and extensibility practical.

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.

Reactive Programming is at the top of new excitements in our field. There is a lot of discussion and theory around this concept, but what does it feel to create applications using these ideas? That's the focus on this talk, and we'll use Vert.x as a vehicle.

Learn about reactive programming, how to create applications, and how Vert.x can make that an enjoyable task.

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.

We all have seen our share of bad code and some really good code as well. What are some of the common anti patterns that seem to be recurring over and over in code that sucks? By learning about these code smells and avoiding them, we can greatly help make our code better.

Come to this talk to learn about some common code smell and to share your experiences as well.

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.

Redux has fast become one the pillars for state management in the modern era of web application developments. Though tiny, it packs a punch, and in this session we will explore the principles behind redux and see how to use it in our web applications.

TBD

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.

In this workshop, attendees will learn how to take advantage of recent work with Gradle and Android to make building Android projects more efficient and effective. The examples will feature the new Android 2.5 plugin, with all the associated improvements, but will also focus on systematic ways to structure your app to make the build faster. We will show how to take advantage of incremental builds, how to use avoidance strategies to reduce the impact of annotation processors, and demonstrate how to use build scans and other profiling techniques to detect bottlenecks in the build process. Finally, we'll show how to avoid the “legacy multi-dex” problem and make your debug-related builds more efficient.

——

Workshop Requirements

Please install the latest version of Android Studio from https://developer.android.com/studio/index.html . If you already have an existing version, you can keep it separate from this one; the new one will not conflict with it.

All other software and/or tools will be discussed during the workshop.