Jeremy Davis
Solving things, slinging opensource
Decatur, Georgia, United States
Actions
Jeremy is a Principal Architect at Red Hat. He helps Red Hat's customers to design and deliver applications, works with Red Hat engineers to create great products, and occasionally speaks at conferences.
Before joining Red Hat he wrote a lot of code in C, C#, Groovy, Java, JavaScript, Objective-C, Perl, PHP, Python, Ruby, Visual Basic; mostly Java.
He currently co-lead Red Hat’s Application Development Community of Practice, and used to lead Red Hat's Microservices Community of Practice and the Business Rules and Workflow SME group. He has recently spent a lot of time with Quarkus and Kubernetes.
He recently acquired a Marshall amp after relying on Fenders for years.
Links
Awards
Area of Expertise
Topics
Backends for Frontends: Microservices’ Bestie
“Any problem in computer science can be solved with another layer of indirection.” - David Wheeler (maybe)
Mobile application developers created the Backends for Frontends Pattern as a layer of abstraction between mobile clients and backend services.
In Microservices Architectures the Backends for Frontends pattern helps development, testing, and deploying user interfaces and insulates end users from breaking changes.
In this talk we will build a BFF, introducing techniques and tools along the way including:
* comparing REST, gRPC, and GraphQL
* reactive approaches to service calls
* avoiding coupling between BFF’s
* approaches for testing and mocking services
You will leave with an understanding of where and how to use the Backend for Frontends Pattern, how to get started, and how to securely put your BFF into production.
Source and infrastructure code will be on GitHub.
Walking to School in the Snow or What to Do When You Aren't Building Bridges with Bricks
Roman architects and engineers built colosseums, bridges and aqueducts that have lasted for millennia. Most software applications last… not as long.
The discipline and processes of software engineering are continuously evolving to deliver faster results. Meanwhile application architecture is undergoing a paradigm shift as the enterprise embraces the cloud.
What does engineering discipline look like when time to market is more important than time in existence?
This talk looks at 5 emerging architecture trends geared towards delivering business value faster and what these trends mean for developers:
* Putting Architects in the Elevators
* Composable Organizations
* Product vs. Project Thinking
* Paved Roads and Golden Paths
* Data Meshes
From MVC to DDD (and Hexagonal Architecture)
Refactoring from MVC to DDD with a bit of Hexagonal Architecture. No slides. All live code with Quarkus, Supersonic Subatomic Kubernetes Native Java
MVC apps make up an enormous percentage of enterprise applications. From Struts to Spring MVC to Jakarta MVC this pattern has been implemented by developers for 20+ years. MVC apps are (relatively) easy to build, easily understood because of their ubiquity, and (relatively) easy to maintain.
However, the MVC pattern’s advantages disappear with complicated business logic, or in a complicated “domain.” Domain Driven Design excels in complicated environments, and provides a structure that makes coding in a difficult domain significantly easier and faster.
In this presentation I will build a basic MVC app and refactor it to adhere to DDD principles implementing Aggregates, Repositories, Value Objects, and Services. And I’ll take a look at how DDD Services enable extensibility with Hexagonal Architecture.
No slides; all code.
I will also show off Quarkus in dev mode. Quarkus dev mode makes this possible look easy
Event Driven Architecture with Quarkus, Kafka, and Kubernetes
Event Driven Architectures are distributed, asynchronous, and scalable. The rise of real time decision making, the on-demand economy, explosion of data, and the adoption of microservices have all driven the adoption of event driven architectures.
This presentation is built on an event driven coffee shop built with Quarkus and Kafka and deployed on Kubernetes (OpenShift.)
We will cover the basic building blocks of event driven architecture and tackle the most common pitfalls of adoption EDA:
Domain Driven Design
Event Storming
Kafka or REST (or other things)
Asynchronous testing
Deploying on Kubernetes
At the end of this session you will be able to get started building your own event driven, streaming applications, apply Domain Driven Design to Event Driven Architectures, and have a few tips for TDD in an event driven Kubernetes world.
A Live Coding Introduction to Domain Driven Design and Hexagonal Architecture
Domain Driven Design excels in complicated environments, and provides a structure that makes coding difficult business logic significantly easier and faster. Domain Driven Design also aligns perfectly with microservices architectures, and the rise of microservices has created a renewed interest in DDD.
Hexagonal Architecture (or Ports and Adapters) excels at producing loosely coupled, interchangeable components that fit well with DDD.
In this presentation I will build a basic app that implements DDD principles with Aggregates, Repositories, Value Objects, and Services and implements Hexagonal Architecture for easy extensibility.
No slides; all code.
7 Strategies for Building Majestic Monoliths
“You shouldn't start a new project with microservices, even if you're sure your application will be big enough to make it worthwhile.” - Martin Fowler, who coined the term “microservices” (https://martinfowler.com/bliki/MonolithFirst.html)
In this talk we will follow Mr. Fowler’s advice and build a Majestic Monolith (https://m.signalvnoise.com/the-majestic-monolith) that can easily be refactored to microservices if and when the need arises.
We will look at 7 strategies for successful majestic monolith building:
* Using Domain Driven Design and Bounded Contexts
* Putting API’s first
* Making data autonomous
* Avoiding bottlenecks
* Committing to continuous integration
* Embracing and measuring code quality
* Adopting the Citadels and Outposts pattern
Of course tools are required to implement strategies, and in this talk we will use Quarkus, the Supersonic, Subatomic Kubernetes Native Java Framework, but you will be able to apply these strategies with almost anything
There will be a bit of live coding and a lot of code available on GitHub
DeveloperWeek Europe 2023 Sessionize Event
Devnexus 2023 Sessionize Event
Jeremy Davis
Solving things, slinging opensource
Decatur, Georgia, United States
Links
Actions
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top