09:45
– 10:00
· 15′
Auditorium "Miltiadis Evert"
Olga Matoula
Package dependency resolution is one of those problems that looks simple until it isn’t. Under the hood, it is a Boolean Satisfiability (SAT) problem. Uv, an extremely fast Python package and project manager written in Rust, brings a whole new level of sophistication to solving it.
In this talk, we will explore how uv’s resolver actually works and the algorithms that power it. Along the way, we will look at some surprising use cases where uv’s resolver behaviour challenges our assumptions about how Python packaging works. We’ll also see some creative ways you can use SAT solvers in practice.
Whether you’re a packaging enthusiast, a library maintainer, an algo lover, or someone who’s stared at a dependency conflict at 2 AM, this talk is for you.
Olga Matoula is a senior software engineer at Bloomberg and a leader of the company's Python Guild, an internal technical community of Python enthusiasts. Previously, she worked in different teams at Bloomberg and Microsoft. In 2014, she co-founded Code It Like a Girl, a first-of-its-kind Greek initiative aiming to teach women and girls how to code. She serves on the organising committee of PyCon Greece and PyLadies Athens. In her free time, she enjoys reading, yoga, and music festivals.
Anubhav Sanyal
Kubernetes is powerful, but learning it often involves repetitive YAML files, static tutorials, and disconnected command-line exercises. To make the learning experience more interactive and engaging, I built Project Yellow Olive - a retro-styled, gamified Terminal User Interface (TUI) in Python that teaches Kubernetes concepts through hands-on gameplay and real cluster interactions.
In this talk, I’ll walk through the architecture and design of the project, including how Python’s Textual framework was used to build a retro game-like TUI experience, how challenge validation systems were implemented, and how the application interacts with real Kubernetes environments using Python and Minikube.
We’ll explore how Kubernetes concepts such as Pods, labels, liveness probes, resource limits, and deployments were transformed into interactive game mechanics and progressive challenges. The session will also cover integrating shell commands, validation engines, and real-time feedback loops into a Python-based TUI application.
Beyond the technical implementation, the talk also explores why gamification matters in developer education. Complex infrastructure concepts are often difficult to retain through traditional documentation-heavy learning methods. By combining retro gaming mechanics with interactive feedback systems, Project Yellow Olive aims to make cloud-native learning more immersive, memorable, and approachable.
Finally, I’ll share the long-term vision for expanding this gamified learning model beyond Kubernetes into broader cloud and platform engineering concepts - including infrastructure, DevOps workflows, and distributed systems education through interactive Python-powered experiences.
Attendees will leave with practical insights into:
i) Building advanced TUIs in Python using Textual
ii) Designing gamified technical learning systems
iii) Integrating Python applications with Kubernetes clusters
iv) Structuring challenge-validation workflows for interactive developer tools
v) Combining retro game design principles with modern cloud-native education
Anubhav Sanyal is a Software Engineer at National Australia Bank (NAB)
who enjoys building creative projects with Python and exploring the intersection of technology, gaming, and education. Outside of work, he is passionate about retro games, travel, developer communities, and open-source culture. He has previously spoken at PyCon Malaysia and Indonesia, Python Asia and enjoys sharing ideas that make technology more engaging and accessible.
Stefanie Molin
Working with data can be challenging: it often doesn’t come in the best format for analysis, and understanding it well enough to extract insights requires both time and the skills to filter, aggregate, reshape, and visualize it. This session will equip you with the knowledge you need to effectively use pandas – a powerful library for data analysis in Python – to make this process easier.
Pandas makes it possible to work with tabular data and perform all parts of the analysis from collection and manipulation through aggregation and visualization. While most of this session focuses on pandas, during our discussion of visualization, we will also introduce at a high level Matplotlib (the library that pandas uses for its visualization features, which when used directly makes it possible to create custom layouts, add annotations, etc.) and Seaborn (another plotting library, which features additional plot types and the ability to visualize long-format data).
Stefanie Molin is a software engineer at Bloomberg in NYC. She is also a core developer of numpydoc and the author of “Hands-On Data Analysis with Pandas,” which is currently in its second edition and has been translated into Korean and Chinese. She holds a bachelor’s of science degree in operations research from Columbia University, as well as a master’s degree in computer science, with a specialization in machine learning, from Georgia Tech.
Python dicts are everywhere! They back module namespaces, instance attributes, **kwargs, and of course actual dictionaries. But have you ever wondered how they work under the hood? And more importantly, what happens to them now that free-threaded Python is here?
In this talk, we'll start by exploring the internals of CPython's dict implementation: how hashing works, the compact table layout that gives you insertion order, and how lookups, insertions, and deletions actually play out in memory. Then we'll see what had to change for free-threading: how reads remain fast without acquiring locks, what the per-object lock is and when it kicks in, and why making a dict thread-safe is harder than it sounds.
Finally, we'll look at the ongoing effort to document CPython's thread-safety guarantees for built-in types and what the resulting documentation means for a Python developer writing concurrent code.
The audience will leave with a deep understanding of how Python's most important data structure works, how it's been adapted for a free-threaded world, and what they can (or can't) safely do with dicts across threads.
Lysandros works as a Senior Software Engineer at Quansight Labs, where he spends most of his time on CPython and the PyData ecosystem. He is a CPython core developer, specializing in the parser, the tokenizer and the REPL. He recently worked on supercharging f-strings in Python 3.12, the new REPL for Python 3.13 and introducing fast string ufuncs in NumPy 2.0. Currently, he's mostly dealing with improving support for free-threaded Python in the PyData ecosystem.
Sho Tanaka
Building AI Agents is accessible, but ensuring their reliability in production is a major engineering challenge. Unlike deterministic software, Agents are probabilistic. A binary "Pass/Fail" test is often insufficient to capture the nuances of an agent's reasoning process.
In this talk, we explore "Evaluation-Driven Development"—a paradigm shift for Python engineers building AI systems. We will focus on measuring the quality of agent trajectories using Python tools and visualizations.
The session covers:
As a developer advocate for Snowflake, Sho is responsible for writing blog articles and developing demo of Snowflake and AI/ML.
Privately, Sho co-organizes the MLOps community JP. First organizer, MLOps Community Japan: Spearheaded the launch and growth of an open, free-to-attend community focused on MLOps/LLMOps/AgentOps. Organized and hosted monthly tech meetups, successfully delivering over 60 events by the end of 2025.
Every web team in 2026 has had the same meeting: "We have a text problem: should we call an LLM?" Getting it wrong is expensive in money, latency, and reliability.
This talk is a decision framework for text problems in production Python web apps: when a regex is enough, when classical ML fits, when an LLM earns its cost, and when to chain them together.
I co-maintain alt-profanity-check (a scikit-learn classifier, ~186,000 monthly downloads on PyPI) and ship LLM integrations in production Django apps. Same problem space, opposite ends of the spectrum.
You'll leave with a framework for scoring any text problem on the dimensions that actually matter in production, latency, cost, failure mode, and three more, and a clearer sense of when "just use an LLM" is right, lazy, or actively dangerous.
Senior Django/Python engineer @ Water Direct. Co-maintains alt-profanity-check on PyPI. Interested in the boring parts of shipping software — cost, latency, and what happens after launch.
Kader Miyanyedi
This talk introduces caching in Python, a simple but powerful way to make programs faster by saving and reusing results of slow operations. Caching is useful when working with repeated calculations or reading the same data many times.
The talk is structured in clear steps. First, we start with a basic explanation of what caching is and why it is important. Then, we look at simple methods like dictionary-based caching. After that, we explore Python’s built-in tools such as @lru_cache, @cache, and @cached_property. Each part includes simple examples to help understanding.
The topic is explained in a practical and easy way, focusing on real use cases. Participants will learn how to choose the right caching method, how to use it correctly, and what common mistakes to avoid. The talk will also explain how improper use of LRU cache can lead to memory leaks, why this happens, and how to fix it using techniques like weak references.
By the end of the talk, they will have the knowledge to apply caching in their own Python projects and improve performance.
I have been a backend developer for 4 years, working primarily with Python and Django. I enjoy sharing what I’ve learned at previous PyCon talks and through writing on Medium, helping others improve their coding and AI skills.
Lais Carvalho
Guido van Rossum described Python as "an experiment in how much freedom programmers need." That framing made sense when humans were the ones writing every line. But what happens to that freedom when the code is increasingly being written for us?
The Zen of Python was never just a style guide. It was an attempt to encode values: clarity, explicitness, readability as a form of respect. Those values don't disappear when we stop typing, they shift. The question is whether we can recognise them, and push back when they're missing.
Drawing on Douglas Hofstadter's Gödel, Escher, Bach book, this talk explores how meaning is layered, how freedom implies responsibility, and how our biases shape what we see and what we miss. Our blind spots are reminders that the things we can't see don't stop existing. Let's see if we can perceive how large those spots are through an experiment.
In 2024, I gave this talk about code. Now, this is about something much bigger: who holds the values when the code writes itself?
Laís Carvalho blends observability expertise with Open Source and a passion for community-building. Former board member (EuroPython, Python Ireland), forever mentor, and advocate for inclusive tech. When not untangling distributed systems, she’s probably playing with watercolor brushes—proof that creativity and logic are NOT mutually exclusive.
Sangarshanan
This talk explores Bytebeat by building a sound generator from scratch in Python. We'll cover the history of its accidental discovery, understand how bitwise operations create musical patterns, implement a Bytebeat Player, and conclude with a live demo creating music in real-time. Whether you're interested in creative coding, algorithmic art, procedural generation, understanding low-level operations in an accessible way, or just want to make weird music with math, this talk will show you how constraints breed creativity and simple code can produce surprising complexity.
My name is Sangarshanan and I am a Software Engineer from planet Earth. I love making stuff that helps and amuses me in equal measure and standing upside down while holding a banana. When I'm bored you can find me making absurdist memes, yet another spotify playlist or staring straight into the void
I am currently pursuing a masters in Music Technology at Universidad Pompeu Fabra. I am also a livecoder performing regularly at events and helping organize creative coding workshops!
Grigoris Maravelias
How do you find structure in data when you don't know what you are looking for? This workshop, drawn from the teaching experience of the AstroStat Academy (astrostat.academy), offers a practical, beginner-friendly introduction to unsupervised machine learning with a focus on clustering, using Python and scikit-learn.
We believe that in an era of easy access to information, what matters most is the understanding that comes from applying tools and learning alongside other people. This workshop is designed to train exactly those deeper skills: interpretability, critical thinking, and problem solving — not just familiarity with an API.
Participants will work through a hands-on Jupyter notebook, progressing from first principles to real-world application. We begin with a short and concise introduction to machine learning: what it is, why it works, and where it fits in the broader landscape of data analysis. We then dive into clustering, showcasing the K-means and DBSCAN algorithms as examples: how they work, why they are good, when they fail, how they compare.
Initially we will play and experiment with synthetic datasets, by tuning the number of clusters, and critically evaluating results using multiple metrics. The session concludes with the application to real scientific datasets from astrophysics, where clustering reveals meaningful structures in the data.
All materials are openly available on GitHub. No prior ML experience is required, just comfort with Python. Whether you work in science, engineering, or any data-rich domain, the skills practiced here transfer directly to your own problems.
I work at the intersection of astrophysics, data science, and machine learning. For 15+ years, I have worked on astrophysical problems - usually complex, high-dimensional, noisy, incomplete. I have also spent an increasingly large fraction of my time to design and deliver hands-on courses and workshops, for both technical and non-technical audiences internationally. I stay curious and keep building.
Alexandros Liapatis
You've probably called an LLM API this week. Maybe you've fine-tuned one, or argued with a coworker about which model is "best." But how much of what's actually happening between your prompt and the response do you understand?
This talk is for Python developers who use LLMs but haven't looked under the hood. We'll cover just enough of the machinery to make you a more informed user and a more skeptical one.
We'll start with tokenization, walk through the transformer, and look at how the training pipeline actually shapes the model you end up talking to. Then we'll spend real time on the part most introductions skip: how evaluations work, and why benchmark numbers are harder to interpret than they look. We'll walk through how evaluations are actually scored, and where the gaps between those scoring choices and real-world performance come from. By the end, you'll have a clearer picture of what a benchmark result is really measuring.
You won't walk out an expert, but you'll have a working mental model of how these systems work and a better read on the numbers people share about them.
I am a Machine Learning Engineer, working on LLM training (continued pre-training, LoRA) and Greek ASR models. I have experience building RAG chatbots and transcription pipelines, and maintains a couple of Python packages on PyPI. Past projects include a Mixture of Experts implementation in MLX and a small Greek language model.
Working with non-uniform data sets at scale is challenging; operations must be fast, correct, resistant to failures, and still offer support for diverse features.
To meet such demands, we have developed two Python frameworks: (a) "scanning", which supports high-performance, high-integrity database migrations and (b) "registries", which generalizes dataset definition and handling with a high-level, expressive UX.
We showcase how both frameworks are used in internal and external projects at GRNET, including the Gov.gr digital services platform.
George Fourtounis is a Tech Lead at GRNET, working on the Greek digital services platform.
Nikos Fotiou
When organizations scale, engineering velocity is affected by team inter-dependencies and scattered insights across different sources and spaces: GitHub repositories and issues, Slack, Confluence; documents and threads of all kinds. But for engineering teams to be successful they have to be able to act fast and accurately. How can we use LLMs and agentic workflows to bridge the gap?
Let's talk about what we did in Elastic, to automate and speed up daily routine tasks by surfacing actionable insights through AI workflows. A story about creating a platform using Elasticsearch as a RAG (Retrieval-Augmented Generation) system with Python microservices on Kubernetes. How ingesters capture knowledge from different sources into Elasticsearch vector indices, then use embeddings, LLMs and Elastic's Agent Builder to deliver grounded, cited answers through a Slack bot, REST API and MCP, all from a FastAPI server. Furthermore, we will discuss how we created a common contract for orchestrating independent remote MCP (Model Context Protocol) servers, transforming the platform's capabilities from static "search engine" to a dynamic investigation and decision hub.
Finally, we will also cover the real engineering challenges: multi-tenant isolation to avoid data poisoning, token budget management for context windows, document-aware chunking that respects documentation structure, as well as open questions about sandboxing the platform's capabilities.
Built on Python 3.14 with FastAPI, pydantic-ai, slack-bolt, Elasticsearch, and other libraries. Sophia means wisdom in greek. This wisdom is not sterile and generic, but grounded in real knowledge, sometimes hidden in some doc or some thread. Let's talk about making engineers wiser as a service!
Senior Software Engineer at Elastic. Working at different posts of platform engineering for more than ten years. Now working on Elastic's platform and network infrastructure, building for scale and reliability. Also tweaking productivity tools to help deliver faster. Brewing beer and discussing outer space.
Daksh P. Jain
Modern fonts look like static design assets, but they are actually complex software packages. Inside every .ttf and .otf file is a structured database of geometry, lookup tables, and rendering rules. The global type industry like Google Fonts, Adobe, and many independent foundries relies on Python to build, inspect, and automate these fonts.
This talk takes a practical, engineering-first look at how Python powers modern typography. Using the open-source FontTools library, I will show how glyphs are stored as contours and Bezier points, how font binaries can be decompiled into editable XML, and how changes can be compiled back into a working font. We will also look at the interpolation math that allows Variable Fonts to morph smoothly between weights such as Thin and Bold.
By the end, attendees will understand how Python fits into real font production pipelines and how these tools can automate or extend their own design and engineering work.
Hey, I'm Daksh, a freelance design engineer who does both software engineering and product/visual design. I've spent 6 years (professionally 3) working across backends, cloud, AI, and frontend, combining them with product design to build things that feel simple and human. I've worked with startups, nonprofits, and tech communities. I organize PyDelhi (New Delhi's Python user group) and have been helping with EuroPython since 2023.
In regulated fintech, every new customer must prove their address. For us, that meant human agents manually reviewing thousands of documents per month — utility bills, bank statements, tax letters — across ten European countries. Average review time: four hours. We built a Python pipeline that automates this end-to-end.
The pipeline has three stages, each using a different tool for what it does best. First, Google Document AI extracts raw text from uploaded PDFs and images. Second, Gemini extracts structured entities — customer name, address, issue date, document type — each with a confidence score. Third, a matching step compares extracted entities against our database records, producing scores that feed into a deterministic decision engine.
The decision engine is where the interesting engineering lives. It's a rule tree, not a model — it consumes confidence and match scores and outputs specific, actionable rejection reasons ("the document is expired", "the name doesn't match", "this is not an accepted document type"). Customers get a clear next step, not a generic failure. We'll walk through how we designed this tree to be auditable by compliance and tunable by engineers via threshold configuration.
We'll also cover the parts nobody talks about: building a human-in-the-loop system so agents review a declining sample of automated decisions, handling Gemini's transient gibberish responses via retry patterns, and the eval framework we use to monitor precision and recall across countries as document formats change. All Python, no ML frameworks.
Director of Engineering at Plum, a UK fintech with 2M+ users. Leading engineering strategy, teams, and delivery across multiple groups with main focus on core banking infrastructure and savings. Background in regulated, high-stakes industries — previously worked on infrastructure and payment systems in the sports betting industry.
James Donahue
As I continue teaching data science and work with statistics students, it becomes more clear that we in the data community are not reaching the rest of the world, and often not the rest of the programming community, in the precise definition of a model. In this talk, I attempt to shine some light into this black box.
Starting with classical statistics and the linear regression, I explain in detail what a basic model is, in a way that is accessible to those without a technical technical background. Building on this concept, I move to basic machine learning, including how we select and train models. The topic of generative AI, specifically LLMs, rounds out the talk.
At every level, I talk about the capabilities and limitations of our models. And, rather than remaining theoretical, we find practical applications from economics, logistics, and, naturally, an LLM. None of these things are magic. So let's follow my favorite economics professor and try to turn this black box into a grey box!
Raised in Nashville, Tennessee, USA, I have bounced around the world, finally settling in Hamburg, Germany. My professional background reflects my vagabond nature. I taught English in Asia, Latin America, and online (full-time remote work before Covid!), worked in adventure tourism in Appalachia (USA) and Chile, and did my masters in Economics in Hamburg. Currently I am occupying myself with a logistics startup, some volunteer work, and trying to build Jim's Data Gym.
Iason Krommydas
You've used numpy arrays hundreds of times, but have you ever wondered what actually lives under the hood? What does an ndarray look like in memory? What are strides, and why do they matter?
I had the same questions, so I did what made sense to me: I tried to build the tiniest possible version myself. The result was a small personal project: a rough C extension implementing a 0D and 1D array of a single dtype. This was just my learning exercise to force myself to understand what numpy is actually doing.
In this talk I'll share what I learned along the way: how shape and strides describe a view into a flat block of memory, what dtype really means at the byte level, and how Python objects wrap C structs under the hood. The goal is to give you a mental model of what numpy is doing every time you create an array or perform an operation on one. Along the way, you'll also pick up some intuition for how C extensions fit into the Python ecosystem
I am a PhD student in Physics & Astronomy at Rice University, researching Higgs boson decays as part of the CMS experiment at CERN. My work spans data analysis, detector data, and software development for large-scale scientific computing. I maintain Awkward Array, an array library for nested variable-sized data, and Coffea, a data analysis toolkit for particle physics. Passionate about open-source tools that enable reproducible and efficient research.
Vasileios Giotsas
In this talk, I'll dive into the engineering that makes the Cloudflare Python Workers viable. We'll explore Pyodide boots, how dynamic linking works across WASM modules, how memory snapshots eliminate cold starts, and why uv became our package management of choice. We'll build and deploy a real Python Worker live.
Target Audience: Python developers, cloud engineers, WebAssembly enthusiasts, and anyone building serverless applications.
Key Takeaways:
uv-first Python deployment workflow looks like on Workers
Vasileios (Vasilis) Giotsas is a research engineer focusing on network measurements and telemetry, the risk assessment and mitigation of topological and macroscopic vulnerabilities of critical Internet infrastructures, and the analysis of Internet routing policies and performance. He has contributed in multiple mission-critical research projects funded by the UK National Cyber Security Center (NCSC), and the US Department of Homeland Security (DHS).
Alexandros Drymonitis
Pyo is a Digital Signal Processing (DSP) toolkit for Python, enabling audio scripting straight into our favorite programming language. Since its initiation in 2010, it has seen a lot of development and has reached a state of a mature and complete toolkit for DSP. Unfortunately, since a year at the time of writing, Pyo is abandonware, but not all hope is lost. Being open source, it enabled a small group of its user community to fork its source and resurect it, bringing it back to being actively maintained. This action has sparked a lively discussion within Pyo's community and has even drawn the attention of the main developer of Pyo, who has now joined our group. Further development of this module has already started and Pyo is expected to be officially released again, supporting the latest Python versions.
In this talk, I will present the basic features of Pyo, together with a few showcases of projects from our community. I will talk about its flexibility, its embeddedness in other programming languages, and its adaptivity to the greater Python ecosystem, a unique feature among DSP programming languages.
Alexandros Drymonitis is a sound and new media artist. He has a PhD from the Royal Birmingham Conservatoire, Birmingham City University, on the creation of musical works with the Python programming language, while his previous studies were on the classical guitar. His artistic practice focuses on new techniques utilizing new media such as computer programming, live coding, AI, or even older practices, like modular synthesis.
Georgios Kalaitzis
It is 8:47 PM on a Saturday. Twelve orders are on the rail. The lamb just ran out. A line cook is in the weeds and the expediter is calling out tickets faster than anyone can plate them. Nobody panics. Service keeps moving.
How? Because a restaurant kitchen is a distributed system that has been in production for two hundred years, and it solves problems your Python services are still arguing about in design docs.
When the lamb runs out, the kitchen does not crash. The server is told, the menu shrinks, and the room never knows. That is graceful degradation, done cleanly. An ingredient with hours left to live is a TTL, and the kitchen runs an eviction policy on it: feature it tonight, prep it for tomorrow, or eat the loss. The walk-in, the prep cooler, and the pass are a tiered cache where latency is measured in steps to the line. A line cook calling for backup is human failover with role elasticity.
This talk takes the brigade system seriously as an architectural reference. I will walk through three Python systems from my own production experience and show the kitchen pattern each one quietly converged on. A batch ML system that found its rhythm in prep-and-batch logic a chef would recognize. A high-throughput messaging pipeline where choosing a compression level was the same call as deciding which order to fire first under load. A test infrastructure that worked because every station had one job and a clean handoff.
Then the part that matters in 2026. As LLMs commoditize the writing of code, the scarce skill becomes what every chef already knows: taste, prioritization, knowing when to pull a dish from the menu. A chef who cannot judge does not survive a Saturday night. The same logic, soon, for engineers.
Come hungry.
Hi I am George, a software engineer focused on building reliable ML distributed systems and developer tooling.
Seungwoo Schin
LLMs are great at answering medical questions. Ask one why, and you get a confident paragraph that may or may not have anything to do with how it actually arrived at the answer. That's a problem when the stakes are high.
We built a small Python system that gives an LLM something to reason over, not just from. The LLM reads a medical textbook and extracts a hypergraph of entities and the multi-way relationships between them. Then an agent traverses that hypergraph with three tools to answer USMLE-style questions, leaving a trace you can actually read and debug. No SNOMED, no symbolic reasoner, no Prolog. Just Python, embeddings, and an LLM calling its own tools.
On MedQA it matches a frontier model. But the more interesting finding is that the same setup hurts smaller models, and we think the reason matters for anyone building agent systems.
Seungwoo Shin is the co-founder and CEO of Mazigle, an AI shop working across media, publishing, and manufacturing. Before Mazigle he ran the leading paid newsletter for US equity analysis on Naver's Premium Contents platform. His background is in NLP, computational linguistics, and the philosophy of language.
As developers rapidly adopt generative AI, a dangerous misconception has emerged: the belief that vector embeddings are easily interchangeable, "plug and play" components. This poster challenges that myth by exploring the hidden dependencies created when embedding layers are integrated into production environments. While managed APIs accelerate initial development, persisting these vectors at scale introduces a profound structural vulnerability tied to proprietary vendor lifecycles, immediately exposing systems to unpredictable token pricing and sudden usage limits.
We examine how this architectural coupling fundamentally differs from standard operational API lock-in, silently jeopardizing system stability, retrieval behavior, and data portability. Furthermore, we analyse hidden overheads that require developers to not only pay to re-embed their entire dataset, but to rigorously re-evaluate baseline retrieval accuracy and system latency from scratch. Finally, the presentation offers high-level strategic frameworks for evaluating embedding infrastructure, empowering engineering teams to reclaim control over their core data layers and build resilient, vendor-agnostic systems.
Vassiliki is a software engineer and AI builder focused on human-centered AI products and emotionally aware technology. She is the founder of MovieGroovy, a mood-based movie and TV recommender. She is also a PyGreece organizer, Women Techmakers Ambassador, and #IAmRemarkable facilitator, supporting inclusive tech communities through mentoring, events, and initiatives around emotional well-being in tech.
CyberSentinel Py is a lightweight AI-powered threat detection system built with Python & FastAPI.
This poster explores phishing detection workflows, URL risk analysis, API architecture, and responsible AI approaches for building practical cybersecurity tooling.
Featuring:
Eyitayo is a product and community builder focused on AI-powered digital safety, cybersecurity, and accessibility. She is the creator of CyberSentinel AI and other community-centred safety initiatives exploring how Python, AI, and practical security tooling can help detect scams, improve online trust, and build safer digital experiences.
Esther Fernández Carbayo
Language models — both generative and classical — base their learning, operation, and evaluation on linguistic structures and principles: they generate valid syntax, map meanings in vector spaces, and respond with pragmatic coherence. Yet linguistics rarely appears as part of the stack. In the current era of generative and agentic AI, this relationship has grown even stronger, to the point where neither can be fully understood without the other. This talk explores how grammatical structures emerge, what meaning embeddings encode, and why a well-crafted prompt functions as a speech act. Through Python examples, we will examine how syntax, morphology, semantics, and pragmatics lie at the core — even as technical discourse conceals them beneath layers of tokens and attention.
Linguist specialized in natural language processing and generative and agentic artificial intelligence. Currently working as an AI engineer and data scientist, developing, tuning, and evaluating large-scale AI systems, and implementing advanced AI engineering techniques to build robust, scalable, secure, and business-oriented solutions.
Alexandra Athanasakou
In the age of abundant online tutorials, many new programmers become trapped in “Tutorial Hell”: the ability to follow instructions without being able to build something of their own. This poster presents the value of hands-on training and Project-Based Learning (PBL) in Python, supported by recent data and statistics from the job market.
The poster serves as a “Mentor Corner,” offering visitors statistical insights that highlight the importance of portfolio building, along with practical advice on how to turn theory into code. Its goal is to inspire participants to focus on active learning and begin their own journey of creating projects.
Alexandra moves effortlessly between data and knowledge, transforming them into stories that make sense. A Business Intelligence Developer and Data Engineer with the heart of an educator, she designs learning experiences that make the 'complex' approachable. As the Lead Instructor of her own e-learning platform, Data Tutor, she combines technical precision, creativity, and a quiet, inspiring strength - because learning, much like data, requires care to truly flourish.
Hi, I'm Andreas Stasinakis, Senior Data Scientist with 6+ years of experience and co-founder of Shift Happens, the largest developer community in Greece. Through our workshops, meetups, and mentoring, I've consistently seen that building real projects is what actually makes Python stick; not courses, not certifications.
I'd like to talk about what that looks like in practice and help any newcomers!
Understanding EU climate policy often requires navigating long, technical documents spread across multiple official sources.
This project explores how retrieval-augmented generation (RAG) and agentic search can help students, early-stage policy learners and honestly myself get an initial understanding of complex policy topics while staying grounded in source material.
The system collects official EU climate policy documents, cleans and structures them into a local dataset, and allows users to ask questions in plain language. An agentic RAG assistant searches the document collection, retrieves relevant passages, and generates answers based on the retrieved sources rather than relying on unsupported model knowledge.
The goal is not to replace reading official policy documents, but to help users identify relevant source material and build enough context before going deeper into the original texts.
The project includes:
Data Scientist and Machine Learning Engineer Coach at SPICED Academy and Neue Fische, helping learners transition into careers in AI and data science.
My background is in Physics, where I played with lasers, mirrors, and experimental setups. Today, I bring that same curiosity into machine learning, AI engineering, and building tools that help people learn complex topics more easily.
Last updated: Aug. 10, 2026, 3:24 p.m.
