Kirk Knoernschild
Software Developer & Mentor
Kirk is software developer with a passion for building great software. He takes a keen interest in design, architecture, application development platforms, agile development, and the IT industry in general, especially as it relates to software development. His recent book, Java Application Architecture was published in 2012, and presents 18 patterns that help you design modular software.Presentations
Agile Architecture
3:15 PM MDT
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.
From Mono to Micro - A Demonstration of Architectural Agility
5:00 PM MDT
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.
Building 12 Factor Apps with Java
9:00 AM MDT
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.
Java 9 - The Jigsaw Module System
10:45 AM MDT
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.
Books
Java Application Architecture: Modularity Patterns with Examples Using OSGi (Robert C. Martin Series)
by Kirk Knoernschild
“I’m dancing! By god I’m dancing on the walls. I’m dancing on the ceiling. I’m ecstatic. I’m overjoyed. I’m really, really pleased.”–From the Foreword by Robert C. Martin (a.k.a. Uncle Bob)
This isn’t the first book on Java application architecture. No doubt it won’t be the last. But rest assured, this title is different. The way we develop Java applications is about to change, and this title explores the new way of Java application architecture.
Over the past several years, module frameworks have been gaining traction on the Java platform, and upcoming versions of Java will include a module system that allows you to leverage the power of modularity to build more resilient and flexible software systems. Modularity isn’t a new concept. But modularity will change the way we develop Java applications, and you’ll only be able to realize the benefits if you understand how to design more modular software systems.
Java Application Architecture will help you
- Design modular software that is extensible, reusable, maintainable, and adaptable
- Design modular software today, in anticipation of future platform support for modularity
- Break large software systems into a flexible composite of collaborating modules
- Understand where to place your architectural focus
- Migrate large-scale monolithic applications to applications with a modular architecture
- Articulate the advantages of modular software to your team
Java Application Architecture lays the foundation you’ll need to incorporate modular design thinking into your development initiatives. Before it walks you through eighteen patterns that will help you architect modular software, it lays a solid foundation that shows you why modularity is a critical weapon in your arsenal of design tools. Throughout, you’ll find examples that illustrate the concepts. By designing modular applications today, you are positioning yourself for the platform and architecture of tomorrow. That’s why Uncle Bob is dancing.