Please note:
On this page you will only see the English-language presentations of the conference. You can find all conference sessions, including the German speaking ones, here.
The times given in the conference program of OOP 2024 correspond to Central European Time (CET).
By clicking on "VORTRAG MERKEN" within the lecture descriptions you can arrange your own schedule. You can view your schedule at any time using the icon in the upper right corner.
Thema: Software Development
- Dienstag
30.01. - Mittwoch
31.01. - Donnerstag
01.02.
How can a deterministic function possibly give random results? We will find out and learn how to use various random number distributions.
Random numbers haven't changed much since C++11, though new features can make these easier to use. Card games and similar need randomness to be fun and make good teaching examples. We will also discover a way to code ourselves (or blobs at least) out of a paper bag in the process.
Target Audience: intermediate. There will be some code and simulations of blobs escaping paper bags
Prerequisites: None but there will be some algorithms and C++
Level: Advanced
Extended Abstract:
Most of us need a random number at some point if we write code. We will discover how they are generated. We will see how to ensure simulating a dice roll makes the numbers 1 to 6 equally likely, and note some pitfalls to be aware of in some programming languages.
We will have a brief aside into stochastic outcomes from deterministic models, also known as chaos. Applying a function iteratively can’t possibly give non-deterministic results, right? We shall see.
After this aside, we will return to using random numbers. We will consider common mistakes and how to think clearly about "random" code. To round off, we will think about how to test code which uses random numbers.
By the end we’ll be familiar with terms like pseudorandom number generator (PRNG), linear congruential generator and random distribution. Finally, we’ll use various distributions to race some blobs out of a paper bag. Seeing a visual demonstration will solidify some the learning outcomes.
Frances Buontempo is currently editor of the ACCU’s Overload magazine and has written two books, one on Genetic Algorithms and Machine Learning and the other on Learning C++ for those who got left behind since C++11. She has worked as a programmer at various companies, mostly in London with a focus on finance. She enjoys testing and deleting code and tries to keep on learning.
Vortrag Teilen
In this session we will walk through various techniques to significantly reduce the resource consumption of regular Spring Boot applications, including using Spring AOT for regular Spring apps, compiling Spring Boot apps to native images (using GraalVM), and using CRaC for instant startup (for scale-to-zero scenarios). We will compare the different approaches, discuss pros and cons for each technology, and share concrete numbers from real-world applications to give the audience an idea of what can be achieved using these technologies.
Target Audience: Developers, Architects
Prerequisites: Basic Spring Boot knowledge required
Level: Advanced
Mehr Inhalte dieses Speakers? Schaut doch mal bei sigs.de vorbei: https://www.sigs.de/autor/martin.lippert
Martin Lippert is part of the Spring engineering team at VMware and leads the Spring tools engineering. In addition to that he focuses on sustainability and green software for several years now.
Mehr Inhalte dieses Speakers? Schaut doch mal bei sigs.de vorbei: https://www.sigs.de/experten/martin-lippert/
User-centred design is one of the default modes of teams working with software, but the consequences are often unsustainable in a densely networked world as we privilege users over all other stakeholders and systems. How might teams approach building products, services and organisations from a more sustainable standpoint than 'user-centricity'? This talk looks at how the techniques of game design, community development, platform operations and security practices can support a practice focused on hyperobjects for multi-centric design.
Target Audience: Leaders, Builders, Architects, Designers, Community Members
Prerequisites: No previous knowledge, only enthusiasm for systems, building things and design
Level: Advanced
Extended Abstract:
The key feature of a 'tragedy' is when everybody does the right thing but it goes wrong anyway. The aim of this session will be to look at why user-centred design goes wrong even if everyone's intentions are pure. This talk (gently!) brings in ideas from feminism, design thinkers, political science and anthropology to focus on very practical, grounded approaches to sustainable design in software teams. We'll look at how building things and designing organisations that have increased levels of friction can improve users' experience and how 'seamless' design can lead to disempowerment. And we'll also draw on the speaker's practical experience of building products used by millions of citizens as part of the UK's digital transformation. By the end of the session we'll have a sense of what might replace the shallow seamlessness of 'user-centred' design — a multi-centric, transcendental design aimed at manufacturing enthusiastic consent.
Simon Edward Bostock is a product and design leader who's worked with software for 20+ years. His interests include how firms and brands incorporate new technologies, how work flows through organisations, EverythingOps and service topologies.
Microfrontends are a popular concept for development in an enterprise project, where a large number of teams want to work independently.
But what is the cost achieving run-time integration and independent framework versions?
JS frameworks intended to build SPAs have solved many problems like deep-linking between pages without reloading the application.
This talk will give you some real life experience which challenges are to be considered using different integration patterns, using webcomponents, module federation and "classic" libraries.
Target Audience: Architects, Developers, Project Managers
Prerequisites: Basic knowledge of Angular or other JS SPA Frameworks
Level: Advanced
Extended Abstract:
How often do project managers wish for a microfrontend architecture? Contrary to microservices in the backend, microfrontends are not always the recommended future choice.
You might have to solve a lot of problems, that have already been solved in frameworks like Angular or React.
If we start separating UI elements in encapsulated webcomponents, we risk a lot of effort re-creating capabilities like deeplinking (routing) or event handling across components.
Or: we need to add additional frameworks that solve the challenges of navigation, context transfer and layouting.
The talk provides an overview, what default architecture patterns Angular provides and how to mitigate problems that might come with classical architectures or a monorepo.
The talk will mention use cases, when the usage of microfrontends is feasible and recommended. It will also provide workarounds if a microfrontend architecture is needed.
Cathrin Möller is a full stack developer, architect and UX and CSS enthusiast and working as a Principal Consultant at TNG Technology Consulting since 2014. She has a broad experience from multiple client projects ranging from mature enterprise projects as well as development from scratch. Therefore she knows common pitfalls and a lot of best practices that she likes sharing in talks.
Vortrag Teilen
This technical session aims to unravel the unique facets of Rust's memory management, including Ownership/Borrowing, Stack/Heap allocation, Reference Counting, and Lifetimes. Rainer Stropek aims to provide an in-depth understanding of these core elements and their interplay in providing memory safety, concurrency, and abstraction in Rust. This session, designed for developers with a strong programming background, will provide insight into the mechanisms that help Rust minimize common runtime errors.
Target Audience: Developers
Prerequisites: Strong development background
Level: Expert
Extended Abstract:
In the arena of systems programming, memory management is a fundamental concern. How a language approaches memory safety, concurrency, and performance has substantial implications for the efficacy of the programs it produces. Rust's unique approach to these concerns through its intricate yet robust memory management system is the focus of this technical session.
We will explore Rust's ownership rules which hinge on three key concepts: ownership, borrowing, and lifetimes. Rust's Ownership system is unique in its way of maintaining a clear distinction between mutable and immutable references and strictly enforces a single ownership policy to ensure safe memory access. We'll delve into the 'borrow checker' system, which keeps track of scopes to enforce these rules at compile-time, effectively minimizing runtime errors.
Next, we'll look at how Rust deals with memory allocation on the Stack and Heap, providing a safer and more explicit interface to these lower-level details. A clear understanding of these processes allows developers to write efficient, error-free code.
The session also takes an in-depth look at Reference Counting (Rc and Arc), Rust's form of memory management for data that has multiple owners. This approach ensures the automatic cleanup of resources, contributing to Rust's promise of memory safety.
Lastly, we'll dissect Lifetimes, a powerful concept Rust introduces to ensure references are always valid. By defining and enforcing Lifetimes, Rust ensures that memory safety is guaranteed without any cost to runtime performance.
This session is tailored for developers who already have a strong programming background and are considering delving deeper into Rust or are interested in the unique aspects of its memory management.
Mehr Inhalte dieses Speakers? Schaut doch mal bei sigs.de vorbei: https://www.sigs.de/autor/rainer.stropek
Rainer Stropek is co-founder and CEO of the company software architects and has been serving this role since 2008. At software architects Rainer and his team are developing the award-winning SaaS time tracking solution “time cockpit”. Previously, Rainer founded and led two IT consulting firms that worked in the area of developing software solutions based on the Microsoft technology stack.
Rainer is recognized as an expert concerning software development, software architecture, and cloud computing. He has written numerous books and articles on these topics. Additionally, he regularly speaks at conferences, workshops and trainings in Europe and the US. In 2010 Rainer has become one of the first MVPs for the Microsoft Azure platform. In 2015, Rainer also became a Microsoft Regional Director.
Rainer graduated from the Higher Technical School Leonding (AT) for MIS with honors and holds a BSc (Hons) Computer Studies of the University of Derby (UK).
Mehr Inhalte dieses Speakers? Schaut doch mal bei sigs.de vorbei: https://www.sigs.de/experten/rainer-stropek/
Vortrag Teilen
Many developers evoke technical debt to explain the misfortunes and troubles of their codebase and delivery. While unmanaged technical debt weighs down an architecture and exerts drag on its schedule, it is more often an effect than a cause. In this talk, we will look at what is and is not meant by technical debt with a view to properly attributing the root and recurring cause as technical neglect than technical debt. Without seeing technical neglect for what it is, we will continue to misattribute our problems to an effect rather than a cause.
Target Audience: Developers, Architects, Technical Managers
Prerequisites: Responsibility for software development, whether implementing it, guiding it or managing it
Level: Advanced
Extended Abstract:
Many developers evoke the mischievous spirit and day-to-day burden of technical debt to explain the misfortunes and troubles of their codebase and delivery. While unmanaged technical debt weighs down an architecture and exerts drag on its schedule, it is more often an effect than a cause. In this talk, we will look at what is and is not meant by technical debt — and other metaphors — with a view to properly attributing the root and recurring cause as technical neglect than technical debt. Without seeing technical neglect for what it is, we will continue to misattribute our problems to an effect rather than a cause.
Kevlin Henney is an independent consultant, trainer, speaker and writer. He helps individuals and teams improve their skills, codebases and cultures, ensuring people have a place in their architecture. He is co-author of two volumes in the "Pattern-Oriented Software Architecture" series, editor of "97 Things Every Programmer Should Know" and co-editor of "97 Things Every Java Programmer Should Know". He lives in Bristol and online.
Vortrag Teilen
Although the term "Cloud Native" in the context of Java has been repeated ad nauseam for years, the JVM as a platform has only recently entered a phase where everything truly aligns with how cloud-native architectures are designed. Let's trace the path Java has already taken in recent years and take a look at what lies ahead in the future. During this presentation, you will learn about projects such as Leyden, CRaC, and GraalVM, and how they can realistically influence the way applications are developed.
Target Audience: Cloud Java Architectural Leads
Prerequisites: Basic Knowledge od Java, Cloud Challenges Experience
Level: Advanced
Extended Abstract:
The goal of the presentation is to provide a comprehensive overview of the evolution of Java in relation to cloud-native architectures. The presentation aims to educate the audience about the progress Java has made in recent years and shed light on the future prospects of the language.
By discussing key projects like Leyden, CRaC, Microprofile and GraalVM, the presentation intends to demonstrate their relevance and potential impact on application development. Ultimately, the goal is to inspire the audience to embrace cloud-native principles in their Java projects and adapt their development practices accordingly.
Head of Java/Kotlin Engineering at VirtusLab, Artur Skowroński has been in the industry for ten years. During this time, he has had the opportunity to work in various roles, such as Software Engineer, Tech Lead, Architect, and even Technical Product Manager. This diverse experience enables him to approach problems from a holistic perspective.
He still loves to get his hands dirty - for more than two years, he has been publishing weekly reviews of events in the JVM world - https://vived.substack.com/
Vortrag Teilen
Henning (OO to the core) and Mike (ferociously FP) agree on all the fundamentals of software architecture, but when it comes to designing models, they can't seem to find common ground.
OO and FP folks like to congratulate themselves on how well they go together - and how OO languages are accreting one feature after another from the FP world.
Henning and Mike will highlight how OO and FP approaches to design differ, and offer possible approaches to unifying both for mutual gain and insight.
Target Audience: Architects, Developers
Prerequisites: Experience in OO or FP
Level: Advanced
Extended Abstract:
Much work remains to unify these two worlds:
- OO folks are weary of premature abstractions, whereas FP folks tend to abstract early.
- While both camps prefer operation-rich models, the approaches to designing these operations are incompatible. Specifically, the BDD and TDD approaches favored by the OO folks are incompatible with the design recipes approach preferred by the functional camp.
- Paradoxically, OO - which is supposed to be about objects - espouses BDD which is about functions, whereas FP has a rich tradition in data design, i.e. objects.
- In OO, objects populate the domain, and they are encapsulated and thus isolated, whereas in FP this encapsulation is an emergent (or not emergent) phenomenon.
- OO is inherently stateful, and FP is inherently stateless. This naturally leads to very different approaches to interface design, and more importantly, to the use of types.
Mehr Inhalte dieser Speaker? Schaut doch mal bei sigs.de vorbei: https://www.sigs.de/autor/michael.sperber; https://www.sigs.de/autor/henning.schwentner
Dr. Michael Sperber ist Geschäftsführer der Active Group GmbH, die Individualsoftware ausschließlich mit funktionaler Programmierung entwickelt. Er ist international anerkannter Experte für funktionale Programmierung und wendet sie seit über 20 Jahren in Forschung, Lehre und industrieller Entwicklung an. Außerdem hat er zahlreiche Fachartikel und Bücher zum Thema verfasst. Michael Sperber ist Mitbegründer des Blogs funktionale-programmierung.de und Mitorganisator der Entwicklerkonferenz BOB.
Mehr Inhalte dieses Speakers? Schaut doch mal bei sigs.de vorbei: https://www.sigs.de/experten/michael-sperber/
Henning liebt Programmieren in hoher Qualität. Diese Leidenschaft lebt er als Coder, Coach und Consultant bei der WPS – Workplace Solutions aus. Dort hilft er Teams dabei, gewachsene Monolithen zu strukturieren oder neue Systeme von Anfang an mit einer tragfähigen Architektur zu errichten. Häufig kommen dann Microservices oder Self-Contained Systems heraus. Henning ist Autor von "Domain Storytelling" (Addison-Wesley, 2022) und dem www.LeasingNinja.io sowie Übersetzer von "Domain-Driven Design kompakt" (dpunkt, 2017).
Mehr Inhalte dieses Speakers? Schaut doch mal bei sigs.de vorbei: https://www.sigs.de/experten/henning-schwentner/
Vortrag Teilen
Most current UI libraries provide great user experience with a vast of components. But when it comes to heavy customization and non-standard scenarios, especially for E-Commerce, they become hard to manage, scale or even slow down performance. How to create a UI library that provides users the most possible freedom in customizing components, while keeping our performance and scalability to the fullest? How much customization freedom is enough? That's what my talk is about.
Target Audience: Developers, Architects, Project Leader
Prerequisites: JavaScript
Level: Advanced
Maya Shavin is Senior Software-Engineer in Microsoft, working extensively with JavaScript and frontend frameworks and based in Israel. She founded and is currently the organizer of the VueJS Israel Meetup Community, helping to create a strong playground for Vue.js lovers and like-minded developers. Maya is also a published author, international speaker and an open-source library maintainer of frontend and web projects. As a core maintainer of StorefrontUI framework for e-commerce, she focuses on delivering performant components and best practices to the community while believing a strong Vanilla JavaScript knowledge is necessary for being a good web developer.
Last year in open source, we saw the compliance threat shift from license violation to contract violation, we saw the rise of the bill of material as a purchasing requirement, and we saw the continued growth of source-available licenses. If you don't know what I'm talking about, you really need to attend, because your business is at risk if you don't understand these changes. In this annual talk, I will review the last year and speculate about what the future may bring.
Target Audience: Product Leaders, Engineering Leaders, Architects, Developers, Enthusiasts
Prerequisites: Basic understanding of open-source software development
Level: Advanced
Prof. Dirk Riehle, the professor for open-source software at University of Erlangen, digs open source. Before becoming a professor, he led the open source research group at SAP in the Silicon Valley.
Vortrag Teilen
Vortrag Teilen
During the talk, we'll dive into the historical context of Generative AI and examine their challenges. From legal compliance to fairness, transparency, security, and accountability, we'll discuss strategies for implementing Responsible AI principles.
It's important to note that the landscape for AI-driven products is still evolving, and there are no established best practices. The legislative framework surrounding these models remains uncertain, making it even more vital to engage in discussions that shape responsible AI practices.
Target Audience: Decision Makers, Developers, Managers, Everyone - AI-driven products require cross-functional teams
Prerequisites: None
Level: Basic
Extended Abstract:
Foundation models like GPT-4, BERT, or DALL-E 2 are remarkable in their versatility, trained on vast datasets using self-supervised learning. However, the adaptability of these models brings forth ethical, socio-technical, and legal questions that demand responsible development and deployment.
During the talk, we'll delve into the history of AI to better understand the evolution of generative models. We'll explore strategies for implementing Responsible AI principles, tackling issues such as legal compliance, fairness, transparency, security, accountability and their broader impact on society.
It's important to note that there are currently no established best practices for AI-driven products, and the legislative landscape surrounding them remains unclear. This underscores the significance of our discussion as we collectively navigate this emerging field.
Isabel Bär is a skilled professional with a Master's degree in Data Engineering from the Hasso-Plattner-Institute. She has made contributions in the field of AI software, focusing on areas like MLOps and Responsible AI. Beyond being a regular speaker at various conferences, she has also taken on the role of organizing conferences on Data and AI, showcasing her commitment to knowledge sharing and community building. Currently, she is working as a consultant in a German IT consulting company.
Are Large Language Models (LLMs) sophisticated pattern matchers ('parrots') without understanding or potential prodigies that eventually surpass human intelligence? Drawing insights from both camps, we attempt to reconcile these perspectives, examines the current state of LLMs, their potential trajectories, and the profound impact these developments have on how we engineer software in the years to come.
Target Audience: Developers and Architects
Prerequisites: A basic understanding of Large Language Models is helpful but not required
Level: Basic
Extended Abstract:
Large Language Models (LLMs) are complex 'black box' systems. Their capabilities remain largely mysterious, only beginning to be understood through interaction and experimentation. While these models occasionally yield surprisingly accurate responses, they also exhibit shocking, elementary mistakes and limitations, creating more confusion than clarity.
When seeking expert insights, we find two diverging perspectives. On one side, we have thinkers like Noam Chomsky and AI experts such as Yann LeCun, who view LLMs as stochastic 'parrots' — sophisticated pattern matchers without true comprehension.
In contrast, AI pioneers like Geoffrey Hinton and Ilya Sutskever see LLMs as potential 'prodigies' — AI systems capable of eventually surpassing human intelligence and visionaries like Yuval Noah Harari that view LLMs as substantial societal threats.
Regardless of whether we see LLMs as 'parrots' or 'prodigies', they undeniable are catalyzing a paradigm shift in software engineering, broadening horizons, and pushing the boundaries of the field.
What are the theories underpinning these experts' views? Can their perspectives be reconciled, and what can we learn for the future of software engineering?
To answer these questions, we examine the current capabilities and developments of LLMs and explore their potential trajectories.
Steve Haupt, ein agiler Softwareentwickler bei andrena objects, betrachtet Softwareentwicklung als ein qualitätsorientiertes Handwerk. Aus Begeisterung für Künstliche Intelligenz erforscht er deren Auswirkungen auf das Softwarehandwerk, arbeitet an KI-Projekten und entwickelt dabei Best Practices. Er spricht regelmäßig über Künstliche Intelligenz und entwickelt Schulungen, um dieses Wissen zu verbreiten.
Mehr Inhalte dieses Speakers? Schaut doch mal bei SIGS.de vorbei: https://www.sigs.de/experten/steve-haupt/
Vortrag Teilen
Vortrag Teilen
Artificial Intelligence (AI) has become integral to software development, automating complex tasks and shaping this field's future. However, it also comes with challenges. In this talk, we explore how AI impacts current software development and possibilities for the future. We'll delve into AI language models in programming, discussing pros, cons and challenges. This talk, tailored to both supporters and skeptics of AI in software development, doesn't shy away from discussing the ethical obligations tied to this technology.
Target Audience: Software Engineers, Architects and Project Leaders in an enterprise environment
Prerequisites: Basic Understanding of Software Development
Level: Advanced
Extended Abstract:
The integration of Artificial Intelligence (AI), especially AI language models, is fundamentally reshaping the landscape of software development. This transformative technology offers exciting possibilities, from enhancing developer productivity to simplifying complex tasks. However, it is crucial to acknowledge and address the inherent challenges that accompany these advancements.
In this session, we delve into AI's role in software development, emphasizing both the potential benefits and potential drawbacks of AI. We will also examine the ethical implications of this technology.
By the end of the session, attendees will have a comprehensive understanding of AI's role in software development, reinforced by practical demonstrations. Participants will gain insight and skills for their daily roles as well as strategies for adopting and applying AI within their software development context.
As AI continues to permeate software development, understanding its potential and preparing for its challenges has become vital. My session, directly tied to the conference theme of "Expanding Horizons", provides unique, practical insights to help attendees navigate an AI-integrated future. Join me in encouraging the responsible and effective use of this transformative technology.
Marius Wichtner works as a Lead Software Engineer in the IT Stabilization & Modernization department at MaibornWolff. Focused on the quality and architecture of diverse applications and backend systems, he has a particular interest in how artificial intelligence intersects with and evolves the realm of software development.
Vortrag Teilen
High traffic during business hours, no traffic at night, weekends and vacations, multiple teams, and several staging environments - these characteristics of a typical enterprise application. Pay-as-you-go, "scale-to-zero" and managed services make serverless architectures appealing for enterprise applications.
On-premise, on the other hand, you get the maximum flexibility and full access to machines with less automation and so more plumbing.
I will compare both approaches with focus on architecture and answer your questions in real time.
Target Audience: Developers, Architects
Prerequisites: Basic Cloud and Java Knowledge
Level: Advanced
Adam Bien is Developer (Architect), Consultant, Trainer (https://airhacks.io), AWS Hero, podcaster (https://airhacks.fm), Java enthusiast (and Java Champion). Adam (https://adambien.blog) uses Java since JDK 1.0 and JavaScript since LiveScript and still enjoys writing code.
Adam regularly organizes Java / Web / Cloud / Architectures online live workshops https://airhacks.live and monthly Q&A live streaming show: https://airhacks.tv.
Vortrag Teilen