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.

Programmierer:innen der Mainstream-Programmiersprachen sind schon sehr erstaunt über die Mächtigkeit eines Lisp-Makrosystems. Wir können dadurch Sprachfeatures ganz einfach selbst implementieren und die Programmiersprache auf natürliche Art und Weise erweitern.
Racket, ein besonderer Lisp-Dialekt, geht noch weiter: Nicht nur ist das Makrosystem besonders ausgefeilt (Stichwort Hygienic Macros) – die Sprache ist sogar darauf ausgelegt, Makros zu schreiben, die eigene Subsprachen (DSLs) realisieren und reibungslos zu integrieren.

Zielpublikum: Entwickler:innen, Architekt:innen
Voraussetzungen: Kein Vorwissen erforderlich
Schwierigkeitsgrad: Anfänger

Extended Abstract:
Wir entwickeln damit komfortabel für verschiedene Domänen eigene Sprachen mit eigener Syntax. Dieser Stil wird deshalb "Language Oriented Programming" genannt – wir passen die Sprache ultimativ an die Domäne und die Anwenderin an.
Dieser Talk gibt eine kurze Einführung in Racket, dann wird das Makrosystem vorgestellt und die #lang-Funktionalität.
Es ist kein Vorwissen erforderlich.

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

Python befindet sich seit Jahren unter den Top 3 der populärsten Programmiersprachen. Spätestens seit dem anhaltenden Hype um maschinelles Lernen führt selbst für normalsterbliche Entwickler praktisch kein Weg mehr an Python vorbei.
Aber wieso ist die Sprache eigentlich so beliebt – selbst außerhalb von Machine Learning? Welche Eigenschaften zeichnet sie aus? Ist es sinnvoll – und funktioniert das überhaupt –, so einfach von Java, .NET oder C++ auf Python umzusteigen?

Zielpublikum: Erfahrene Software-Entwickler:innen und -Architekt:innen
Voraussetzungen: Erfahrung in einer Hochsprache, typischerweise aus der Java-, .NET-Welt oder C++-Welt
Schwierigkeitsgrad: Anfänger

Extended Abstract:
Als langjähriger Java-Entwickler ist dem Vortragenden natürlich v.a. die Java-Sicht sehr gut bekannt, sodass (hoffentlich) ein möglichst wertneutrales Bild davon gegeben werden kann, was Java von Python unterscheidet und wo beide Sprachen jeweils ihre Stärken und ihre Schwächen haben. Wie bitte? Schwächen? – Ja, auch die gibt es. ;-)

Mehr Inhalte dieses Speakers? Schaut doch mal bei sigs.de vorbei: https://sigs.de/autor/christian.heitzmann