“Excellent!”
DevTernity is the #1 international software development conference.
Through a series of inspiring talks, discussions, and practical masterclasses led by top minds of our industry, you'll develop skills paramount to your success – coding, architecture, engineering practices, and tech leadership.
Start preparing for an architect, engineering leader, or CTO role today.
Author of Clean Code, Clean Coder, Clean Architecture, and Clean Agile
Author of Modern Software Engineering and Continuous Delivery
Creator of Ruby on Rails, Co-founder @ Basecamp, Hey
Principal Architect @ Microsoft, Blogger, Podcaster
Author of Architecture and Programming Books, Consultant, Trainer
Author of Building Microservices and Monolith to Microservices
Author of 99 Bottles of OOP and Practical Object Oriented Design
Principal @ Hollub Associates Ltd, Author of Multiple Books
Co-inventor of Microservices, Principal Consultant @ Fred George Consulting
Originator of BDD, Mentor, Principal Consultant @ Dan North & Associates
Game Designer, Programmer, Co-founder of id Software
Distinguished Engineer, Staff Developer Advocate @ Google
Staff Engineer @ Coinbase, Core Contributor @ Ethereum
Software Coach, Mentor, Consultant, TDD Trainer
Author of The Software Architect Elevator and Enterprise Integration Patterns
Author of Code as a Crime Scene, CTO, Creator of CodeScene
Software Craftswoman, Tech Influencer @ Instagram
Director of Engineering @ Nubank, ex-Apple, ex-ThoughtWorks
Head of Developer Relations at Amazon Web Services (AWS)
Principal Engineer, Global Integration Architect @ Just Eat Takeaway
Developer Advocate @ Atlassian, ex-MongoDB
Chief Architect @ Headspring, Microsoft MVP, Creator of MediatR and AutoMapper
Creator of Htmx, Principal @ Big Sky Software
Lean has been applied as a toolkit to fine-tune development processes and organisational workflow, but what does it mean when we apply the practices to the detail of the code, the practices used to develop it and the people who develop it? What does Lean Code and its creation look like? There is a need to move beyond often separated worlds of software craft and agile development, to properly embrace code in its detail, but to also connect it more completely to the flow of business and the intelligence of people around it. To move beyond simple exhortations of clean code to something more human. This talk offers a fresh look at Lean principles and practices from the perspective of the code and the coder, rather than the usual scale of the organisation and the development process.
Code quality is an abstract concept that fails to get traction at the business level. Consequently, software companies keep trading code quality for new features. The resulting technical debt is estimated to waste up to 42% of developers’ time, causing stress and uncertainty, as well as making our job less enjoyable than it should be. Without clear and quantifiable benefits, it’s hard to build a business case for code quality.
In this talk, Adam takes on the challenge by tuning the code analysis microscope towards a business outcome. We do that by combining novel code quality metrics with analyses of how the engineering organization works with the code. We then take those metrics a step further by connecting them to values like time-to-market, customer satisfaction, and road-map risks. This makes it possible to a) prioritize the parts of your system that benefit the most from improvements, b) communicate quality trade-offs in terms of actual costs, and c) identify high-risk parts of the application so that we can focus our efforts on the areas that need them the most. All recommendations are supported by data and brand-new research on real-world codebases. This is a perspective on software development that will change how you view code. Promise.
Some advice is timeless; it ages like a fine wine. Each time you revisit it you discover a nuance, a new connection to something else. As you grow, the advice is waiting there to reveal another layer you had never considered.
Some advice is a product of its time; it ages like milk. It starts fresh, then it begins to smell, and eventually it rots and can even become harmful! It made sense in the context and constraints of its day, but things have changed and it is no longer relevant.
As Admiral Grace Hopper famously said: "The most dangerous phrase you can use is 'But we've always done it this way!'" Daniel believes this is why so many people have an almost religious zeal for SOLID, Scrum, and other antiquities.
In this session, Daniel argues from first principles why ideas like SOLID and Scrum made sense in their day, over a quarter century ago, and why they have been superseded and should now be considered harmful. For contrast, he suggests Continuous Delivery and lean product development are ageing like fine wines. If there is time, he will show how methods like SAFe have never been relevant and never will be, but can be very appealing to a certain kind of manager.
Many large enterprises are feeling pressure: digital disruptors attack with brand-new business models and no legacy; the Facebook generation” has dramatically increased user expectations; and access to state-of-the-art technologies has been democratized by cloud providers. This is tough stuff for enterprises that have been, and still are, very successful, but are built around traditional technology and organizational structures. “Turning the tanker”, as the need to transform is often described, has become a board room-level topic in many traditional enterprises. Chief IT Architects and CTOs play a key role in such a digital transformation endeavor. They combine the technical, communication, and organizational skills to create business value from a tech stack refresh, to look behind buzzwords like “agile” and “DevOps”, and to build a technology platform that assures quality while moving faster. They do so by riding the “Architect Elevator” from the penthouse, where the business strategy is set, to the engine room, where the enabling technology is implemented. I rode that elevator for 5 years in a major financial services organization and am now advising major corporations on their digital journey. I collect stories from the daily life of IT transformation and package them in lighthearted, but meaningful anecdotes.
Since Kent Beck wrote the book on TDD in 2002 a lot of words have been dedicated to the subject. But many of them propagated misunderstandings of Kent's original rules so that TDD practice bears little resemblance to Kent's original ideas. Key misunderstandings around what do I test, what is a unit test, and what is the 'public interface' have led to test suites that are brittle, hard to read, and do not support easy refactoring. In this talk, we re-discover Kent's original proposition, discover where key misunderstandings occurred and look at a better approach to TDD that supports software development instead of impeding it. Be prepared from some sacred cows to be slaughtered and fewer but better tests to be written.
If you've been in the tech industry for any length of time, you've probably been asked to participate in interviewing. Lucky folks will receive some basic training from their employer, but most are expected to just figure it out. It can be time-consuming, nerve-wracking, and tedious. You probably don't enjoy doing it, and that can lead to bad hires and painful experiences. Kris has participated in more than 250 interviews at AWS - as both an interviewer and a hiring manager - and has finally come to embrace the process. She'll provide practical tips you can use to conduct more effective interviews, saving you time and making the whole process a lot more enjoyable.
In this session, continuous delivery pioneer David Farley illuminates durable principles at the heart of effective, modern software development.
He distills the discipline into two core exercises: learning and exploration and managing complexity.
For each, he defines principles that can help you improve everything from your mindset to the quality of your code and describes approaches proven to promote success.
Big Bang rebuilds of systems are so 20th century. With our users expecting new functionality to be shipped more frequently than ever before, we no longer have the luxury of a complete system rebuild. In fact, a big bang migration of a monolithic architecture into a microservice architecture can be especially problematic, as we’ll explore in this talk.
We want to ship features, but we also want to improve our architecture, and for many of us this means breaking down existing systems into microservices. But how do you do this while still regularly releasing new features?
In this talk, I’ll share with you some key principles and a number of patterns which you can use to incrementally decompose an existing system into microservices. I’ll also cover off patterns that can work to migrate functionality out of systems you can’t change, which are useful when working with very old systems or vendor products. We'll look at the use of strangler patterns, change data capture, database decomposition and more.
Software development has become more complex over the years: Building and running a distributed architecture in the cloud, ensuring observability, discussing user experience with design and product, and keeping a healthy balance between dev speed and code quality isn’t easy. Just be agile and practice DevOps, they say.
Join Sven and learn how great software teams measure and improve their developer productivity, coordinate work across teams, run microservice teams, and create a healthy and joyful engineering culture. Always backed up by data instead of opinions.
The talk will demonstrate how teams at Atlassian and other tech companies faced development challenges, reinvented themselves, and created new ways of working to get s%*t done.
Robert C. Martin (Uncle Bob) reintroduces Agile values and principles for a new generation of programmers and nonprogrammers alike, striping away misunderstandings and distractions that over the years made using Agile difficult.
Moving from a layered architecture to a vertical slice architecture can be a bit daunting. We remove abstractions, complex structures, and focus building on the axis of change, then what's next? What new structures, patterns, and policies will need to be introduced in this style of architecture? How will we deal with common business functionality, and where do concepts like CQRS and DDD fit in? In this session, we'll introduce the idea of vertical slice architectures, and dive into the patterns, tools, and techniques used with slices. We'll also cover how you can fit vertical slices into different kinds of systems, from desktop, SPA, and normal MVC applications. Finally, we'll look at some of the new challenges that come with slices and layers, and how a different approach provides a much more maintainable end result.
Looking at my LinkedIn Profile and seeing my current title as "Director of Engineering," you might feel that my career was an easy straight line from Dev to Director. You are wrong!
I had many turns back and forth. In the 15 years of my career, I went from being The "Tech Support" guy to Programmer to Project Manager to QA, back to Engineering/DevOps and Agile Consulting, and finally to Engineering Management in the Mobile space, where I finally found myself in the last five years.
In this talk, I will tell you how all the left and right turns I took on the road prepared me to be where I'm with a much more solid foundation than the 'straight-line career path approach" would ever do.
In theory, object-oriented applications consist of small, interchangeable objects which know almost nothing about one another. In reality, many apps contain big classes full of long methods built of many conditionals. Our classes act more like procedures than objects; they know too much, they contain code we can't reuse, they're hard to change and they get worse every time we do so. This talk uses the principles of object-oriented design to break ugly procedures into pleasing objects which have just the right balance of knowledge and ignorance. It bridges the gap between theory and practice and reveals a few simple secrets of OOD that you can use to convert confusing, unmaintainable faux-OO code into understandable, reusable, easily testable objects.
Meet our special guest – David Heinemeier Hansson – the creator of Ruby on Rails, CTO and co-founder of Basecamp and Hey. In this fireside chat we'll be talking about the future of Rails, why and how Basecamp has moved from cloud to bare metal, what makes a good developer, hiring, self-development, and life.
Transformations are difficult, and often simply fail. After all, change is usually disruptive. Even an organization that wants to embrace change can see mediocre results. The underlying causes vary from ignorance on how to transform, to full and hostile resistance. In this talk, we will discuss the various causes and the strategies we can use to overcome (or at least mitigate) this resistance to change, and create meaningful transformations with our clients.
Every month, someone new asks me the question, "How do I convince my manager to let me refactor?" While it's true that a manager shouldn't constrain the programmer's plans to deliver high-quality code, the fact remains that some organisations allow their managers to assert this level of micro-control. In this talk I outline a set of models for justifying evolutionary design with basic economic concepts that relate directly to delivering, planning, and funding software projects. This talk will provide you with a solid argument to meet any skeptic's rational objections to writing tests first and letting both low-level design and architecture emerge.
SPA architecture and the JSON API have allowed much more sophisticated web applications to be built and the approach has been formalized by libraries such as React and Vue. In the last few years, however, we have seen the rise of an associated phenomena: Javascript Fatigue in which developers admit to being overwhelmed by the complexity of the SPA architecture. Join this talk to learn how to compress the complexity of web development without losing all the benefits of SPA.
Most have learned to communicate with compilers but not people, so they lack the skill to progress their ideas and solutions beyond the confines of a small team, code base, or the outside world. Code is going to continue to get easier to write, test, and deploy, and that's going to require the future of software development to change from spending most of your time in an IDE to in front of people. As the saying goes: "some people have ideas and some ideas have people", and it's going to require an additional set of skills to do that. Let'l talk about these skills.
As information workers, we are asked to absorb even more information than ever before. More blogs, more documentation, more patterns, more layers of abstraction. Now Twitter and Facebook compete with Email and Texts for our attention, keeping us up-to-date on our friends dietary details and movie attendance second-by-second. Does all this information take a toll on your psyche or sharpen the saw? Is it a matter of finding the right tools and filters to capture what you need, or do you just need to unplug.
As co-founders of id Software, John Romero and John Carmack created the code behind the company's seminal titles. The principles they defined through experience in id’s earliest days built upon one another to produce a unique methodology and a constantly shippable codebase. In this talk, John Romero discusses id software’s early days, these programming principles and the events and games that led to their creation.
This keynote presents my (and many other's) thinking about #NoEstimates. It argues that estimation is a bad thing, particularly in the Agile world, and presents ways to plan that don't involve estimation.
Every system has an architecture, whether accidental or intentional, and regardless of whether it was put in place by a nominated architect or whether it emerged from the decisions and discussions of a team.
All too often the focus of what is often described as architecture is centred around a specific set of platform technologies, which forms only one part of the set of concerns an architecture should. And all too often architecture is seen as a separate concern from development process, whereas the two are intertwined — what you build is influenced by how you build it, and vice versa.
The course covers a wide range of topics through a number of practical exercises, with plenty of time dedicated to group discussion:
And much more!
Understand the concepts of DDD but feeling overwhelmed to implement? Feeling overwhelmed by complex examples and can't connect how to implement DDD in your project? Looking for more concrete guidance on the concepts and principles of DDD and want to learn how to connect it to real-world code? If this sounds familiar, then this masterclass is for you.
We cover both the theory and patterns of DDD, and connect it to code with hands-on examples in .NET 6.
In this masterclass, you'll learn:
We spend some time on the theory and concepts of DDD and then applying it to a real-world, complex example with hands-on code exercises.
We will be using .NET as our development platform, but the learned concepts will be applicable to other languages and platforms.
In this masterclass you'll learn the essential parts of Kotlin: an elegant, powerful, and a pleasant language to work with. We'll focus on fundamental parts of Kotlin, it's imperative and functional programming capabilities, how Kotlin provides elegance without compromising performance by tactfully channeling the JDK. We will also dive into how to interact between Kotlin and Java code.
You'll learn:
This masterclass is led by Marcin Moskala, an official JetBrains partner for Kotlin training, the author of Effective Kotlin: Best Practices, Kotlin Coroutines, and Advanced Kotlin books.
In this course, we discuss complex tradeoff decisions involved in making evolutionary design a core, everyday programming practice. You’ll learn how to start to make the design flex, how to balance production with protecting your production capacity, and how to expand your view from the elements of simple design to higher-level principles of modularity.
Key topics:
And much more!
Many of us are familiar with the challenges posed by legacy applications. Some have the luxury of starting with a clean slate, but over time, even greenfield projects can morph into something reminiscent of the legacy apps we once struggled with. These shared issues often lead both legacy and greenfield applications to a state where implementing even a minor change becomes a painful endeavor.
How can we circumvent these challenges? What path should we tread? What are our goals? What defines an exemplary application? Let's collaboratively construct such an application during this masterclass!
Join us for this masterclass where you will delve into practices that every professional developer should not only comprehend but also implement while building a Java-based business application. Throughout the course, you will:
This masterclass is dedicated to developers able to code and complete exercises in Java.
Embark on this journey to refine your coding practices and emerge as a more adept professional developer!
Prioritizing technical debt is a hard problem as modern systems might have millions of lines of code and multiple development teams — no one has a holistic overview. Fortunately, a new set of techniques known as behavioral code analysis are here to help. These combine quality metrics with data on how the engineering organization works with the code. You can then prioritize improvements and risks so that you can balance short- and long-term goals guided by objective data. This new perspective on software development will change how you view code.
Together we will:
Go through real-world case studies from both Microservices and Monoliths.
And much more!
We all have an opportunity every day to make a postive impact on folks around us. These are often called "soft skills," but they can be some of the hardest to learn! We could call them "people skills," "essential skills," or "core skills." But, how about "SKILLS OF AWESOMENESS?" Yes, what we all need is more ways we can be awesome to each other, and awesome together.
You'll learn:
And much more!
Through a series of practical exercises, we will discover and discuss the most important and relevant topics you want to cover, so that you can get the most value out of this masterclass!
The masterclass is led by David Neal – #1 speaker of 2021.
Functional programming can be an excellent approach to designing decoupled, reusable systems with a rich domain model. This masterclass will show you why and how.
You''ll learn the core concepts of FP, and how to apply them to crafting domain logic, capturing business rules, designing business workflows, error handling, and much more, including:
We will be using F# as our development language. The principles will be applicable to other languages. No experience with F# needed.
In this masterclass, I’ll take you through three different styles of enterprise service architecture: modular monoliths, distributed synchronous systems, and event-driven systems.
Together, we will design a non-trivial backend system and find out the strengths and weaknesses of each architectural approach. We will discuss the typical mistakes and problems developers face during service architecture design and how to solve them. You will learn how to choose the best architecture style for your project, and how to design hybrid solutions, leveraging the best parts of each architecture style.
Topics include:
This masterclass covers fundamental concepts, relevant to all programming platforms and languages; developers and architects with different backgrounds can attend.
Increasingly developers are relying on distributed architectures to solve the problems of scaling their applications and their development teams. But that means they now have to consider the problem of getting the parts of their systems to talk to each other.
In this masterclass, we will look at distributed systems, such as microservices, and how we integrate them. We will understand why we would prefer messaging, the fundamentals and key concepts of messaging, and how to build an event-driven architecture.
Topics covered include:
We will use Rabbit MQ message broker. Hands-on exercises are offered in C#, JavaScript, Python and Go.
You can’t simultaneously fight your code and be Agile—it slows you down too much. Your code’s design must evolve incrementally along with your understanding of the product. In this masterclass, you’ll learn everything you need to create highly adaptable designs. Along the way, you’ll also experience Event Storming and other Domain-Driven Design techniques.
You’ll learn:
In all, you’ll learn how to build a coherent and highly maintainable system and architecture that can easily accommodate changing requirements and grow incrementally as the system evolves
Are you struggling with your codebase which causes problems like poor maintenance, unreadability, performance, and poor testability? After this masterclass, you will be ready to identify and repair architectural and code root causes of those issues using proven patterns and techniques from Domain-Driven Design, Test-Driven Development, Object-Oriented Programming, and modularization.
During code exercises, we will walk through solutions to issues like:
The masterclass will start with code that represents a huge legacy system that some of us have to work with on a daily basis. We will gradually refactor it and not only introduce patterns like CQRS, aggregates, policies, and parallel change, but also walk through how to talk about refactoring, technical debt, and how to sell our ideas to management.
The course is for developers able to code and complete exercises in Java, C#, or PHP.
In this masterclass, guided by continuous delivery expert David Farley, we'll learn durable principles at the heart of effective, modern software development.
Farley's techniques cohere into a unified, scientific, and foundational approach to solving practical software development problems within realistic economic constraints.
The topics include:
And much more!
In this masterclass, through code examples, hands-on exercises, and discussions you''ll learn how to design a clean and pragmatic architecture.
The topics include:
This masterclass uses Java as a reference language.
* Additional 20% VAT charge applies to EU individuals, EU companies VAT non-payers, and companies in the Republic of Estonia.