Kirk Knoernschild

Agility Through Modular Architectures - From Modular Monoliths to Microservices

Monday, 9:00 AM EST

No single architectural style solves all needs. Though microservices have taken the developer community by storm recently, they are not always the optimal solution. In some cases, a more monolithic architecture may be more suitable short term. Or perhaps a more traditional system of web services that allow you to leverage existing infrastructure investment is preferable. Fortunately, proven architectural practices allow you to build software that transcends specific architectural alternatives and develop a software system that gives the development team the agility to shift between different architectural styles without undergoing a time-consuming, costly, and resource intensive refactoring effort. Modularity is the cornerstone of these alternatives.

In this workshop, we will examine the benefits and drawbacks of several different modular architecture alternatives and we’ll explore the infrastructure, skills, and practices necessary to build software with each of these alternatives. There will be straightforward exercises and demonstrations that show the alternatives and how to create software that provides the architectural agility to easily shift between architectural alternatives.

Topics discussed include:

• Defining architectural agility
• Dissecting the monolith
• Exploring microservices
• Other architectural alternatives, including traditional web services
• Development infrastructure requirements
• Measuring architectural integrity

Fixing Software Architecture

Tuesday, 8:30 AM EST

Current approaches to software architecture do not work. As we challenge some of the sacred truths of software development (reuse, failure prevention), we examine how current approaches to software architecture must also change.

Software systems evolve but current approaches to architecture do not factor in this inevitable evolution. Attempts to define the architectural vision for a system early in the development lifecycle does not work. Big architecture up front (BAUF) does not work. To compound the challenge, agile methods offer very little guidance on how to effectively do software architecture.

In this session, we examine several actionable principles that will help you create software architectures that possess the ability to continuously evolve.

Modularity: The Foundation of Modern Architectures and Platforms

Tuesday, 10:30 AM EST

Modularity is the common aspect of modern architectures and platforms. Understanding the role of modularity when making architecture decisions is critical.

The architecture paradigms we’re using are changing. The platforms we deploy our software to are changing. We are confronted with several new architecture paradigms to choose from, such as microservices and miniservices. Yet should we automatically discard some of the proven architectures we’ve used in the past, including more traditional web services? Likewise, new platforms, such as cloud, complicate the decision. Yet, at the heart of this transformation is modularity.

In this session, we’ll explore how modularity is impacting the platforms we are leveraging and the architecture paradigms we’ll use and offer a clear roadmap with proven guidance on navigating the architecture decisions we must make.

Migrating to the Java Platform Module System

Tuesday, 1:30 PM EST

The Java Platform Module System was available with Java 9. In this session, we provide a clear framework for migrating your applications to JPMS.

With Java 9, modularity became a first class construct on the Java platform…Finally! In this session, we explore the default module system and examine how to migrate applications. We'll start by examining the first step in the migration and then examine several strategies for migrating your application.

Finally, we will explore advanced concept of JPMS that bring greater structural integrity and encapsulation to the Java platform.

Java MicroProfile - Enterprise Java Meets Microservices

Tuesday, 3:15 PM EST

Organizations have a lot of expertise in Java EE. With MicroProfile, developers can leverage this expertise to build cloud-native applications.

Few consider Java EE as a viable option for building microservices. Yet developers have a wealth of knowledge and skill that they may want to leverage to build microservices as they adopt cloud-native architecture patterns. The MicroProfile is a baseline platform definition that optimizes Enterprise Java for a microservices architecture and delivers application portability across multiple MicroProfile runtimes. In this session, we will explore the MicroProfile and examine it’s viability for using Java EE to build cloud-native applications.

Building 12 Factor Apps with Java

Tuesday, 5:00 PM EST

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.