Everyone (including your humble speaker) talks about Modularization. For once, let's focus on other interesting and exciting parts of Java 9 that does not involve modularization. In this presentation we will talk about key improvements and additions to the Java language and the JDK introduced in Java 9.

We will focus on first things that can be done better in Java 9 compared to previous versions on Java.
Then we will look at things we simply could not do before but we can benefit from now.
And finally, we will not talk about Modularization, well I lied, will discuss that just a bit.

Reactive Programming is no longer an esoteric idea. Many libraries and tools have started providing excellent support for this idea of programming. So much that Java 9 has embraced this idea by including it into the specification. In this presentation we will take a dive into what reactive programming looks like from the Java specification point of view.

Reactive Programming
What problem does it solve
How to use it from Java point of view?
What can you do to make good use of it.

After years of stagnation, Java is one of the most vibrant languages of current times. Java 8 saw several improvements and Java 9 a few more. Well, that's only the beginning. Come to this talk to learn about where Java is heading, what's brewing in the language and the ecosystem, well beyond Java 9.

We will look ahead into the next versions of Java, what you can expect, and how you can get ready.

React is a very targeted library for creating rich front end. While React does fairly well what it intends to provide, developing a practical application requires more than using React alone.

In this presentation we will build the front end for a small application that pulls data from a backend and along the way learn how to use React and related libraries to achieve the desired results.

In this presentation, we will dig deeper into creating applications with React.

We will take a deeper look into creating components, dealing with life cycle events, managing state, when and how to use Redux, and how to approach automated testing of the front-end code you create.

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.

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

Chaos Engineering, pioneered by Netflix, is the discipline of experimenting on a distributed system in order to build confidence in the system's capability to withstand turbulent conditions in production.

In this presentation, we'll take a look at the problem of building resilient software, and discuss how applying Google's SRE principles and patterns for architectural resiliency can help us to solve it. We'll then examine how the practice of Chaos Engineering can help us to prove or disprove the resiliency of our systems.

As an architectural style, microservices are here to stay. They have crossed the proverbial chasm, and now it’s time to get to work. Microservices provide us with the ability to create truly evolutionary architectures composed of cohesive and autonomous components using well known and characterized distributed systems patterns.
As we create and compose components across the hard boundary of the network, we become deeply interested in establishing the correct boundaries and has resulted in renewed interest in system design and decomposition. Fortunately, the tried and true practices of Domain-Driven Design are available to us.

In this presentation, we will cover a distillation of strategic (bounded contexts, subdomains, context mapping) and tactical (aggregates, domain events) DDD techniques and demonstrate how they enable us to create effective event-driven microservices.

The late Stephen Covey, world-renowned leadership author and speaker, said many times that “You don’t break principles. You only break yourself against them.” Like any other discipline, software engineering is governed by its own set of unbreakable principles. Those who discover and align their behavior with them often seem to be good at this business we call software, and those who ignore or willfully violate them inevitably fail, sometimes in spectacular ways.

Our industry has existed for several decades. One could logically surmise that we should have discovered and aligned around at least a few of these principles by now. And yet the trained eye of a historian, focused on the events of our industry’s last two decades, would observe a troubling cycle of discovery leading to failure, leading to rediscovery and further failure. What is the nature of this cycle? Why are we trapped? How do we escape? We’ll confront these questions and more in this tragicomedy that has something for everyone, from the novice script kiddie to the seasoned blowhard jamboree.

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

In this session we will take a look at some of the features that ECMAScript 6 / 7 / 8 / 9 and 10 bring to the table. We will take an exploratory approach, and by the end of 3 hours, you will be well versed with ALL of the new features in JavaScript.

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

In this session we will take a look at some of the features that ECMAScript 6 / 7 / 8 / 9 and 10 bring to the table. We will take an exploratory approach, and by the end of 3 hours, you will be well versed with ALL of the new features in JavaScript.

An integral part to any DevOps effort involves automation. No longer do we wish to manage tens, hundreds or even thousands of servers by hand, even if that were possible. What we need is a programmatic way to create and configure servers, be those for local development, all the way to production.

This is where tools like Ansible come into play. Ansible offers us a way to define what our server configurations are to look like using plain-text, version-controlled configuration files.
Not only does this help with avoiding “snow-flakes”, but it promotes server configuration to participate in the SDLC, pulling server configuration closer to the developers.

In this session we will explore what Ansible has to offer, decipher the Ansible terminology, and run some examples to configure a local server.

Ansible, like Git, aims to be a simple tool.
The benefit here is that the level of abstraction that Ansible offers is paper-thin, with no complicated workflows, or opinions enforced by the tool itself.
The downside is that without a prescribed approach to Ansible, developing your playbooks often becomes a case of trial-and-error.

As engineers steeped in the DevOps mindset we must be able to use the tool effectively, allowing us to accelerate and shorten the lead time from development to production.

In this session we will take a look at some lessons learned when working with Ansible. Topics covered:

• Variables, variable lookup precedence, and the best way to use variables in your Ansible scripts
• Setting up Ansible to work locally, allowing for faster development, iteration and testing
• Laying out your inventory files, and positioning them to work best with group_vars and host_vars
• Thinking about the “hierarchy” of your infrastructure, and how best to use Ansible to reflect that hierarchy

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

Angular leverages a whole slew of technologies — from TypeScript, to RxJs to Protractor for E2E testing, all within reach via the Angular CLI. All of these tools come with their own tooling, and knowing how to use these tools independently, and in concert is what makes us effective Angular developers.

In this session we will first look at the tooling for each of these pieces individually. We will see what configuration options are available to us, and then see how to leverage the Angular CLI to bring all of these together. We will also see some of the features that the Angular CLI offers us to decrease our time from development to production

This session covers the landscape of Big Data tools, technologies and best practices in 2018. You'll leave this session armed with the knowledge you need to build Big Data solutions by assembling the best technologies for you.

We cover the components of a big data pipeline, options available for each module and the pros, cons and best practices for each option.

Big Data is exploding into our industry and these skills are increasingly in demand. Much of our existing body of knowledge needs to be updated, however as Big Data solutions present a number of unique challenges. In this half-day workshop we start with the question “What is Big Data?” and “How do big data solutions differ from traditional data architectures.” We then dive into core Hadoop technologies to tackle your Big Data challenges and dive into several tools and technologies for distributed processing of large datasets.

The Big Data Space is rapidly changing and with a seemingly dizzying number of technology choices, one might not know where to begin. Our goal with this half-day workshop is to give you an overview of a number of technologies, their respective strengths and weaknesses, and enough knowledge to make informed decisions and built great tech!

Big Data is exploding into our industry and these skills are increasingly in demand. Much of our existing body of knowledge needs to be updated, however as Big Data solutions present a number of unique challenges. In this half-day workshop we start with the question “What is Big Data?” and “How do big data solutions differ from traditional data architectures.” We then dive into core Hadoop technologies to tackle your Big Data challenges and dive into several tools and technologies for distributed processing of large datasets.

The Big Data Space is rapidly changing and with a seemingly dizzying number of technology choices, one might not know where to begin. Our goal with this half-day workshop is to give you an overview of a number of technologies, their respective strengths and weaknesses, and enough knowledge to make informed decisions and built great tech!

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

In this session, we'll explore the new reactive features in Spring 5 to build reactive, non-blocking applications using Spring's familiar programming model.

Traditionally, applications have been built using a blocking, synchronous model. Although comfortable and intuitive for most programmers, this model doesn't scale well. And although there are several new approaches to reactive programming, they don't necessarily fit into the familiar programming model that Spring developers are accustomed to working with.

Spring 5 has introduced a set of new reactive features, enabling non-blocking, asynchronous code that scales well using minimal threads. Moreover, it builds on the same concepts and programming models that Spring developers have used for years.

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.

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.

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.

Apache Spark is the fast data processing of large document stores and databases. Spark is highly distributed, optimized, and redundant for large clustering manipulation and aggregation.

This talk is an introduction to Apache Spark, it's architecture, and it's programming API. We start with an introduction to DataFrames, the Catalyst Optimizer, and Spark SQL. We will then venture onto DataSets, discuss the DataSet API and the functional programming aspects of it. We will touch lightly on RDD and the pros and cons of using the API. We will then finish with how to connect to data sources like HDFS, S3, Cassandra, Elastic Search, and Kafka. This presentation will have samples that you can try out at home or at the office.

Spark Streaming is one of the few additions that are available with Spark that uses its internal architecture and creates a Streaming processing framework to process data in real time.

In this presentation, we will start with a small reintroduction to Spark and it's architecture and what it does. Then we delve into streaming, what purpose does it serve, how to set up Spark Streaming and how to use it. We will discuss how to set it with time, how the internals work, and how also to integrate it with Kafka. We then will talk about some of the more high-end features like checkpointing, and windowing.

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.

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.

As developers we not only operate in different contexts, but also often have these different contexts interplay as part of our work.
Each of the tools that we use — version control systems like Git (along with collaborative tools like Github/Gitlab), IDE's like Eclipse/IntelliJ, build systems like Gradle, Ci/Cd tooling like Jenkins, IaaC tools like Ansible, the command line — all introduce context.

To be effective developers we need to know when to operate in a certain context, combine or tease apart how these contexts interplay.
Can you improve your release announcements if format your commit messages consistently? You bet!
How should your build tool interact with your version control system?
What does naming your files have to do with how you use your IDE?

This session will take a look at several of these contexts — it will attempt to discern between them, explore when you should separate them and when you attempt to bring them together.

With lots of examples, and lots of quizzes this session will definitely leave you thinking about a few things.

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.

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!

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.

Today our world is full of things that are “as a service” - infrastructure, containers, platforms, software…and of course functions. With developers just now wrapping their heads around application platforms and containers, what are they to make of functions as a service? How does a busy developer cut through the hype and make sense of the world of serverless, Kubernetes, Spring Cloud Function and all the rest? This talk will clear up the confusion! We examine Riff, a FaaS built atop Kubernetes. We will discuss where functions and serverless fits in your world, and how you can get started with some simple demos. Though functions aren’t a silver bullet, they are an important part of the development toolbox; this talk saves you from the buzzword bingo to give you a solid foundation of the FaaS landscape.

Today our world is full of things that are “as a service” - infrastructure, containers, platforms, software…and of course functions. With developers just now wrapping their heads around application platforms and containers, what are they to make of functions as a service? How does a busy developer cut through the hype and make sense of the world of serverless, Kubernetes, Spring Cloud Function and all the rest? This talk will clear up the confusion! We examine Riff, a FaaS built atop Kubernetes. We will discuss where functions and serverless fits in your world, and how you can get started with some simple demos. Though functions aren’t a silver bullet, they are an important part of the development toolbox; this talk saves you from the buzzword bingo to give you a solid foundation of the FaaS landscape.

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.

All software architectures have to deal with stress. It’s simply the way the world works! Stressors come from multiple directions, including changes in the marketplace, business models, and customer demand, as well as infrastructure failures, improper or unexpected inputs, and bugs. As software architects, one of our jobs is to create solutions that meet both business and quality requirements while appropriately handling stress.

We typically approach stressors by trying to create solutions that are robust. Robust systems can continue functioning properly in the presence of internal and external challenges, but they also have one or more breaking points. When we pass a robust systems known threshold for a particular type of stress, it will fail. When a system encounters an “unknown unknown” challenge, it will usually not be robust!

Recent years have seen new approaches, including resilient, antifragile, and evolutionary architectures. All of these approaches emphasize the notion of adapting to changing conditions in order to not only survive stress but sometimes to benefit from it. In this class, we’ll examine together the theory and practice behind these architectural approaches.

Microservices continues to be the latest buzzword in the industry, and probably will be for some time. If you are not sure what microservices is or want to start getting your feet wet in understanding the basics of this architecture style, then this session is just right for you. In this session I will cover the basics of the microservices architecture pattern. We'll talk about distributed architecture, what a microservice is, what the bounded context means, how to determine the right level of service granularity, the dangers of inter-service communication, and the role of the API layer. By the end of this session you will have a good idea of what the microservices architecture style is all about and whether it is a good fit for you.

Agenda:

• Why Microservices?
• Microservices Topology
• Service Granularity
• Service Classification
• Bounded Context and Share-Nothing Architecture
• The Role of the API Layer

.

.

Jorge Santayana is famous for saying “Those who cannot remember the past are condemned to repeat it”. When SOA (Service-Oriented Architecture) was all the craze, everyone got all excited about services, but forgot about the data. This ended in disaster. History repeats itself, and here we are with Microservices, where everyone is all excited about services, but once again, forgets all about the data. In this session I will discuss some of the challenges associated with breaking apart monolithic databases, and then show the techniques for effectively creating data domains and how to split apart a database. I consider the data part of Microservices the hardest aspect of this architecture style. In the end, it's all about the data.

Agenda

• Data distribution challenges and considerations
• Creating data domains
• Data and service granularity
• Handling common data tables
• Managing distributed transactions

Once you break things apart into microservices, you must then put them back together. In other words, individual services still sometimes need to talk to one another to complete a given business transaction, whether that transaction is synchronous or asynchronous. In this session I talk about the various patterns of communication within microservices - orchestration, aggregation, and adapters. I also talk about coupling between services, including stamp coupling and bandwidth issues, and how to address these common communication woes.

Agenda

• Orchestration vs. Choreography and When To Use Each
• Microservices Orchestration Pattern (tying services together)
• Microservices Aggregation Pattern (cross-cutting business concerns)
• Microservices Adapter Pattern (communicating to outside systems)
• Stamp Coupling and Bandwidth (twin evils)
• Asynchronous vs. Synchronous Communication

Have you ever wondered how to share data between microservices? Have you ever wondered how to share a single database schema between hundreds (or even thousands) of microservices (cloud or on-prem)? Have you ever wondered how to version relational database changes when sharing data in a microservices environment? If any of these questions intrigue you, then you should come to this session. In this session I will describe and demonstrate various caching strategies and patterns that you can use in Microservices to significantly increase performance, manage common data in a highly distributed architecture, and even manage data synchronization from cloud-based microservices. I'll describe the differences between a distributed and replicated cache, Using live coding and demos using Hazelcast and Apache Ignite, I'll demonstrate how to share data and also how to do space-based microservices, leveraging caching to its fullest extent.

Agenda:

• Caching Topologies
• Sharing Data Between Microservices
• Space-Based Microservices and Caching
• Calculating Data Collisions

Reactive architecture patterns allow you to build self-monitoring, self-scaling, self-growing, and self-healing systems that can react to both internal and external conditions without human intervention. These kind of systems are known as autonomic systems (our human body is one example). In this session I will show you some of the most common and most powerful reactive patterns you can use to automatically scale systems, grow systems, and self-repair systems, all using the basic language API and simple messaging. Through code samples in Java and actual run-time demonstrations, I'll show you how the patterns work and also show you sample implementations. Get ready for the future of software architecture - that you can start implementing on Monday.

Agenda

• introduction to reactive architecture
• supervisor consumer pattern (automated microservices scalability)
• workflow event pattern (automated asynchronous error handling)
• producer control flow pattern (automated repairing of downstream systems)

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