There are many paradigms and movements in software development, always something else to absorb. OO, Functional, Agile, DevOps, Product teams, what’s next? Or: what’s behind them all? Maybe a few core principles can get us the best of these movements, and beyond them.

In this keynote, Jess gets at three principles, and then one. Then she illustrates how this one principle is wider than software and exists in the design of our lives.

What does it mean for a language to be designed for embedded or IoT use? An insider takes a look at the guts of the Toit system to see the design choices that minimize memory use and maximize performance for a programming environment that has a 21st Century feel on fingernail-sized devices.

We've all experienced heartbreak, spent long nights wallowing away in disappointment, entire weeks ruined by the smallest of mistakes, all the time wondering why on earth you keep trying when nothing seems to change. Data systems. They break your heart. In this session we'll dive into some typical data systems, based on actual production case studies. We'll discuss why they are so painful to work with, explore ways to fix them (or leave them) and reflect on why we seem to keep making the same mistakes. Let's learn how to get past them to build the data systems of our dreams.

We all know what a product is. We buy and use them all the time. But, what does it mean where you work? Why is there so much resistance to creating great products where you work? This talk focuses on how to recognize the mindset that gets in the way of effective product design and development. You may be guilty of the mindset yourself. I know I am. We’ll talk about how to recognized when you, your leadership, and the processes you use have slipped into anti-product mode. And, give you ideas on what you can do to fight it.

Spring is all about helping developers get to production quickly and safely. These days, "production" is all but guaranteed to mean Kubernetes, and Spring has you covered. Join me, Spring Developer Advocate Josh Long (@starbuxman), and we'll look at how Spring Boot makes writing blisteringly fast, cloud-native, and scalable services more effortless than ever.

Agile doesn’t just need a reboot, it needs a rethink. The word isn’t a noun, a management fad, a manifesto or even a framework. One may be agile and never sprint, conduct a standup meeting or be part of a release train. The dread that many experience from commercial agile approaches is unfortunate and unnecessary. Agile is an adjective: an agile surgeon, dancer, athlete, team, etc. Being agile is joyful and is applicable to all living beings. So how do we tap into that joy? In this new talk, based on my forthcoming book, Joy of Agility, you will learn the definition of agile, six essential mantras for becoming agile, and several of my favorite stories that illustrate agility. You will leave this talk with a clear understanding of what it means to be agile and how to move towards the joy that flows from genuine agility.

Previous studies have shown that there is a non-trivial amount of duplication in source code. We recently analyzed a corpus of 2.6 million non-fork projects hosted on GitHub representing over 258 million files written in Java, C++, Python and JavaScript, and found a large amount of duplication, much more than we anticipated. This finding made us be much more careful when using open source repositories for drawing statistical conclusions, especially now -- in the age of machine learning. In this talk, I will present our GitHub study, and will briefly cover some of our most recent work on extending duplicate detection to the machine learning models themselves.

Octopus Deploy, a remote-first software company, is on a journey to scale from an engineering team of 30 to 130 over 2 years. Engineering management is a critical part of that journey. We want to build a workplace where every engineer has a good manager. To that end, we split apart the technical lead and engineering manager roles. In this talk, Trish will discuss the positive outcomes, the challenges of this approach, and the definition of the Octopus Deploy Engineering Manager role. In true Octopus form, this role definition is shared publicly on their Github account for anyone to use.

The pursuit of faster performance in computing is the driving reason for many new technologies and updates. This talk discusses performance improvements now underway that you will likely be adopting soon, for processors (including 3D stacking and cloud vendor CPUs), memory (including DDR5 and high-bandwidth memory [HBM]), disks (including 3D Xpoint as a 3D NAND accelerator), networking (including QUIC and eXpress Data Path [XDP]), runtimes, hypervisors, and more. The future of performance is increasingly cloud-based, with hardware hypervisors and custom processors, meaningful observability of everything down to cycle stalls (even as cloud guests), and high-speed syscall-avoiding applications that use eBPF, FPGAs, and io_uring. The talk also discusses where future performance improvements might be expected, with predictions for new technologies.

What does it take to become a highly productive software developer? How do you maximize your personal output? How do you reach optimal impact? How do you make your team more productive? How do you influence an organization? How do you define success? How do you handle disappointment? Do you really want to become a 10X developer?

What's the difference between mentorship and sponsorship? What's the role of the senior engineer as a colleague to an early-in-career engineer? What must we do to welcome the next generation of creators, and what are your responsibilities? Let's facilitate a welcoming culture of learning and exploration and normalize not knowing the answer.

Software architecture emerged in the 1990s and has been evolving ever since, from a directive, up-front activity, where a single architect created the architecture, which was then implemented by others, to today’s team-based adaptive architectural approaches where architecture is a shared activity owned by the entire team. In this talk, we’ll explore the architectural practices that deliver architecture as a “shared commons” which supports the Agile+DevOps ways of working needed for success in the digital age.

As our realestate.com.au audience has grown, so have the teams that build it. In this talk, I’ll present how we’re building and adopting micro frontends, design systems, and tooling together in our frontend platform products to build web and native experiences at scale. I’ll present the drivers behind our frontend platform strategy the lessons we’ve learnt along the way.

While microservices enabled REA to scale our technology and teams on the backend, our web and native apps have faced the scaling challenges of working in monoliths. Splitting out standalone experiences to solve this brought both technical and product divergence which led us to adopt an internal frontend platform strategy including design systems and micro frontends across React, iOS, and Android.

The Killer C’s are like cholesterol: there’s the good kind and the bad kind. When the bad kind gets out of control, it can destroy systems and even whole companies. What can we do to lower complexity and harmful coupling? How can we encourage cohesion and healthy coupling? In this talk, Michael will describe the nature of coupling, cohesion, and complexity and what makes the difference between clogging arteries and running marathons.

All systems reflect the history and evolution of their designers, as well as their constraints in time, cost, team composition, and organizational factors. The architecture of our applications documents our attempts at making tradeoffs to balance our needs and limitations. If we get it right our systems will support 1 or 2 orders of magnitude growth. But when growth accelerates, systems will show signs of stress. Where and how this stress will degrade your application is a challenge to predict, or even detect in real time.

Setting a course of action to meet new growth can be difficult. Architectural changes are even more burdensome for hyperscale systems. Tolerances are lower and component changes must not regress in performance. Edge cases that are one-in-a-million events become common. But there is hope! Here are some proven patterns and lessons learned while evolving systems at internet-scale.

Historically, layout on the web has been quite difficult. We were basically limited to sizing elements either absolutely, or relative to their parent. And the positioning thing was even worse! As developers, we were forced to rely on hacks and third-party tools like Bootstrap to achieve the layouts we wanted.

But, good news everyone! Modern CSS now has us covered. Flexbox and grid give us a bunch of superpowers for creating more dynamic, flexible layouts. So let's take a look at exactly what some of those powers are, the kinds of things we can build with them, and how we can keep those things responsive enough for the modern web.

As a developer I've been pretty skeptical of this whole ""no-code"" trend. Sure, maybe you can build a static website or a blog using a template builder but if you want to build a real application and you don't want to get boxed in you'll need to write code, right?

Let's keep an open mind and take a closer look at these no-code and low-code tools. There are situations where visual tools are just plain better at what they do than writing code. This talk will look at examples where it makes sense to build software visually, and the tools already being used for production software. Being able to directly see and manipulate what you're building is a powerful concept which should make us rethink how writing code typically works. We'll also look at where no-code tools don't make sense, why they can be difficult to adopt, and what the future of traditional coding will look like.

A #LowJS approach is an appealing alternative to the ever-increasing complexity being used to build web applications (sardonically named “Single Page Apps”).

A number of interesting frontend LowJS toolkits have emerged including HTMX and Basecamp’s Hotwire.

In particular, Hotwire is an alternative approach to building modern, dynamic, accessible, responsive web applications without using much JavaScript by sending HTML (instead of JSON or XML) over the wire.

To show what’s possible, we’ll get technical and dive into a full-blown, real-world application which uses Hotwire with Server-Sent Events (SSE) generated by a reactive Spring WebFlux backend, Thymeleaf templates, and Kotlin Coroutines and Flows for a brand new approach to reactive streams.

In a world of rapid changes and increasing uncertainties, organizations have to continuously adapt and evolve to remain competitive and excel in the market.

In such a dynamic business landscape organizations need to design for adaptability. Designing for adaptability requires understanding the landscape organizations are operating in, identifying patterns of change, applying principles for organizational fitness, and making mindful strategic decisions to adapt change.

Organizations need to aim for building systems and team organizations aligned to the business needs and business strategy and evolving them for adaptability to new changes and unknown environments.

This talk brings different perspectives and techniques together from business strategy (Wardley Mapping), software architecture (Domain-Driven Design), and team organization (Team Topologies) as a powerful toolset to design, build and evolve adaptive systems and team structures for a fast flow of change."

It is no secret the world is inundated with data. Throughout the world, organizations are working to become more data-driven. To do so, one of the key skills for organizations is data literacy. Come to this session to hear what data literacy is, the four levels of analytics, why data literacy has risen in the world, and what you can do to improve your own data literacy.