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

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

In 250BC Rome began its expansion into Carthage, and later into the divided kingdoms of Alexander, starting the rise of a great empire until its decline starting around 350AD. Much can be learned from the rise and fall of the Roman Empire as it relates to a similar rise and fall: Microservices. Wait. Did I say “fall of microservices”? Over the past 5+ years Microservices has been on the forefront of most books, articles, and company initiatives. While some companies been experiencing success with microservices, most companies have been experiencing pain, cost overruns, and failed initiatives trying to design and implement this incredibly complex architecture style. In this session I discuss and demonstrate why microservices is so vitally important to businesses, and also why companies are starting to question whether microservices is the right solution. Sir Issac Newton once quoted “What goes up must come down”; Blood, Sweat & Tears sang about this in their hit “Spinning Wheel”. Microservices is no exception. Come to this provocative session to learn about the real challenges and issues associated with microservices, how we might be able to overcome some of the technical (and business) challenges, and whether microservices is really the answer to our problems.

Software architecture is hard. It is full of tradeoff analysis, decision making, technical expertise, and leadership, making it more of an art than a science. The common answer to any architecture-related question is “it depends”. To that end, I firmly believe there are no “best practices” in software architecture because every situation is different, which is why I titled this talk “Essential Practices”: those practices companies and architects are using to achieve success in architecture. In this session I explore in detail the top 6 essential software architectural practices (both technical architecture and process-related practices) that will make you an effective and successful software architect.

This session is broken up into 2 parts: those essential architecture practices that relate to the technical aspects of an architecture (hard skills), and those that relate to the process-related aspects of software architecture (soft skills). Both parts are needed to make architecture a success.

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)

Event-driven architecture using messaging and events is hard - really hard. In this talk I describe and demonstrate (through live coding in Java and RabbitMQ/ActiveMQ) several key event-driven architecture design patterns that you can use to solve many problems related to scalability, throughput, and error handling in event-driven systems.

Agenda:

Event Forwarding pattern
Ambulance pattern
Watch Notification pattern
Multi-Broker pattern
Contextual Queue pattern
Thread Delegate pattern

Whether starting a new greenfield application or analyzing the vitality of an existing application, one of the decisions an architect must make is which architecture style to use (or to refactor to). Microservices? Service-Based? Microkernel? Pipeline? Layered? Space-Based? Event-Driven? SOA?. Having the right architecture style in place is essential to the success of any application, big or small. Come to this fast-paced session to learn how to analyze your requirements and domain to make the right choice about which architecture style is right for your situation.

Agenda

Architecture Style Classification
Common Architecture Styles
Domain to Architecture Isomorphism
Case Studies: Selecting an Architecture Style

The journey from developer to software architect is a difficult and uncharted path filled with lots of challenges, pitfalls, and confusion. In this session I show some ways to better understand the role of a software architect and ways to effectively steer a charted course towards becoming a software architect. In this journey I discuss the expectations of a software architect, how to think like an architect, and also talk about various architecture personalities and how they impact a development team. I then talk about some of the core leadership skills an architect must have to succeed, and finally end the session with some valuable resources that will help you in the long and difficult journey from developer to architect.

Agenda:

Expectations of an architect
Thinking like an architect
Architecture personalities and boundaries
Leading teams
Architecture resources

Java was once a language that dragged along and evolved at snails' pace. Thankfully, that's no longer the case. The recently years have seen accelerated development of both language features and JDK improvements. In this presentation we will dive into some of the recent changes of Java that are both fun and powerful to use and discuss where the language is heading in the near future.

The modern features of the language
Where's Java heading?

The last big water-hose change to Java came in Java 9. Since then, thanks to the new release cadence, the language is evolving faster, but with bitesize improvements. With release every six months, we'll soon be seeing Java 15! In this presentation we'll explore the features of Java, both the language changes and the significant JDK changes, starting from Java 9 to the current version.

Language changes
Significant JDK changes

One of the most intriguing classes in the JDK is the Collectors utility class, with a collection of some highly powerful functions that are useful during the reduce operation of streams. The functions that are in this class have so much to offer and yet, due to their complex nature, often are not used as much as they should be. Using well defined live coded examples, we will take up several common programming problems. Discuss them quickly and drive the implementation of these using the Collectors' methods. By the end of this presentation you will know more throughly the power of Collectors and how to apply the methods in there.

The Collectors utility class
Benefiting from Collectors
Learn to program some advanced capabilities of functional style along the way

Developer First leadership does not depend on accumulating power within a team or company. Instead, it focuses on the needs of the developers, their technical and career growth, and building positive team cultures.

This session will cover 7 different tactics to practice Developer First leadership. These include empowering others, the importance of diversity & inclusion on our dev teams, establishing a positive developer onboarding experience, and how to become an authentic and respected leader.

Participants of this talk will learn how to successfully navigate the complexities of Engineering Leadership; regardless of your title!

Do you feel inspired by conference talks but overwhelmed by all of the take aways to remember when you get back to work? This session will provide an opportunity to identify and practice key leadership skills immediately!

We will work to understand what your motivational style means to you and how you can use it as a compass for decision making and improving your enjoyment at work.

Attending meetings, researching a new feature, writing support documentation, troubleshooting an annoying bug, responding to on call duties, and the growing email inbox; when do I find time to actually write code?

This one hour session will involve hands on activities for participants to assess their priorities and learn essential skills for maximizing their busy schedules and spending time on the things that actually matter!

Please view and download the handout before joining this session. (located with session slides)

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.

ES6+ ushered JavaScript into the modern era. Features like fat-arrow functions, destructuring, rest/spread operators can help us write code that is simple, succinct and elegant. Features like Classes can help organize our models better, and async/await can help make our asynchronous code easier to reason about.

In this session we will take a simple piece of functionality, and see how we can refactor it to use modern JavaScript capabilities. This will give us the ability to see how these features can help us, and where we should be careful as we go about migrating our code.

If you think that successful individuals in our field are just talented or lucky, you’re only partially right. More importantly, they are very good at focusing on the right things, making them extremely efficient. We often blame others for our inability to focus, but the truth is that we allow outside forces to drain our time and attention, leaving us time-crunched and stressed.

This session will highlight many popular productivity strategies, many of which can be applied in your home as well as in your office! Whether your issue is email or chat addiction, incessant meetings, procrastination, general disorganization, or poor estimation skills… this course is for you. Reclaim your time, your career, and your life by training yourself how to focus on what matters.

Even if you're already using Git and comfortable with the basics, situations can arise where you wish you understood it better.

In this session, we’ll quickly cover the fundamentals of cloning, branching, and merging. Then we’ll move on to different workflows, release management strategies, how to get out of a Git pickle, and more. We will explore less frequently used - but extremely helpful - commands that can save your team hours, days, or weeks of work. Finally, you’ll gather some pro tips for using Git on the command line, ensuring that wherever and however you work, you’ll become your team’s resident Git Wizard.

Most of us want tech to be an equitable and inclusive place where everyone feels comfortable. But it can be intimidating - or even frustrating - when it feels like the target is always moving. The things that didn’t seem like a problem yesterday suddenly are, and we’re not sure what we should be doing instead.

Rather than approaching this subject with anger or blame, we will instead focus on understanding and practical advice you can use to make your workplace more enjoyable and welcoming to all. At the end of this session, there will be a significant amount of time for Q&A, where we can have an open dialogue about how to become better allies.

In this example-driven presentation, we'll start with an empty directory and have an application (simple as it may be) running in a production environment, leveraging Spring and 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 example-driven session, we'll build a complete (albeit simple) Spring application, leveraging Spring's support for reactive programming at all levels, from the database to the client.

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.

This session will help you approach difficult people and situations with more empathy, and more importantly, discover practical tips on how to diffuse their effect on you and your happiness.

Does it seem like no matter what you do, you can’t make your boss happy? How about your nit-picky teammate who tears your code apart whenever they have the chance? Or the direct report who won’t do anything without you explicitly asking? When you have to work closely with these kinds of people every day, those annoying personality traits can make your life miserable. By peeling back the labels we assign to people, we will strive to understand what makes them tick. This session will help you approach difficult people and situations with more empathy, and more importantly, discover practical tips on how to diffuse their effect on you and your happiness.

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.

In this session we will go further with DDD, considering aspects like aggregates, domain events, factories and repositories, and consider how DDD can be represented in architecture, be that hexagonal, REST or RPC.

If you need a deeper dive into DDD, then this is the session for you.

We live in a world of microservices. Yet, what is a microservice? What defines the boundaries of a microservice? How do we define the relationships between microservices? Thankfully domaindriven design gives us the concepts and practices to better design and decompose our services.

In this session we will consider many of the concepts of DDD — How bounded contexts use Ubiquitous language to model the domain, how context maps can be used to establish the interconnections between services as well aggregates and domains events, all of which will service us well as we go about creating our microservices.

A large part of embracing DevOps involves embracing automation. Over the last decade we have seen the emergence of “as Code” — Build-as-Code, Configuration-as-Code and Infrastructure-as-Code. The benefits to utilizing such tools are huge! We can codify the state of the world around our applications, giving us the ability to treat everything that our code needs like we treat the code itself. Version control, release management, tagging, even rolling backs are now possible. Terraform, an open-source tool from HashiCorp allows us to build, control and modify our infrastructure. Terraform exposes a Domain-specific language (DSL) that we can use to express what our infrastructure should look like. Terraform can work with all the major cloud providers, including Amazon AWS, Google GCP and Microsoft Azure. If you are curious about what this tool has to offer, this session is for you. Come on in, and let's learn how to terraform your cloud.

This session will focus on Terraform. We will look in to how this tool works, explore its capabilities, and see how it can play a pivotal role in our Infrastructure-as-Code (IaC) strategy. With lots of code and demos, this session will certainly give you enough fodder for thought, and provide a baseline so you can decide if Terraform is right for you.

Albert Einstein once said — “We cannot solve our problems with the same thinking we used when we created them.”

As developers, architects, managers, tech-leads, our job entails solving big problems. However, our systems are composed of parts, and it is the interaction of those parts that ensure the system works, and tells us where to go looking when things fail. What does it mean to think in systems? What are the benefits, and what are tools are available to us? If any of this intrigues you (and it should) come join me as we explore a new way of thinking about problems, both big and small.

In this session we will take a page from Donella H. Meadows fantastic book “Thinking in Systems” and attempt to get an understanding of what makes up a system, how we can tease apart the moving parts of the system, and get into the mindset of a “systems thinker”.

Want to bring in [new cool thing X] or [necessary technology change Y] to your company, because you know there's a need for it? GOOD IDEA! Except…now what? If your company is more than about 3 people, how do you explain, enable, and encourage the adoption of this change, especially if it will require some work on everyone’s part?

In How to Technology Good, Josh and Laine will explain how bringing in technology is subject to one of the biggest problems in IT - how to scale it. They'll also talk about tips and tricks for how to be as successful as you can, and the main things to keep track of and watch out for. They'll go through each phase of bringing in new tech, all the way from how to pick your success criteria through what to think about when it comes to maintenance.

There is pain inherent in development - monoliths, confusing deployment processes, conflict between dev/ops/business.

IT is hard and the pace of change now makes it even more difficult. Join Josh and Laine as they talk about how focusing on solving this pain can help in a lot of surprising ways - kickstarting DevOps, speeding up product delivery, and even enabling the business as a whole.

Containers enable rapid development and rapid software delivery - and with that increase in speed comes a need to shift how people think about and tackle security. Running those containers is part of this consideration - the platform and container orchestration has to figure out and handle all of the moving parts.

In this talk, Laine and Josh will give their recommendations for Kubernetes as a platform to run containers. They'll go through talking about security from the perspective of the pieces that make up the container - the ingredients, and how it runs in addition to where it runs. They'll discuss application and platform boundaries while explaining a simple model to use in order to think about and discuss this complex topic.

Based on the book with the same title as this talk, this presentation will explore the modern features of JavaScript that make this a pleasant language to use. Come to this presentation to get a quick jumpstart on the elegant capabilities from passing arguments, to creating iterators, to destructring, and more features of using ES 6 and beyond.

Safely defining variables
Rest, spread
Default parameters
Generators and iterators
Destructuring
…and more…

JavaScript has had metaprogramming from the beginning, but in recent versions of the language more power has been packed. This opens door for not only doing function and property injection but also synthesis. In this presentation you will learn, using live examples, the power of metaprogramming and how to make use of that to create dynamic, highly extensible code for your client side and server side applications.

Metaprogramming
Injection
Synthesis
Extending existing classes and functions

In this session, we'll look at various ways that the latest features of Spring and Spring Boot can help with testing the tough-to-test portions of an application.

TBD

Contrary to popular belief, software engineering culture is not about the free food, open office spaces, and ping pong tables.

You can sense a great team culture when you observe it, and unfortunately you've probably experienced (or are currently experiencing) elements of a bad team culture. Not to worry - it's never too late to grab the reins and make small changes to steer your team in the right direction!

In this talk, Kate will highlight 8 tactical tips that attendees can implement on their teams immediately to help shape their team's culture!

Our industry never stops changing, but sometimes those changes are trivia and fluffy. Sometimes they are fundamental and enduring. This series is going to highlight some of the most important trends happening in the hardware, software, data and architecture spaces.

The LLVM Project has been around for over a decade, but is increasingly important as a compiler infrastructure to get reuse and portability, shared optimizations and a faster time to market. Many newer programming languages have chosen it as the basis of their toolchain including Swift, Julia, Rust and more. In this talk, we will talk about the tools, components and layers of LLVM and how it is helping usher in new visions of portability and reuse.

Modern software developers need modern tools to address the changing world around them.

We will cover:

The traditional architecture of compiler systems
The history of the LLVM project
An overview of how it is being used by pretty much everybody
The porcelain and plumbing portions of the toolchain
The role of optimization in compiler systems
Generating cross-compiled and portable code
How LLVM is going to help mediate the impact and effects of the changing hardware landscape

Rust has quickly become an incredibly popular language with exceptional tooling, documentation and a renowned community that welcomes and helps those who are new. It is intended as a systems programming such as C/C++ but has modern functional capabilities and intentionally-designed safety features.

It is for these reasons that large companies are starting to embrace Rust more than ever.

Modern software developers need to understand modern languages that change the game.

We will cover:

Getting set up with Rust toolchains
The Rust memory model
Common Gotchas
Generics
Functional Programming
Pattern Matching

While still new to most people, WebAssembly provides a formidable vision of safe, fast, portable code. Through clever choices and well-considered design, the basic vision allows us to target browsers as a platform using a variety of languages other than (but compatible with) Javascript. This technology coupled with advancements in the Web platform are setting up the future of Web-delivered applications to look more like (and likely to replace) desktop applications.

Modern software developers need to understand how just about every aspect of their industry is about to change.

We will cover:

The history and development of the WebAssembly MVP
An overview of what is possible in the browser including jaw-dropping demos
The basics of interacting between JavaScript and WebAssembly modules
A roadmap for the future of WebAssembly in the browser

Most people's understanding of WebAssembly is based upon a three year old W3C standard that is exciting in its own right. The more interesting possibilities, however, will be realized when WebAssembly escapes the browser and ushers in a whole new era of ubiquitous, secure computing. We will discuss the various container environments and how they will solve some of the more persistent issues with more conventional software development technologies.

Modern software developers need to understand how just about every aspect of their industry is about to change.

We will cover:

The problem of APIs with respect to portability
And overview of Web Assembly Services Interface (WASI)
It's portability promises
It's security promises
It's nano processor vision of software composition
Various WASI runtimes include:
wasmtime
wasmer
wasm3
lucet
Advancements and future directions
Interface Types
Multi-value Return Types
Module Linkage

Our industry never stops changing, but sometimes those changes are trivial and fluffy. Sometimes they are fundamental and enduring. This series is going to highlight some of the most important trends happening in the hardware, software, data and architecture spaces.

Modern software development needs to facilitate faster time to market, easier data integration and unlock new features for our applications, services and architectures. Incumbent to this vision is the need for a serialization format that is less about developer simplicity and more about flexible, evolvable and powerful systems. JSON-LD represents a vision for unifying the worlds of data, APIs and modern software systems. Useful in its own right, it also serves as the basis for much of the work being done in the standards world to engender annotations, activity streams, verifiable claims and more.

The modern software developer needs modern data models.

JSON-LD was developed in response to pushback to earlier standard serialization formats such as RDF/XML. It strikes a balance between developer-friendliness and support for LinkedData models built on standards. We are seeing a growing adoption of it as a format to project data and business value across a wider set of use cases than traditional Web APIs.

In this talk we will discuss the various JSON-LD file formats, tools for producing and consuming it, how it connects to the vision of the Semantic Web, how it can add value to any organization that needs to integrate information across sources with minimal need for consensus and coordination as well as how it is being used in an increasing number of important scenarios across industries.

We will cover:

The RDF data model
Various other standard serialization formats
JSON-LD as a Web developer-friendly serialization
Interacting with existing JSON APIs
The Updated JSON-LD 1.1 Specification
JSON-LD processing activities including: compaction, expansion, flattening and framing

I hope you'll join me on this exciting survey of Serverless Computing. When you think of Serverless you probably think of Lambda's or Cloud Functions but there's so much more to the Serverless ecosystem. During this session will look at Serverless Computing in all its various forms and discuss why you might want to use a Serverless architecture and how it compares to other cloud services.

Serverless is an exciting component of Cloud computing and it's a growing rapidly. During this session we'll look at all things Serverless and discuss how to incorporate it into your system architecture. We'll build a Lambda function during the presentation and talk about the pros and cons of Serverless and when you should use Serverless systems.

There are a few Serverless frameworks available today to make building a function easier than ever. We'll look at a couple of these frameworks, build a local, Serverless function and deploy it to AWS (if the network cooperates). Finally, we'll talk about performance considerations, how to structure your Serverless functions, and how to perform safe l

The cloud promises highly scalable infrastructure, economies of scale, lower costs and a more secure platform. When moving to the cloud, how do you take advantage of these new capabilities? How do you optimize your organization to make the best use of the resiliency and elasticity offered by the cloud?

Closely associated with cloud computing is Continuous Delivery, the automated process to get changes to your customers quickly, safely and in a sustainable way. Continuous Delivery was born in the cloud and is a great way to get ideas to your customers. There’s one catch, if you want to adopt a Continuous Delivery strategy, you need to build applications differently, your team structure needs to change and how you test and validate systems needs to adapt to these changes.

This presentation will look at how to transform your organization to take advantage of all the cloud has to offer. We’ll look at strategies for initiating your transition to the cloud, how to adopt a continuous delivery strategy, and how to manage cross-functional teams (sometimes called two-pizza teams) and projects when every team can deploy to production multiple times a day.

Managing teams in chaos will provide you the information needed to implement the two-pizza rule for your organization, enable your teams to work independently while still focusing on a common goal, and how to beat your competition to market.

“Forewarned is forearmed”
-Old Proverb

If it seems like humans are easy to deceive, it's because we are. The myriad traits that make humankind so eminently exploitable are practically baked into our DNA. Too often these same traits make it into the software we build. This session takes an entertaining look at why humans are so easy to fool and goes on to explore what we can do to overcome our weaknesses and build more secure software.

Security is everyone's responsibility but the burden disproportionally falls on us. As software engineers, we are the last line of defense in our organization. We build the technology and that technology is constantly scanned, probed, and tested. Building truly secure software requires going beyond mere functional requirements; it requires a complete shift in how we think about problems.

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.

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.

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

In tech teams it's a constant firefight. We react. Then we react to the reaction… the cycle continues. In all this noise, in all this chaos, how do we move forward. How do we remain proactive?

A great leader must be an enabler for the team. At times this means insulating the team from the noise. At other times it means improving the environment for the team. At all times, however, it requires setting clear priorities and conditions for success.

This session is focused on the art of moving forward in even the noisiest environments.

In this example-driven session, we'll use the Skill Flow Builder to create an interactive fiction game for Alexa from the ground up. We'll see how to manage the player's inventory of items, apply conditional effects, and add sounds and imagery to bring interactive fiction games to the voice-first generation.

“You are standing in a room with a table. On the table is black cylindrical device with the word 'Amazon' on the side. What do you want to do next?”

For as long as there have been computers, there have been computer games. Some of the earliest games were text-based adventure games like Colossal Cave Adventure and the Zork series. These games invited intrepid adventurers to use their imagination and wits to navigate complex worlds, solving puzzles to achieve the game's objective. Modern games are far more sophisticated than those early text adventures. Even so, there was still something amazingly endearing and fun about exploring caves and dungeons looking for treasure in games that were more like books where you are the main character.

Voice-enabled devices like Alexa are now breathing new life into the interactive fiction game genre. Rather than typing in your next move, you can speak it to Alexa; and she will describe the outcome to you, possibly with music and sound effects to set the mood. When played on a screen-based Alexa device, images can accompany the textual description for a richer immersion into the fictional world.

Machine Learning is clearly here to stay. While it is a far cry from actual Artificial Intelligence, it provides many invaluable and remarkable ways to learn from the data we are collecting about our customers, products and daily activities. The past afforded us machine learning libraries which became machine learning frameworks. Now, we are designing and building machine learning platforms that facilitate entire initiatives in reusable and extensible ways. We will discuss many of the drivers of modern machine learning systems and the platforms that we are seeing emerge.

Modern software developers who want to learn from their data need to understand the machine learning landscape.

We will cover:

The major languages and platforms involved in the machine learning space
Different approaches to data science and machine learning for
Individual analysts
Backend developers
API-oriented strategies for exposing Machine Learning capabilities
An overview of the major platforms for training and deployment across a variety of hardware and software architectures

How do you build a Cloud Native Applications? So many cloud deployments are a lift and shift architecture, what would it look like if you started from scratch, only used cloud native technologies? During this session we will compare and contrast two applications, one built using a traditional Java application architecture, the other using a cloud native approach. How does building an app for the cloud change your architecture, application design, development and testing processes? We’ll look at all this and more.

During this session we’ll dive in to the details of Cloud Native applications, their origins and history. Then, look at what’s involved when you move from an on-prem data center to the cloud. Should you change your approach to application design now that you are in the cloud? If so, what does a cloud-based design look like.

By the end of the session, you’ll have a better understanding of the benefits of a cloud native application design, how to best leverage cloud capabilities, and how to create performant Microservices.

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

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

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

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

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

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

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

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

Kubernetes is a powerful platform for running containers and distributing computation workloads across resources. A significant question is how do you get all your code to this platform, continuously.

In 2019 our community is bursting with new solutions to assist our delivery pipelines. While Jenkins is a dominant player, there is a growing array of new ideas and choices. From coding at your laptop to building containers to deployments, we will explore the various tools and techniques to reduce the delivery frictions.

Kubernetes is also a fitting platform for hosting your continuous tools, pipeline engines, registries, testing, code analysis, security scans, and delivery workflows.

From this session, you will understand the latest tools and techniques for pipelining on Kubernetes. Let's up the game on your Maturity Model.

Three evolutionary ecosystems work well together Java, Containers, and Kubernetes.

Past versions of Java were never designed to be “container aware”. This has led some to stray away from the JVM and consider other shiny languages. But wait, before you go, let's discover what Java 9, 10, 11, 12, 13 (…) has done to get our applications into efficiently distilled containers that pack nicely into Kubernetes.

Topics covered:

Microframeworks
Java9+, advancing beyond the troubled past
Java runtime to container runtime - a paradigm shift for “run anywhere”
Distillation pattern · small containers with a reduced attack vector
Multi-stage Dockerfile
JLink, JDeps
GraalVM
Hands on example

There are distinct advantages to a monolithic architecture, but when does the balance tip towards smaller targets? What cultural and devops practices are essential to success? How do you decide where to make the first slice, evaluate and iterate? All these questions will be answered, and we'll discuss pro tips from monolith-slaying case studies.

We'll look at all the factors that impact your migration from a Monolith to a Microservices architecture.

One of the biggest impediments to overall developer productivity and the overall success of the software organization is inefficient processes. Without the right tooling to get to the root of the problem, debugging build and test failures is incredibly frustrating and leads to delays in shipping software.

In this workshop, you’ll work through examples using Maven, Gradle, and Gradle Enterprise on our real data and that of some popular open source projects. You'll learn how to measure build speed and reliability, which metrics are important, how to apply these analyses to your own builds, and how to use build caching to make those builds dramatically faster enabling your team to achieve better developer productivity.

Would Chuck Norris ask you to come hear him speak at a conference? No, he wouldn't. He would TELL you that you're coming, and then roundhouse kick you in the face if you gave him any more lip.

“What would Chuck Norris do?” is a philosophy this session will cover in depth. Other topics include: badass vs a-hole, human duck typing, the art of [not] caring, instrumentality, and what your facial hair says about you. You won't learn any new code in this session, but you might unleash a Pandora's box of awesomeness that will change the way you interact with your coworkers forever.

Twin Cities Software Symposium

March 6 - 8, 2020

TEST