NDC Conferences

This talk was recorded at NDC Copenhagen in Copenhagen, Denmark. #ndccopenhagen #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndccopenhagen.com/

Subscribe to our YouTube channel and learn every day:   
/        @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#cloud #dotnet #security #serverless 

Over 12 billion requests per month, over a terabyte of data being constantly queried, paying subscribers, public APIs, unpredictable throughput patterns, constant uptime requirements and a never ending stream of data breaches. That's the challenge of running Have I Been Pwned on a day-to-day basis.

There must be a pretty big team of developers and SREs?

Yep, two people!

Wait what?! How is that possible?

In this talk I'll show you what it takes to run Have I Been Pwned, it's architecture, what technology it is using and how to bring out the best in the infrastructure and frameworks used to run it. I'll also go over some learnings and gotcha's that we had to figure out, sometimes the hard way.

NDC Copenhagen 2025

Adventures at HyperScale! - Stefán Jökull Sigurðarson - NDC Copenhagen 2025

ClojureTV

Clojure has a curated set of language features and standard library, but not every tool sees equal use. This talk will review my findings in what special forms, macros, and functions are used most often in publicly available Clojure code, with a particular focus on the forms most common in function bodies.

Besides curiosity, looking empirically at common ways code is structured hones intuitions on what tools to reach for first.

Biography

Alys Brooks is a programming tutor and writer. Previously, she was a software developer and a technical writer, and remains interested in communicating technical concepts accurately and engagingly.

In her free time, she enjoys photography, running, and game development. She lives with her cat and way too many books in Wisconsin in the US.

Recorded Nov 13, 2025 at Clojure/Conj 2025 in Charlotte, NC.

Clojure/Conj 2025

The Shape of Clojure Code - Brooks

geecon conference

Do you want to know your options for running Java on Google Cloud? We will explore various options for running workloads written using the latest Java and Jakarta EE versions on serverless offerings like CloudRun and Knative. Furthermore, we will look at optimizing your runtime performance using various frameworks and Native Image compilation.

GeeCON 2025

GeeCON 2025: Rustam Mehmandarov - Optimising Java for Cloud: The Enterprise, The Serverless, and ...

AI will stay with us, whether we like it or not. The continuous growth of the possibilities of AI systems presents both opportunities and challenges, which requires from us to be more responsible for the world around us. The advent of AI can have a darker side, and it’s not necessary the development of rouge AI that will decide to wipe out humanity, like in the movies. During this talk I would like to give you some (possibly) less common perspectives on AI, and to leave you with some food for thought. This talk will be for everyone - feel free to join. And now ask yourself: can you tell if this abstract has been generated by AI, or not?

GeeCON 2025: Maciej Krzysica - Why should we be careful with AI?

Once upon a time, there was a mainstream computer language that ran on almost every computer. Everyone was using it everywhere; it was (basically :-)) dominating the industry. Suddenly, it was over. Well, it is still there but certainly not dominating. We will unravel the rise and fall of BASIC. What was the language itself? What was it like to use GOTO everywhere? What were the strengths and weaknesses of the language and its implementations? We will uncover the role that Microsoft played, and even take a peek at some of Bill Gates' code in assembly. And then we will question why it lost popularity, where BASIC stands today, and whether the same fate could befall Java. Like BASIC itself, this talk is targeted at everyone, from beginners to professionals.

GeeCON 2024

GeeCON 2024: Jarek Ratajski - The Story of BASIC

Full title: Breaking Chains: Confronting Common Productivity Hurdles in Modern Software Development

Having had the opportunity to work with various organizations and teams on software projects in recent years, I've realized that many teams blindly follow established best practices or technologies without realizing that some of them can actually hinder productivity, causing delays in meeting project deadlines and diminishing developer satisfaction. Often, developers or managers, stressed by impending deadlines, worsen their situation by adopting even more inefficient practices or intentionally accruing technical debt, further complicating their circumstances. In this talk, I'll explain why some popular practices might not be as effective as commonly believed, highlighting the actual problems they solve and the specific situations in which they could be beneficial. These examples draw from my 20+ years of experience and the recognition of my company, Codeborne, as one of the more quick and efficient software development partners. Let's reconsider how teams can work more enjoyably and efficiently, minimizing wasted time. The goal is to illustrate that there are alternative, more effective ways to develop software and to give you ideas to make better choices when initiating a new project or improving your current practices.

GeeCON 2024: Anton Keks - Confronting Common Productivity Hurdles in Modern Software Development

LeadDev

As leaders we have been tasked to go all-out with AI: both in terms of our products and also our productivity. This talk outlines what you should be thinking of doing for your team, your product, and, importantly, yourself with AI.

The hype surrounding Large Language Models (LLMs) has reached a fever pitch, making it challenging for technology leaders to discern actionable strategies from speculative promises. This talk cuts through the noise, offering a pragmatic operator’s perspective on how to genuinely leverage LLMs within your organisation.

We’ll cover specific, real-world applications for boosting your engineering team’s output, from automating mundane tasks to enhancing code quality and fostering rapid prototyping. You’ll learn how to identify high-impact product features powered by LLMs that deliver quick wins, along with practical considerations for data privacy, model selection, and deployment.

Crucially, we’ll discuss how you, as a leader, can personally leverage AI for better decision-making, thinking and strategic planning, ensuring you leave with concrete steps to implement and see immediate value from AI across your team, product, and leadership approach.

Key takeaways
- Develop a clear, actionable AI strategy for your team: Learn how to assess the readiness of your engineering function for LLM adoption and identify practical tools and workflows to boost productivity and innovation without overwhelming your team.
- Identify impactful LLM applications for your product: Understand methodologies for pinpointing genuine problems LLMs can solve within your product roadmap, moving beyond surface-level integrations to create meaningful user value.
- Navigate the personal leadership shift with AI: Gain insights into how your role as a technology leader evolves with the rise of AI, including strategies for continuous learning, ethical considerations, and fostering a culture of responsible AI experimentation.

Find the slides here: https://leaddev.com/leadership/llms-an-operators-view

LeadDev Berlin 2025

LLMs: An operator’s view | James Stanier | LeadDev Berlin 2025

“It’s me– Hi. I’m the problem, it’s me,” croons Taylor Swift on her iconic track, “Anti-hero.” When it comes to the growth of those around us, this also applies to Staff+ Engineers.

Simply put, experienced ICs are often the largest barrier to growth of those around them. Leadership will turn to you when something mission critical has to get done fast. Leadership will turn to you to save someone else’s project that has run off the rails. Playing the hero feels really good in the short run. But it’s not sustainable in the long-run for you, or for the organization. Even if you don’t burn out, you slow or stunt the growth of others.

Think about when you grew most as an engineer. Some people will say, “it was when this really experienced person took me under their wing.” But most will say something like, “it was when that really experienced member of the team left, and I had no other choice but to step up.” By default, others grow more in our absence than in our presence. And, we struggle with this problem quite a bit. Our median tenure is quite high, which means the most common growth opportunity in the industry (“a senior IC leaves”) happens less often than elsewhere. This pushes us to experiment with different ways to grow others.

In this talk, I reflect on the ways I’ve tried (and often failed) to cultivate other engineers. Conventional wisdom says we should “scale” ourselves by focusing on “org wide impact”. But I’ve discovered the power of doing what doesn’t scale. When I’ve carved out time each week to invest in the three most capable engineers around me, something remarkable happens: the whole team sings.

Key takeaways:

- By default, others grow more in your absence than in your presence.
- Identifying and investing in 2-3 key people is super impactful
- Push your best people regularly out of their comfort zone

Find the slides here: https://leaddev.com/leadership/un-becoming-the-bottleneck

StaffPlus New York 2025

Un-becoming the bottleneck | Alex Poulos | StaffPlus New York 2025

Transform product-engineering tensions into strategic partnerships by addressing prioritization conflicts, technical debt advocacy, decision-making processes, and business alignment through practical collaboration frameworks.

The product-engineering partnership forms the backbone of technical delivery, yet remains one of the most challenging relationships to navigate effectively. When this alliance falters, the consequences cascade throughout the organization: delivery timelines slip, technical quality suffers, and team morale deteriorates. Development leads and engineering managers frequently encounter specific pain points: priorities that seem to change without technical consideration, insufficient investment in system health, opaque decision-making processes, and difficulty connecting daily work to strategic objectives.

Drawing from extensive experience spanning startups to enterprise organizations, this session offers battle-tested approaches that engineering leaders can implement immediately. You’ll learn how to establish mutually respected prioritization frameworks that balance business momentum with technical sustainability, create structured processes for engineering input during product planning stages, and develop shared metrics that unite rather than divide these critical functions.

Beyond process improvements, we’ll address the critical human elements of successful collaboration: building psychological safety when advocating for technical needs, establishing confidence-building communication patterns between teams, and creating the conditions where product and engineering leaders become genuine strategic partners rather than occasional collaborators. This practical session delivers concrete tools for transforming product-engineering dynamics from a source of organizational friction to a catalyst for delivery excellence. You’ll walk away with implementation frameworks you can adapt to your specific context, regardless of your organization’s size or maturity level.

Key takeaways
- Implement a balanced prioritization system that creates visibility for both technical health and product initiatives
- Establish engineering’s strategic voice through structured participation models in the product development lifecycle
- Create shared metrics and success definitions that align technical and business perspectives
- Master effective communication strategies for technical advocacy across organizational boundaries

Find the slides here: https://leaddev.com/communication/from-friction-to-function-strengthening-the-product-engineering-alliance

LeadDev New York 2025

From friction to function: Strengthening the product-engineering alliance | Kevin Goldsmith

CppCon

https://cppcon.org​
---

Agentic C++ Debugging C++ Live! - Without a Safety Net  - Daisy Hollman & Mark Williamson - CppCon 2025
---

Mark Williamson (Undo) and Daisy Hollman (Anthropic) will show more in-depth examples of AI-enhanced time travel debugging, with some audience interaction and a preview of some upcoming AI debugging technology. 
---

Sponsored by JetBrains: https://www.jetbrains.com/clion/
---

Daisy Hollman

Dr. Daisy Hollman is a distinguished software engineer and programming language expert, known for her impactful contributions to the C++ standards committee since 2016. She has worked on C++ language and library design at Google, and more recently joined Anthropic, where she explores the intersection of programming languages and AI systems.

Mark Williamson

I went through Cambridge University, UK and got drawn into the local startup ecosystem.  I've been at Undo.io building time travel debuggers for Linux C++ developers for the past 11 years, eventually landing in my current role as CTO.

Right now I'm cramming AI-related knowledge into my head as fast as it can accommodate.

Talk to me about time travel, AI agents, rock climbing and unicycles.

---


CppCon is the annual, week-long face-to-face gathering for the entire C++ community. The conference is organized by the C++ community for the community. You will enjoy inspirational talks and a friendly atmosphere designed to help attendees learn from each other, meet interesting people, and generally have a stimulating experience. Taking place this year in Aurora, Colorado, near the Denver airport, and including multiple diverse tracks, the conference will appeal to anyone from C++ novices to experts.
Annual CppCon Conference - https://www.cppcon.org
https://www.linkedin.com/company/cppcon
https://x.com/cppcon
https://www.facebook.com/CppConference
https://www.reddit.com/r/cppcon/
https://mastodon.social/@CppCon
---

Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd: https://events.digital-medium.co.uk
---

#cpp #cplusplus #cppcon #cppprogramming #cplusplusprogramming #softwaredevelopment #softwareengineering #coding #code #computerscience #technology #technews #programming #programmer

CppCon 2025

Agentic C++ Debugging Live! - Without a Safety Net - Daisy Hollman & Mark Williamson - CppCon 2025

Confreaks

These videos are from the XO Ruby conference series, lovingly captured on-site by the XO Ruby organizers themselves using Confreaks borrowed gear and their best efforts. As a friend of the community, Confreaks is handling all editing and post-production so these talks could be preserved and shared with everyone. The footage and audio reflect the grassroots, volunteer-run nature of the event — real humans doing their absolute best under conference conditions. We’re proud to help bring these talks to you and hope you enjoy the content! 

Tired of wrestling with localhost ports in your Ruby projects? A reverse proxy can simplify your local development, align it with production, and make multi-app environments effortless. In this talk, we’ll explore the evolution of reverse proxy solutions, their setup, and their role in Ruby development. Through practical examples and use cases, you’ll discover flexible strategies to enhance your local dev workflow.

Video Production by Confreaks
Follow Confreaks 👇
https://confreaks.com
https://x.com/confreaks
https://confreaks.bsky.social

XO Ruby 2025

XO Ruby Austin 2025 - Rewriting Localhost: A Modern Approach to Dev Environments by Nathan Hessler

AI Engineer

Implementing secure identity and access management for AI agents with Okta!

https://twitter.com/patjriley
https://twitter.com/CarlosFGalan

AI Engineer 2025

Identity for AI Agents - Patrick Riley & Carlos Galan, Auth0

Meeting Cpp

Monadic Operations in C++23 - Robert Schimkowitsch - Meeting C++ 2025
Slides: https://slides.meetingcpp.com

Let's talk about monads. How do they work? Why and how would you use them?

The aim of this talk is to introduce some fundamental functional programming techniques (such as monads) and explain how they make your code safer and more readable.
Using C++20 and 23 features, multiple classic condition- and loop-based code examples are transformed into a more functional, declarative form. The resulting code is less complex, has less duplication and a lower likelihood of containing bugs.

The talk is intended for anyone who would like to learn about functional programming techniques and add new tools to their code design toolbox. After it, you will

- Have an idea how functors and monads work
- Know multiple ways to pass callables to them
- Confidently use std::views::transform and std::views::join, std::optional and std::expected
- Know about some some common pitfalls and how to avoid them

Being able to read basic C++ code is recommended.

Meeting C++ 2025

Monadic Operations in C++23 - Robert Schimkowitsch - Meeting C++ 2025

EuroRust

*Panic! At The Disk Oh! - Jonas Kruckenberg at EuroRust 2025*

Unwrapping results, assertions, divide by zero: we've all seen our Rust programs panic and crash. But have you ever wondered how that happens under the hood?

Wonder no more! Over the last year I went down this rabbit hole way too deep and have returned to tell you all about Rusts most cursed feature. You will learn how panics, stack unwinding, the drop trait, and more work

*About Jonas Kruckenberg*
I'm Jonas, open-sourcerer and builderer of things, working as a Software Engineer at Mainmatter. I'm currently building the next generation Operating System. Previous work you might know: Tauri, vite-imagetools.

--------------------
*EuroRust 2026* – Get your ticket for EuroRust 2026 now and join us in Barcelona! 👉 https://eurorust.eu
EuroRust is organized by Mainmatter, experts in Rust and distributed systems  👉  https://mainmatter.com/rust/

EuroRust 2025

Panic! At The Disk Oh! - Jonas Kruckenberg | EuroRust 2025

All Things Open

Spacewalk 2026! Kick off the new year with "One big AI idea" 
January 13, 2026 | 6:30 pm ET (23:30 UTC)

All Things Open RTP goes live with a high-energy meetup focused on AI, open source, and real-world tech lessons. Expect quick talks, sharp insights, and a strong community vibe.

Schedule for the Evening:
6:30 – Kick-off/welcome, a few announcements
6:40 – One big AI idea speakers
7:50 – Closing announcements and thank you’s
8:00 – Everything wrapped up

Programming

The general focus of the evening will be AI. We'll feature 5-6 world-class speakers discussing the "one big thing" they feel our audience should be aware of / educate themselves on / know more about as we move into 2026. Talks will be 10 minutes each on the big IMAX stage and slides will be projected onto the HUGE IMAX screen. It's a (very) cool experience.

Speakers

* Mark Hinkle, CEO/Founder @ Peripety Labs
* Nithya Ruff, Head of the Amazon Open Source Program Office/Chair Linux Foundation Board
* Robert Thelen, CEO & Co-Founder, LlamaFarm
* Andre Lassiter, Managing Partner, MS3IT Business Solutions
* Eli "the Computer Guy" Etherton, Silicon Dojo

More details: https://www.meetup.com/all-things-open-rtp-meetup/events/312452401/

Spacewalk 2026

Spacewalk 2026: One big AI idea | All Things Open meetup (free live tech talks)

AWS Events

In this episode of AWS show and tell, we will get a crash course on Amazon Quick Suite, and key features driving customers to explore the tool. We will dive into the basics of Quick Suite, and then explore the Research and Automating tooling native to the Quick Suite Service.

Quick Suite Community - https://community.amazonquicksight.com/

AWS re:Invent 2025

Amazon Quick Suite: Getting Started Guide | AWS Show and Tell

This talk was recorded at NDC Copenhagen in Copenhagen, Denmark. #ndccopenhagen #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndccopenhagen.com/

Subscribe to our YouTube channel and learn every day:   
/        @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#ai #architecture #bigdata 

The customer is always right. Right!?
Well, some customers... Some customers are just impossible to please, like ticking time bombs ready to explode.
But how can we spot them in time? How can we solve the world's most difficult problem of all: Identifying the Karens among our users before it’s too late?

In this talk, we'll explore how to build AI-powered real-time streaming pipelines. Whether it’s for fun, profit, or simply seeking revenge on the Karens of the world.
We will discuss the architecture, libraries, and tools you need to perform real-time sentiment analysis on live unstructured user data coming from your own system or even social media, using Apache Kafka and Apache Flink. You'll learn about the challenges of integrating AI models into these technologies, and we'll walk through a practical, real-world example.
Finally, we'll break down the differences between using powerful large language models (LLMs) and lightweight small language models (SLMs), understand the pros and cons of each and how to pick the best one for your specific scenario.

Whether you are experienced in streaming systems and data engineering, or just curious about applying AI to solve real-world problems, this session will give you the foundation, insights, and inspiration to try it out yourself.

AI vs. Karen: Real-Time Customer Sentiment Detection at Scale - Josef Goldstein - NDC Copenhagen

This talk was recorded at NDC Copenhagen in Copenhagen, Denmark. #ndccopenhagen #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndccopenhagen.com/

Subscribe to our YouTube channel and learn every day:   
/       @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#dotnet #ai #microsoft #mobile 

Machine Learning is no longer exclusively reserved for Python or some of the more ‘hipster’ languages. Let's see what we can do while sticking to C#!

In this session, we’ll explore how to train Regression and Classification models using C# and ML.NET, and how to run those models in a .NET MAUI app, enabling offline AI analysis directly on a mobile device. We’ll also look at how to create an image classification model using Azure Custom Vision, and use it offline in our .NET MAUI app with the power of ONNX.

After this session, you’ll have a basic understanding of what Regression and Classification problems are, how to train and evaluate models with ML.NET and Azure Custom Vision and how to use these models locally in a .NET MAUI app.

Building Intelligent .NET MAUI Apps with ML.NET - Pieter Nijs - NDC Copenhagen 2025

Join us for an exciting live demo on AWS GenAI Developer Hour as we explore the cutting edge of Physical AI! In this episode, we'll build a real-world application that enables an agentic humanoid robot—powered by NVIDIA Gr00t N1.5 and Unitree G1—to perform precision pick-and-place operations while conducting real-time quality inspection. Watch as we combine computer vision, generative AI, and robotics to create an intelligent system that doesn't just move objects, but understands what it's handling. Whether you're a robotics enthusiast, AI developer, or curious about the future of automation, this hands-on session will show you how to build smarter physical AI solutions that bridge the digital and physical worlds.

Physical AI Unleashed: Teaching Humanoid Robots to Pick, Place & Inspect

This talk was recorded at NDC Copenhagen in Copenhagen, Denmark. #ndccopenhagen #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndccopenhagen.com/

Subscribe to our YouTube channel and learn every day:   
/        @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#dotnet #database 

Sometimes modelling your data in a relational database like SQL server is really hard, or awkward. And modelling it in a document database, only makes a lot of sense if the data can be persisted as document without too many relations. But what if you have data that is relational, and awkward to model in a relational database? Well, then a graph database might be the right tool for the job.

However, getting started with graph databases can be a bit daunting if you have only ever worked with SQL server. Especially since most graph databases are so "far" away from your standard Microsoft domain.

But it really doesn't have to be. Graph databases, like neo4j, are awesome for a lot of scenarios. So, maybe shying away from using them because of the daunting task of getting started isn't the best solution. And honestly, getting started with neo4j as a .NET developer, isn't really that complicated.

In this talk, Chris Klug, a senior .NET developer with 25+ years of coding experience, will give you the introduction to neo4j that he wished somebody would have given to him years ago.

In just one hour, you will see how to get neo4j up and running on your computer. How you connect to it from your .NET application. And how you query it using the Cypher query language. Basically, everything you need to get started with ne04j. Or...everything you need, to go from zero to neo4j n00b...

neo4j for the relational .NET developer - Chris Klug - NDC Copenhagen 2025

API Conference

APIs are the backbone of modern applications—but they’re also prime targets for attacks. Join Tobias Polley, CEO of predic8, at API Conference Berlin 2025 for a hands-on session on Practical API Security.

In this session, you’ll learn how to:
- Understand and mitigate the OWASP API Security Top 10 Risks (2023)
- Use API gateways and OpenAPI documents with annotated security metadata
- Implement rate limiting effectively to prevent DoS and brute-force attacks
- Think like a hacker and defend like a pro using practical offensive and defensive techniques

Gain real-world insights to secure your APIs from the ground up and protect your organization against evolving threats.

Website → https://apiconference.net/
Blog → https://apiconference.net/blog-en/
Downloads  → https://apiconference.net/library/
Newsletter → https://apiconference.net/newsletter-en/
Linkedin →   / https://de.linkedin.com/company/api-conference
Bluesky → https://bsky.app/profile/apiconference.bsky.social

API Conference Berlin 2025

Practical API Security: Learn to Attack & Defend Your APIs | API Conference Berlin 2025

This talk was recorded at NDC Copenhagen in Copenhagen, Denmark. #ndccopenhagen #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndccopenhagen.com/

Subscribe to our YouTube channel and learn every day:   
/        @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#dotnet #security #genai 

Model Context Protocol is rapidly becoming the de facto standard for LLMs and systems to communicate.

This session explores the fundamentals of the MCP protocol, how to safely implement it into our applications with the .NET SDK and Semantic Kernel, plus key considerations for building a production-ready system – like auth, rate limits, and observability.

We'll cover the basics of setting up an MCP server in .NET and exposing executable functionality as Tools, enabling any client to communicate with our application. We'll understand how Semantic Kernel's familiar concepts of Plugins and Functions map over to the world of MCP.

Let's walk through integrating .NET's native Identity services to align with MCP’s authentication spec, enforce role-based permissions using Semantic Kernel Filters, and apply rate limiting middleware to keep systems reliable and secure.

Finally we will discuss approaches to running intelligent .NET applications in the wild with .NET Aspire, open telemetry, and deploying to Azure Container Apps.

MCP with .NET: securely exposing your data to LLMs - Callum Whyte - NDC Copenhagen 2025

This talk was recorded at NDC Copenhagen in Copenhagen, Denmark. #ndccopenhagen #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndccopenhagen.com/

Subscribe to our YouTube channel and learn every day:   
/        @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#javascript #ui #ux #ui

Imagine this. You wake up as a zombie and need to integrate back into everyday life. But it’s a tough adjustment to make, being undead, as you need to order groceries and stock up on a fresh supply of brains. However, the web is more dynamic than you remember and visual notifications that are now used to communicate updates, errors, and content changes are difficult to understand. If not impossible.

We’ll explore ARIA Live Regions through the eyes of a zombie trying to navigate the modern day web. From creating an account, ordering your favorite snacks, to sending an email, we’ll experience how screen readers understand, or sometimes don’t understand, dynamic content and live region updates. We’ll explore the rules and recommended methods for incorporating live regions to create more inclusive notifications, and ultimately, we’ll find ways to replace live regions all together with more persistent and robust patterns.

The Shopping Dead: An Accessible Live Web For The Unalive - Daniel Yuschick - NDC Copenhagen 2025

The AI API landscape is booming—but it’s also a Wild West of risks: uncontrolled API keys, prompt injection attacks, privacy issues, and escalating costs. In this session from API Conference Berlin 2025, Ikenna Nwaiwu shows how AI Gateways act as the “sheriff” of your AI integrations.

Learn how to:
- Securely manage access to AI model APIs
- Enforce governance and compliance policies
- Optimize token consumption and costs
- Balance innovation with safety

Tame the chaos of AI APIs and build robust, reliable AI applications.

Website → https://apiconference.net/
Blog → https://apiconference.net/blog-en/
Downloads  → https://apiconference.net/library/
Newsletter → https://apiconference.net/newsletter-en/
Linkedin →   / https://de.linkedin.com/company/api-conference
Bluesky → https://bsky.app/profile/apiconference.bsky.social

AI Gateways: Secure & Govern Your AI APIs | API Conference Berlin 2025

Data spaces are shaping the future of secure, interoperable data sharing across industries and borders. In this session from API Conference Berlin 2025, Petteri Kivimäki explores what data spaces are, how they work across all layers of interoperability, and which initiatives, standards, and governance models are driving their adoption in Europe and beyond.

Learn how data spaces enable trusted data exchange, align with regulations, and support modern digital ecosystems.

Website → https://apiconference.net/
Blog → https://apiconference.net/blog-en/
Downloads  → https://apiconference.net/library/
Newsletter → https://apiconference.net/newsletter-en/
Linkedin →   / https://de.linkedin.com/company/api-conference
Bluesky → https://bsky.app/profile/apiconference.bsky.social

Data Spaces Explained: Interoperability, Standards & Governance

Devoxx Poland

Subscribe to our channel: https://youtube.pl/c/DevoxxPoland?sub_confirmation=1

You use various tools and frameworks but have you ever looked how they are built? Maybe you wind Netty framework and WebSockets there.
WebSockets are alternative communication method based on the TCP protocol. It allows for two-way, full-duplex communication between the client and the server. During the presentation, we will implement such a solution using Netty.

Netty is a framework that allows to create such communication (and not only), based on asynchronous events, in a very efficient way. Like every framework, it has its conventions, which I will try to introduce to you.

Recorded at Devoxx Poland 2024

Twitter: https://twitter.com/DevoxxPL
Instagram: https://www.instagram.com/DevoxxPL

Join us also here:
Devflix: https://devflix.pl

#Devoxx #DevoxxPoland #IT #Development #SoftwareDevelopment

Devoxx Poland 2024

Let's look under the hood - Netty and WebSockets • Arkadiusz Migała • Devoxx Poland 2024

Rohan Mehta and Nihar Sheth join Julian Wood to show the latest improvements to Lambda event source mappings for processing events from SQS, Kinesis, DynamoDB Streams, MSK, and Kafka. Discover how to achieve 3x faster auto-scaling and up to 200K events per second with the new Provisioned Mode for SQS. See how to reduce costs by up to 90% for low-throughput Kafka workloads. Implement advanced error handling with batch controls.
We are also available to answer any of your serverless questions.
Host:
Julian Wood - Principal Developer Advocate, AWS Serverless: https://x.com/julian_wood https://bsky.app/profile/julianwood.com https://www.linkedin.com/in/julianrwood/
Guests:
Rohan Mehta - Serverless Specialist Solutions Architect, AWS: https://www.linkedin.com/in/rohan-mehta-dev/
Nihar Sheth - Principal Product Manager, AWS Lambda: https://www.linkedin.com/in/niharsheth-aws/
Stream Links:
AWS Lambda enhances event processing with provisioned mode for SQS event-source mapping: https://aws.amazon.com/blogs/aws/aws-lambda-enhances-sqs-processing-with-new-provisioned-mode-3x-faster-scaling-16x-higher-capacity/
AWS Lambda announces new capabilities to optimize costs up to 90% for Provisioned mode for Kafka ESM: https://aws.amazon.com/about-aws/whats-new/2025/11/aws-lambda-optimize-costs-provisioned-mode-kafka/
* SUBSCRIBE TO THIS CHANNEL: https://www.youtube.com/@AWSEventsChannel
* * SERVERLESS OFFICE HOURS * *
Playlist: https://s12d.com/soh-youtube
A weekly live office hours to learn about building serverless applications. We cover a separate topic each week, including what's new with serverless, deep dives into feature launches and best practices, and explorations of real-world usecases. Join us live to ask us anything you want about serverless technologies and applications.
* * https://ServerlessLand.com * *
Your resource for learning about serverless technology.
Learn to use and build apps that scale automatically on low-cost, fully managed serverless architecture.

What's New: AWS Lambda event source mappings | Serverless Office Hours

This talk introduces hypothesis-driven development as a method for validating architectural choices. We’ll explore how to design experiments that provide actionable data, allowing teams to make informed decisions and adapt to changing requirements.

As a Staff+ engineer, you’re expected to lead complex, cross-functional initiatives, align teams around technical direction, and deliver meaningful outcomes – all in the face of ambiguity and rapid change. Yet the most important architectural decisions often happen early in a project – precisely when knowledge is limited and uncertainty is highest.

To lead effectively in this environment, you need a mindset shift: embrace the role of a lean architect and treat architecture as a series of testable hypotheses. Validate decisions early – while changes are still inexpensive and easy to make. Start small. Build steel threads: thin, end-to-end slices that deliver value and surface insight. Use them to ask sharper questions:

Will this pattern scale in production?
Are our boundaries enabling speed or creating new bottlenecks?
What is real-world usage telling us about our assumptions?
By experimenting your way to better decisions, you create space for smarter choices and generate the feedback needed to shape architecture. As successful patterns emerge, your team can invest with confidence – steadily building scalable, resilient systems one iteration at a time.

Find the slides here: https://leaddev.com/technical-direction/the-lean-architect-experimenting-your-way-to-better-decisions

The lean architect: Experimenting your way to better decisions | Maxime Najim | StaffPlus New York

AI is reshaping what’s easy to solve in technical interviews, prompting us to revisit what we ask and why. This talk explores how more thoughtful, human interviews can lead to deeper signal and better hiring.AI is reshaping what’s easy to solve in technical interviews, prompting us to revisit what we ask and why. This talk explores how more thoughtful, human interviews can lead to deeper signal and better hiring.

AI is changing the landscape of technical interviews. With tools that can generate code, explanations, and solutions in seconds, many traditional formats are losing their ability to surface meaningful signal. At the same time, AI is becoming a natural part of how engineers work – so why design interviews that ignore it?

This talk explores how we can adapt interviews to this new reality. Rather than relying on questions that are easy to offload, we’ll focus on ways to uncover deeper qualities: how candidates think through ambiguity, weigh trade-offs, and communicate their decisions. It’s not about avoiding AI—it’s about designing interviews that reveal what it can’t answer for someone.

We’ll dig into practical strategies for structuring interviews around your team’s actual workflows, crafting questions that invite thoughtful discussion, and creating an environment where candidates feel comfortable showing how they approach real problems. You’ll also learn how interviewer tone and feedback can elevate – not dilute – evaluation.

More humane interviews don’t just feel better for candidates – they give your team a clearer signal, more honest conversations, and ultimately, stronger hires.

Find the slides here: https://leaddev.com/hiring/rethinking-interviewing-in-an-ai-era

AI is making many classic interview puzzles meaningless so this talk shows how to design human centered interviews that reveal how candidates think through ambiguity, weigh trade offs and communicate decisions. Worth watching if you interview or hire engineers.

Rethinking interviewing in an AI era | Justin Lee | LeadDev Berlin 2025

ng-conf

Are you stuck in the doldrums of endless subscribe and unsubscribe just to load data? Chart a cleaner course with httpResource, Angular's API for retrieving data directly into Signals! No manual subscribe, no unsubscribe, no wrapper code, no mutiny.

In this session you will:
- Discover where httpResource fits into Angular's Signals‑first reactivity model
- Navigate concise examples that demystify httpResource syntax
- Conquer loading, refetching, and error handling with minimal code
- Fathom when to declare a resource in a service vs in a component

You'll sail away with a treasure chest of practical code examples and fresh insights to steer your next project through the subscription-free seas of httpResource.

Join the Angular Community: http://www.ng-conf.org/
Get your ng-conf tickets: https://ti.to/ng-conf
Follow Us: https://twitter.com/ngconf
Read More: https://medium.com/ngconf 
Hear More: http://theangularshow.com 

ng-conf is a multi-day Angular conference focused on delivering the highest quality training in the Angular JavaScript framework. Developers from across the globe converge on Salt Lake City, UT every year to attend talks and workshops by the Angular team and community experts.

ng-conf 2025

Signal the Sails: Loading Data with httpResource() | Deborah Kurata | ng-conf 2025

These videos are from the XO Ruby conference series, lovingly captured on-site by the XO Ruby organizers themselves using Confreaks borrowed gear and their best efforts. As a friend of the community, Confreaks is handling all editing and post-production so these talks could be preserved and shared with everyone. The footage and audio reflect the grassroots, volunteer-run nature of the event — real humans doing their absolute best under conference conditions. We’re proud to help bring these talks to you and hope you enjoy the content! 

Tech as an industry is in a weird place right now. Far from being just for hobbyists, technology companies are the biggest companies in the world with market caps exceeding the GDP of many countries. Tech takes up an increasing amount of space in our lives while simultaneously becoming less fun than it once was.
In this talk we'll explore how we got here, and more importantly, actionable things we can do to help make tech better in our own lives and in the world around us.
Maybe, just maybe, there is a path to feeling optimistic again.

Video Production by Confreaks
Follow Confreaks 👇
https://confreaks.com
https://x.com/confreaks
https://confreaks.bsky.social

XO Ruby Austin 2025 - The Vibes Are Off in Tech (but we can fix them) by Aaron Harpole

These videos are from the XO Ruby conference series, lovingly captured on-site by the XO Ruby organizers themselves using Confreaks borrowed gear and their best efforts. As a friend of the community, Confreaks is handling all editing and post-production so these talks could be preserved and shared with everyone. The footage and audio reflect the grassroots, volunteer-run nature of the event — real humans doing their absolute best under conference conditions. We’re proud to help bring these talks to you and hope you enjoy the content! 

On December 22, 1978, veteran US Navy pilot Jay Prochnow found himself lost over the Pacific in a tiny single-engine plane after a navigation failure during a solo ferry flight. With no land in sight and nightfall approaching, he had to find a way to survive. This is the story of how he navigated out of the crisis – and what we can learn from his experience.

 Video Production by Confreaks
Follow Confreaks 👇
https://confreaks.com
https://x.com/confreaks
https://confreaks.bsky.social

XO Ruby Austin 2025 - Lost and Alone Over the Pacific by Nickolas Means

When we were asked to bring order to the chaos of a 100,000 sq ft warehouse run on spreadsheets, the default advice was clear: “just buy something.” But after seeing the brittle integrations and inflexible workflows of off-the-shelf systems, we took the road less purchased.

In this talk, I’ll walk through the architecture of the Warehouse Management System (WMS) we built in Clojure and Datomic. I’ll cover:

* How we got the buy-in to build
* How we modeled the entire warehouse as a state machine
* What happened when financial tracking interfered with workflows on the floor
* How Datomic’s time traveling saved us after an accidental reset
* Datomic Cloud gotchas and how we mitigated them

You'll walk away with concrete patterns for building resilient systems in Datomic—plus a few hard-earned lessons on what to avoid when your ops team also wears steel-toed boots.

Biography

Tim Pote is a backend engineer and consultant with 14+ years of experience building distributed systems. He has deep expertise in Clojure and Datomic and authored Fusebox, a fault-tolerance library for Clojure. Most recently, he led the design and development of a warehouse management system from scratch—turning forklifts and spreadsheets into a state machine. Tim runs Edgedancer, a consultancy focused on helping Clojure companies build systems that scale with ease.

Recorded Nov 13, 2025 at Clojure/Conj 2025 in Charlotte, NC.

Forklifts, Facts, and Functions: Building a Warehouse Management System with Clojure+Datomic - Pote

https://cppcon.org
---

Best Practices for AI Tool Use - Jason Turner - CppCon 2025
---

AI (LLMs) are becoming prolific in C++ tooling. Virtually everything has an AI bot built in or available to it. Common wisdom says that these tools simply regurgitate what they find on the internet. As we all know, the internet is full of terrible examples of outdated memory leaks, undefined behavior, and worse!

How do we effectively and safely use these tools while ensuring good code quality?! 
 
---

Slides: https://github.com/CppCon/CppCon2025/blob/main/Presentations/Best_Practices_For_AI_Tool_Use.pdf

Work at Hudson River Trading (HRT): https://tinyurl.com/safxfctf
---

Jason Turner
 
Jason is host of the YouTube channel C++Weekly, co-host emeritus of the podcast CppCast, author of C++ Best Practices, and author of the first casual puzzle books designed to teach C++ fundamentals while having fun!
---

CppCon is the annual, week-long face-to-face gathering for the entire C++ community. The conference is organized by the C++ community for the community. You will enjoy inspirational talks and a friendly atmosphere designed to help attendees learn from each other, meet interesting people, and generally have a stimulating experience. Taking place this year in Aurora, Colorado, near the Denver airport, and including multiple diverse tracks, the conference will appeal to anyone from C++ novices to experts.
Annual CppCon Conference - https://www.cppcon.org
https://www.linkedin.com/company/cppcon
https://x.com/cppcon
https://www.facebook.com/CppConference
https://www.reddit.com/r/cppcon/
https://mastodon.social/@CppCon
---

Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd: https://events.digital-medium.co.uk
---

#cpp #cplusplus #cppcon #cppprogramming #cplusplusprogramming #softwaredevelopment #softwareengineering #coding #code #computerscience #technology #technews #programming #programmer

AI is everywhere in C++ tooling and those models can spit out outdated memory leaks, undefined behavior and worse. Watch this talk for clear rules and examples to use AI helpers safely and keep your C++ code correct.

Best Practices for AI Tool Use in C++ - Jason Turner - CppCon 2025

*What actually are attributes? - Jana Dönszelmann at EuroRust 2025*

Attributes are a super versatile tool. They can add metadata to almost any part of rust’s syntax. This is great for designing new features in the language: if their syntax can just be an attribute, the parser and therefore high-level syntax doesn’t need to change. And that’s not just useful inside the compiler; Rust gives that power to users through attribute macros, so they can add their own syntax to the language. Think of serde to add serialization, or tokio’s attribute that lets main be async. Of course, with attributes around, every new feature’s syntax looks like an attribute-shaped hole, leaving us with critical parts of the language being just attributes, instead of having proper syntax.

Over the past year, I’ve worked on refactoring the parts of the compiler that processes attributes, and this talk is about some of the things this taught me about language design. About how they are both critically necessary, and an absolute pain to have. And to motivate that, I’ll show some funny bugs I found in the compiler while refactoring them.

*About Jana Dönszelmann*
Hi! I’m Jana (she/her). For the past years I taught embedded systems, in Rust, at the university of Delft. Now I work almost full-time on rustc in the compiler team as part of Hexcat, and co-organise Rust meetups and conferences.

When I’m not doing that, I’m probably playing guitar or board games.

--------------------
*EuroRust 2026* – Get your ticket for EuroRust 2026 now and join us in Barcelona! 👉 https://eurorust.eu
EuroRust is organized by Mainmatter, experts in Rust and distributed systems  👉  https://mainmatter.com/rust/

What actually are attributes? - Jana Dönszelmann | EuroRust 2025

Welcome to Season 5 of AWS Tech Tales. If you're new here, this is the show where we talk about real life customer issues and what you can do to solve them! Today we'll be tackling centralized networking using Gateway Load Balancers and Transit Gateway. Can you help us solve our connectivity and routing issues before the episode's end? Show us what you know about route tables and GWLBs in the chat!

The Tale of Troubleshooting Centralized Networking

Code Sync

✨This talk was recorded at ElixirConf EU 2025. If you're curious about our upcoming event, check https://elixirconf.eu ✨

Abstract:
Whisperer is a framework for building and orchestrating multi-agent AI systems or any form of workflow-related system.
At MonitorLizard (an opentelemetry-based Agentic AI-powered Observability platform), we needed a simple way of building and orchestrating observability-based agents, which help te:00s investigate and fix production issues. This led to the creation of Whisperer, which we’ve recently open-sourced.
At its core, Whisperer is a set of behaviours for defining agents and a fault-tolerant orchestrator capable of sequencing and executing these agents by leveraging the power of LLMs. Whisperer is a framework instead of a library; it lets you decide what implementations to use for your agents and sequencing strategy while abstracting away the hassle of orchestration.
In the ever-changing landscape of LLMs and Agentic systems, where implementation changes often, Whisperer serves as a solid blueprint for utilising improvements in the space while keeping the core stable.


Let's keep in touch! Follow us on: 
💥 Bluesky: https://elixirconf.bsky.social
💥 X: https://twitter.com/ElixirConfEU 
💥 Facebook: https://www.facebook.com/CodeSyncGlobal 
💥 LinkedIn: https://www.linkedin.com/company/code-sync
💥 Mastodon: https://genserver.social/codesync

ElixirConf EU 2025

Whisperer - An Elixir based Multi Agent Workflow Framework  - Sola Aremu 'Pelumi & Ridwan Otun

This talk was recorded at NDC TechTown in Kongsberg, Norway. #ndctechtown #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndctechtown.com/

Subscribe to our YouTube channel and learn every day:   
/      @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#cplusplus 

While OOP class hierarchies are a C++ staple, they can sometimes lead to performance issues due to scattered data, or unintentionally obscure the core logic of data transformations.

Data-Oriented Design (DOD) presents a different way of thinking: prioritizing data layout not only unlocks significant performance gains via cache efficiency but can also lead to surprising simplicity in the code that actually processes the data.

This talk is a practical introduction for C++ developers familiar with OOP. Through a step-by-step refactoring of a conventional OOP design, we'll both cover how data access patterns influence speed and how a data-first approach can clarify intent.

We’ll measure the performance impact with benchmarks and analyze how the refactored code, particularly the data processing loops, can become more direct and conceptually simpler.

Key techniques like Structure-of-Arrays (SoA) vs. Array-of-Structures (AoS) will be explained and benchmarked, considering their effects on both execution time and code clarity. We’ll pragmatically weigh the strengths (performance, simpler data logic) and weaknesses of DOD, highlighting how it can complement, not just replace, OOP.

We'll also demonstrate that DOD doesn't necessitate abandoning robust abstractions, showcasing C++ techniques for creating safe, expressive APIs that manage both complexity and performance.

Let's learn how thinking "data-first" can make your C++ code faster and easier to reason about!

NDC TechTown 2025

More Speed & Simplicity: Practical Data-Oriented Design in C++ - Vittorio Romeo - NDC TechTown 2025

This talk was recorded at NDC TechTown in Kongsberg, Norway. #ndctechtown #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndctechtown.com/

Subscribe to our YouTube channel and learn every day:   
/      @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#rust #keynote #api 

Rust users are often very enthusiastic about their language. Sometimes annoyingly so. Where does this enthusiasm come from? There has been a lot of talk about Rust memory safety, but this does not explain why users are so positive about the language.

Rust users will sometimes try to explain how Rust programs seem to "just work". Is there something to this? Where does this come from? And could this explain part of the enthusiasm?

It could be argued that Rust is not really about memory safety specifically, but more about making incorrect programs in general harder to write.

This talk will try to cover some of the language features and techniques behind this, like:
- The strong type system
- Strongly typed error handling
- The lack of implicit conversions
- Good API design for types like Options and Result
- Sum types and pattern matching
- The typestate pattern

Keynote: Rust is not about memory safety - Helge Penne - NDC TechTown 2025

This talk was recorded at NDC TechTown in Kongsberg, Norway. #ndctechtown #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndctechtown.com/

Subscribe to our YouTube channel and learn every day:   
/      @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#cplusplus 

C++ has many problems: issues with memory safety, bounds safety, type safety, and especially undefined behavior — to just name a few. However, while this may be true for old C++ standards, today we already have wonderful solutions: ranges, value semantics, strong types, concepts, constexpr, … Using those makes it almost impossible to experience problems with these safety issues. So the question is: why do C++ developers still experience problems and why is C++ still perceived as problematic?

In this talk, we will focus on what really goes wrong in the C++ industry. We’ll talk about the 10% bubble, i.e. the fact that the vast majority of “C++ developers” is not fully aware of the state of the art and does not use the recommended tools and features. We’ll take a look at the reason why current teaching material
is not consequently updated to the newest best practices. And finally, we’ll consider the lack of investment into good programmers. Although initially it may sound like a legacy problem, we’ll come to realize that C++ has a people problem.

"No matter what they tell you, it's a people problem" (Gerald Weinberg)

The Real Problem of C++ - Klaus Iglberger - NDC TechTown 2025

This talk was recorded at NDC TechTown in Kongsberg, Norway. #ndctechtown #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndctechtown.com/

Subscribe to our YouTube channel and learn every day:   
/     @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#cplusplus 

Clang 20 introduced Function Effect Analysis (FEA), which enables real-time safety guarantees at compile-time. Mark your functions as non-throwing, non-allocating, or non-blocking — and have the compiler enforce it! For instance, a function marked non-allocating is not allowed to call malloc or new, and can only call other functions if they are also marked non-allocating (or if the compiler can deduce that they won't allocate).

In this talk, we will demonstrate function effect analysis and explain how it works. We will also see why it can be hard to enable FEA in the presence of third-party libraries, and what can be done about it.

At Squarehead, we've used FEA almost since its official release to refactor our soft real-time pipeline towards harder real-time. We will present our experience and lessons learned from this process, and the talk will be packed with useful real-life tips, tricks, and practices to set you up for success.

If time permits, we will also demonstrate the brand-new RealtimeSanitizer, the run-time companion to FEA.

After this talk, you'll know how and why to use Function Effect Analysis and RealtimeSanitizer and be aware of real-life tips, tricks, and practices for using them in your own projects.

Real-time Safety — Guaranteed by the Compiler! - Anders Schau Knatten - NDC TechTown 2025

This talk was recorded at NDC TechTown in Kongsberg, Norway. #ndctechtown #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndctechtown.com/

Subscribe to our YouTube channel and learn every day:   
/     @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#testing #rust 

Volvo Cars have shipped their first ECU (Electronic Control Unit) fully written in Rust as part of the new SPA2 EV platform. This is the first of its kind in the automotive industry.

I will describe the project, how it came about and why Rust in cars is a great idea!

A shortened version of this talk will be presented at RustWeek 2025

Volvo Cars shipped an ECU fully written in Rust; this talk shows how they did it and why Rust belongs in cars.

Rust at Volvo Cars - Julius Gustavsson - NDC TechTown 2025

This talk was recorded at NDC TechTown in Kongsberg, Norway. #ndctechtown #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndctechtown.com/

Subscribe to our YouTube channel and learn every day:   
/      @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#cplusplus #python 

Parallel programming can be intimidating, but doesn’t need to be! There's a new paradigm for parallel programming that's newcomer-friendly, highly productive, and performant: block-based programming.

Block-based programming models divides inputs into local arrays (tiles) that are processed concurrently by groups of threads (blocks). Users write sequential array-centric code, and the framework handles parallelization, synchronization, and data movement behind the scenes. Block-based models have been around for a long time, but in recent years, they've grown in popularity for GPU programming in languages such as [Triton](https://openai.com/index/triton/), [JAX/Pallas](https://docs.jax.dev/en/latest/pallas/index.html), and [Warp](https://nvidia.github.io/warp/modules/tiles.html), aiming to make parallelism more accessible and increase portability.

In this example-driven talk, we'll cover the basics of block-based programming in both Python and C++. We'll present cuTile, NVIDIA's new block-based programming model for Python, C++, and other languages, and Tile IR, the new compiler stack that it is built with. We'll reveal new details about this new technology for the first time in this talk. We'll compare and contrast block-based models with traditional parallel programming models.

We'll look at a variety of examples, including a new tile-based [LLAMA3](https://github.com/meta-llama/llama3)-based large language model demo, a stencil code, and an FFT solver.

In this session, you'll:
- Learn the best practices for writing block-based parallel applications for CPUs and GPUs.
- Gain insight into the performance of block-based code and how it actually gets executed.
- Discover how to reason about and debug block-based applications.
- Understand the differences between block-based and traditional parallel programming and when each paradigm should be used.

By the end of the session, you'll understand how block-based programming enables more intuitive, portable, and efficient development of high-performance, data-parallel applications.

Block-Based Parallel Programming - Bryce Adelstein Lelbach - NDC TechTown 2025

This talk was recorded at NDC TechTown in Kongsberg, Norway. #ndctechtown #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndctechtown.com/

Subscribe to our YouTube channel and learn every day:   
/      @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/



Interested in how to use parallel algorithms from the C++ standard library in your own projects? In this talk, I’ll walk you through what’s available, how they work, and where they can help - using simple examples to keep things clear and practical.

We’ll look at which standard algorithms can be parallelized and how their behavior changes when you apply parallel execution. I’ll also show you a few special algorithms that are only available in the parallel world.

Then, we’ll dive into execution policies: what they do, when to use which one, and what their trade-offs are. Along the way, I’ll share small examples to make the concepts easier to grasp and explain the reasoning behind the design choices.

To wrap up, we’ll talk about the current limitations of this approach, and I’ll give you a quick peek at what’s coming next in the C++ standard related to parallelism.

If you’re curious about parallel features in C++ and want a hands-on introduction - this session is for you.

Parallel Algorithms: Work Smarter, Not Harder - Jana Machutová - NDC TechTown 2025

This talk was recorded at NDC TechTown in Kongsberg, Norway. #ndctechtown #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndctechtown.com/

Subscribe to our YouTube channel and learn every day:   
/      @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/


Practical software does not run in an abstract vacuum, it runs on underlying hardware platforms. Practical software engineering does not exist in an abstract vacuum either. The software layer sits in between the domain specific requirements on top and the underlying runtime platforms below. Many interesting developments have happened on all three of those layers over the years, and while contemporary hardware has gone a long way forward, it often suffers from the attention deficit caused by an overshadowing flood of advancements and “advancements” in the software part of the universe. This new shiny programming language is safe, performant, and solves a backlog of problems that have been dragging for long. While that new shiny programming paradigm automagically relieves from dealing with low level details and the toolchain is plain amazing. The hardware side brings into this fistfight a set of new architectures, ISAs, and hardware abstractions – just to stay on par with the software side. Looks perfect? What else would an engineer dream about, no?

Not really. Let’s take a look at the contemporary commodity hardware platforms of today, and also at the trendy software engineering waves of today, and try to sense how and why it could (and frequently does) cross out the potential benefits of hardware advancements – and what could be done to actually be friendly to your underlying hardware, and at what cost.

This is a set of somewhat separate topics, bound together into a common logical set of performance engineering.

How do language constructs such as references, lambdas, inheritance, object representation, runtime checks, and selected STL examples map to the actual runnable platform level code, and at what cost.

The notion of out-of-order execution, claims on whether OoO is superior and there is no need to look at the level of instruction selection. What specifically is out of order in the context of contemporary x86 platforms (surprisingly, it is not instructions), and what impact does it have to the overall performance. A brief look into where the complexity lies inside the contemporary high performance execution cores and sockets, and why aspects such as variable length instruction encoding are trivial to resolve.

Memory hierarchy operation, logical, physical, and geometrical address spaces, their relationship and translations, memory performance in virtual address spaces, and clever ways to hide capacitor array’s latency.

Vectorization and why it is still not there yet universally everywhere, and why it won’t be?

Data dependencies and what could be done about it.

How could one help the compiler to do the right thing, and yet more important – how could one stay away from making things more complex for the compiler to do the right thing.

Branching control.

ABI aspects, parameter passing, compilation unit scope and its impact.

The claims on the imminent obsolescence of x86 and how the new wave of ARM and RISC-V upstarts will overtake it once again after previous not so successful attempts.

This is a reasonably simplified talk on a set of interrelated topics for generalist software engineering audience, motivated by the trends of handwaving on how Rust, Go, Zig, D, and the species yet unseen will take over C with classes and solve all the outstanding problems in the field of performance, security, time to market, and global warming too. A viewpoint is from someone dealing with performance optimization in domains of network engineering, electronic trading, and high performance computing. No specialty background is required and expected from the target audience, although the depth of coverage is targeted for senior engineering staff sufficiently proficient in the contemporary software engineering ecosystem. The content itself would be a lightened-up version of specialty workshops organized for hardware engineers on how software expects to see the platform, and for software engineers on what the underlying hardware actually does; not presented publicly previously. Content could be tweaked according to the target audience profile if you would see a need for that, however it is not expected to be an entry-level talk at all. The level of possible technical opinionated argumentation, reaching up to controllable flaming, is also possible, either via a format of a workshop-style presentation, or a panel discussion.

Performance engineering - being friendly to your hardware - Ignas Bagdonas - Ignas Bagdonas

This talk was recorded at NDC TechTown in Kongsberg, Norway. #ndctechtown #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndctechtown.com/

Subscribe to our YouTube channel and learn every day:   
/      @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#cplusplus 

Serialization in embedded systems often goes far beyond standard formats like JSON or XML. While integrating hundreds of different messages across a wide range of sensors for next-generation military submarines, our team encountered archaic and highly specialized data formats—including 5-bit integers, 3-byte floating-point numbers, and manufacturer-specific encodings.

This talk will detail our approach to building a flexible and efficient serialization library in C++. Inspired by libraries like cereal but designed for the unique constraints of embedded systems, our solution enables complex data formats to be implemented declaratively - minimizing code duplication across serialization, deserialization, and logging.

Attendees will gain insights into leveraging C++ templates and concepts to design serialization systems that balance adaptability with maintainability.

Adventures in Serialization: A Flexible Approach for Embedded Systems in C++ - Jørn Bersvendsen

This talk was recorded at NDC TechTown in Kongsberg, Norway. #ndctechtown #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndctechtown.com/

Subscribe to our YouTube channel and learn every day:   
/      @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#cplusplus #clanguage 

In this talk we cover the topic of autovectorization. We explain what are vector instructions, and explain the process of autovectorization, when the compiler emits vector instructions to make your loop faster.

The main focus of the talk are vectorization inhibitors: parts of your C++ code that prevent automatic compiler vectorization. We give examples of unvectorized loops, we examine CLANG's vectorization report and we give solutions that will make codes several times faster with minimal modification.

Faster programs with your compilers autovectorization feature - Ivica Bogosavljevic - NDC TechTown

This talk was recorded at NDC TechTown in Kongsberg, Norway. #ndctechtown #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndctechtown.com/

Subscribe to our YouTube channel and learn every day:   
/      @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#tools #language #rust 

Often when new languages like Rust get introduced, it starts with a hobby project and simple proof of concepts. But what does it take to go beyond that and use it in production?

Akiles is a manufacturer of access control devices and have been using Rust to program our embedded devices for over 4 years. Embedded Rust projects like Embassy started at Akiles, and have since flourished and grown into a widely used open source project.

This talk will give an introduction to the Embedded Rust ecosystem, async Rust, and share our experience using Rust in production at Akiles.

Embedded Rust in Production - Ulf Lilleengen - NDC TechTown 2025

This talk was recorded at NDC TechTown in Kongsberg, Norway. #ndctechtown #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndctechtown.com/

Subscribe to our YouTube channel and learn every day:   
/      @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#python #language #rust 

Achieving memory safety on microcontrollers is hard, perhaps even harder than elsewhere.

In this talk, we will explore two readily available options. On the one side, there is MicroPython, an implementation of Python that targets microcontrollers. Python is a powerful and expressive language, and manages its memory with a garbage collector. Unfortunately, it is also famous for its performance limitations, which are even more pronounced in constrained environments.

On the other side, we can reach for Rust, a modern systems language with zero-cost abstractions and ownership-based memory management. As a drawback, the language is arguably more difficult to use, and its ecosystem for embedded environments is (still) not quite mature enough.

What if we could combine the advantages of the two?

This session explores the intersection of the contrasting programming paradigms and how they can coexist within the constrained memory space of a microcontroller. We'll cover the background on both languages’ memory models, and specific challenges encountered when they interact, such as ownership conflicts, buffer aliasing issues, and garbage collection considerations.

We will present the experiences gained when implementing a Rust-MicroPython interop layer, solutions to some of the problems outlined above, and techniques for implementing a safe Rust API for extending MicroPython.

Extending MicroPython with Rust: Two Worlds Collide - Jan Matějek - NDC TechTown 2025

Your weekly deep dive into cloud security, where technical expertise meets real-world application. Join hosts Russ Noll and Tristan Watty Ph.D. every Monday at 11am PST for an hour of comprehensive cloud security content that bridges the gap between technical implementation and practical business solutions. In this episode, we level up from our Control Tower foundation by collecting the Landing Zone Accelerator power up that transforms your baseline environment into an enterprise grade security fortress. Think of this as equipping your character with enhanced abilities. You've learned the core mechanics in World 1-1, and now it's time to unlock the advanced strategies that let you solve enterprise-level challenges.

World 1-2: Power-Up Collected - Landing Zone Accelerator Activated

This talk was recorded at NDC TechTown in Kongsberg, Norway. #ndctechtown #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndctechtown.com/

Subscribe to our YouTube channel and learn every day:   
/      @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#cplusplus 

C++ is beautiful in the way that even the simplest things can be unexpectedly challenging and complex. You’d think that nothing could be easier than declaring a constant, right?

Choose the most suitable way to define it: a global variable, a local variable, or a static class data member. Maybe a template. Set the right linkage and storage duration. Use some combination of specifiers like static, inline, and constexpr for that. Maybe use extern in some cases. How does it play along with modules by the way?..

If all of this is obvious to you — congratulations! That’s impressive. But if this whole zoo makes your head spin a bit, let’s try to untangle it together.

How to declare a constant in C++ - Mikhail Matrosov - NDC TechTown 2025

✨ This talk was recorded at MQ Summit 2025. If you're curious about our upcoming event, check https://mqsummit.com/ ✨

Securing your messaging networks is vital. Preventing malicious actors from attacking your business is crucial to prevent monetary or reputation loss. But where in your network needs protecting?

In this session Rob Parker, Security Architect for IBM MQ, will share the key areas that need protecting in messaging networks as well as how best to protect them.

Let's keep in touch! Follow us on:
💥 Twitter:   / MQSummit 
💥 BlueSky:   / mqsummit.bsky.social 
💥 LinkedIn:   / mqsummit

MQ Summit 2025

This talk shows which parts of your messaging network actually need protecting and gives concrete steps to secure brokers, topics and connections.

Securing your messaging networks: What needs protecting and how? - Rob Parker | MQ Summit 2025

✨ This talk was recorded at Code BEAM Europe in November 2025. If you're curious about our upcoming event, check https://codebebeameurope.com ✨
---
They wanted to get Discord messages imported into the system. This service didn't need to integrate with any of our existing libraries. This was it. I slowly realised: my chance to write this in Elixir! Unfortunately, they didn't love functional programming languages -- they almost didn't hire me because I seemed too "FP". But nothing ventured, nothing gained. I typed out "git push", I clicked Enter. Took a deep breath and hoped I wouldn't get fired.
We've all been forced to adopt the tech stack at the companies we've worked at. Wouldn't it be nice to use Elixir instead? I've been lucky enough to actually work on technology that I found interesting, whether that meant mounting a satellite dish on the top of our building at Netscape to get stock information (yes, the old days!) on our SGI servers or Elixir for games and AI.
Or is it luck? Sometimes the benefit of choice comes with your title and position, or the relationship you have with the decision makers. But sometimes, it's just about finding the right opportunity and approach.
This talk explores the soft strategies I've employed to achieve this -- and how "soft" doesn't always mean easy. Soft can be hard.
---
Let's keep in touch! Follow us on:
💥 Bluesky: / codebeam.bsky.social
💥 Twitter: / codebeamio
💥 LinkedIn: / code-sync

Code BEAM Europe 2025

Softly, Surely: Bringing Elixir to Work - Ellyse Cedeno | Code BEAM Europe 2025

🔄 Upgrade Rollout Policy – Minimize downtime and risk during database version upgrades with intelligent, phased rollout strategies that keep your applications running smoothly.
⚡ Zero-ETL for Self-Managed Databases – Break down data silos without complex pipelines! Discover how to seamlessly integrate your self-managed databases with AWS analytics services for real-time insights.
💰 Database Savings Plans – Optimize your database costs with flexible pricing models that deliver significant savings on your database workloads.

Relational Database Innovations from re:Invent 2025 - Part 2

CITYJS CONFERENCE

In this talk, we'll explore the capabilities of React's Context API and learn how to use its powerful features outside of React to declutter our code, reduce bloat, and simplify our functions' signatures. We'll make use of JavaScript fundamentals to build this API from scratch, and by the end of the talk, you'll be able to use it in your vanilla JavaScript and node applications. Join me as we dive into the world of React's Context API and discover how to harness its power in your own projects. You won't want to miss this exciting opportunity to learn a new approach to building efficient, effective applications.

CityJS Athens 2025

Evyatar Alush - Let's Build React Context From Scratch in JS

Everyone is building AI Agents, and everyone is looking for ways to build them more easily. Earlier this year, OpenAI released the OpenAI Agents SDK to bring the patterns they have found to work for building agents to the developer community. With the SDK you can define AI agents by supplying them instructions (prompts), specifying which model to use (OpenAI or not), listing tools it uses (including MCP), and much more. The OpenAI Agents SDK encourages a paradigm of orchestrated micro-agents, which themselves may have micro-orchestrations within them with the use of handoffs. It’s an elegant and powerful model.

But a good AI Agents programming model is not enough. These agents are ultimately wildly distributed systems and are plagued with all of the problems such systems bring.

- How can they persevere through flakey networks?
- How can they function when LLMs are rate limited?
- How can they run for long periods of time (hours, days, weeks, months) when infrastructure is rarely stable that long?

In this workshop, we’ll show you how. Temporal is an open source (MIT license) durable execution framework that brings resilience to AI agents, and in this workshop we’ll show you how it’s done with the OpenAI Agents SDK. Spoiler: OpenAI and Temporal have done all of the heaving lifting for you with an integration announced earlier this year.

Oh, and OpenAI themselves use Temporal to help make several of their products production ready (image gen and Codex, for example).

Not using the OpenAI Agents SDK? Do come anyway; the foundational concepts carry over to different agent frameworks (and more integrations are coming all the time).

https://twitter.com/cdavisafc
https://www.linkedin.com/in/corneliadavis

OpenAI + @Temporalio : Building Durable, Production Ready Agents - Cornelia Davis, Temporal

Too many MCP servers are simply glorified REST wrappers, regurgitating APIs that were designed for SDKs, not agents. This leads to confused LLMs, wasted tokens, and demonstrably poor performance. If you've ever pointed an MCP generator at an OpenAPI spec and called it a day, this talk is your intervention.

Like any product, great MCP servers are the result of careful design. This talk shares the hard-won lessons from creating FastMCP, the most popular framework for building MCP servers (and yes, for generating them, too). The secret is to stop thinking about endpoints and start thinking about products. We will cover the three pillars of agent-native product design—Discovery, Iteration, and Context—providing an actionable framework for curating context into small, highly effective surface areas that lead to better AI outcomes.

Jeremiah Lowin, CEO of Prefect
https://twitter.com/jlowin
https://www.linkedin.com/in/jlowin
https://github.com/jlowin

Your MCP Server is Bad (and you should feel bad) - Jeremiah Lowin, Prefect

How can I stick with my project? Are rewrites bad? How do I get the community involved? What are some development practices which can make life saner in a long-running project?

In this talk, we'll discuss answers to each of these questions. We'll cover my experience building jank, the native Clojure dialect, for over a decade. We'll also look forward, at the next decade of jank development.

You'll leave this talk equipped with some practical philosophies to help you finish your projects and hopefully some inspiration to check out jank.

Biography

Jeaye is the creator of the jank programming language, a Clojure dialect on LLVM with seamless C++ interop.

Jeaye has a background in C++ systems programming, focusing on games and game engines. After over a decade in game development, he's focused on building tools to make native programming saner.

Recorded Nov 14, 2025 at Clojure/Conj 2025 in Charlotte, NC.

How to stick with your projects, even when they're janky - Wilkerson

These videos are from the XO Ruby conference series, lovingly captured on-site by the XO Ruby organizers themselves using Confreaks borrowed gear and their best efforts. As a friend of the community, Confreaks is handling all editing and post-production so these talks could be preserved and shared with everyone. The footage and audio reflect the grassroots, volunteer-run nature of the event — real humans doing their absolute best under conference conditions. We’re proud to help bring these talks to you and hope you enjoy the content! 

What would it take to recreate the magic of TikTok, snappy feeds, endless scroll, and smart recommendations, using only Ruby on Rails? This talk explores just how far Rails can go as a full-stack framework, from building modern UIs to experimenting with feed algorithms that keep content engaging.

Video Production by Confreaks
Follow Confreaks 👇
https://confreaks.com
https://x.com/confreaks
https://confreaks.bsky.social

XO Ruby Austin 2025 - TikTok on Rails by Cecy Correa 2

These videos are from the XO Ruby conference series, lovingly captured on-site by the XO Ruby organizers themselves using Confreaks borrowed gear and their best efforts. As a friend of the community, Confreaks is handling all editing and post-production so these talks could be preserved and shared with everyone. The footage and audio reflect the grassroots, volunteer-run nature of the event — real humans doing their absolute best under conference conditions. We’re proud to help bring these talks to you and hope you enjoy the content! 

What started as a simple side project to find things to do in my city evolved into a full AI-powered event recommendation engine. I'll share how I've been building an intelligent event discovery platform in my spare time using Ruby.

Video Production by Confreaks
Follow Confreaks 👇
https://confreaks.com
https://x.com/confreaks
https://confreaks.bsky.social

XO Ruby Austin 2025 - Rag Demystified by Landon Gray

https://cppcon.org​
---

Back To Basics: C++ Strings and Character Sequences - Nicolai Josuttis - CppCon 2025
---

Strings are a key datatype for each programming language. At first, using strings in C++ looks easy. However things can pretty fast cause surprises and become complicated. 
 
 In this talk we look at the details every programmer should be aware of: 
- The various types for strings and character sequences
- The type and value category of string literals
- Dealing with internationalization (I18N)
- Raw strings
- The short string optimization (SSO)
- Optimization of strings versus string views
- Type conversions and lifetime dependencies 

---

Slides: https://github.com/CppCon/CppCon2025/blob/main/Presentations/Back_To_Basics_Strings_and_Character_Sequences.pdf

Sponsored by JetBrains: https://www.jetbrains.com/clion/
---

Nicolai Josuttis
 
---

CppCon is the annual, week-long face-to-face gathering for the entire C++ community. The conference is organized by the C++ community for the community. You will enjoy inspirational talks and a friendly atmosphere designed to help attendees learn from each other, meet interesting people, and generally have a stimulating experience. Taking place this year in Aurora, Colorado, near the Denver airport, and including multiple diverse tracks, the conference will appeal to anyone from C++ novices to experts.
Annual CppCon Conference - https://www.cppcon.org
https://www.linkedin.com/company/cppcon
https://x.com/cppcon
https://www.facebook.com/CppConference
https://www.reddit.com/r/cppcon/
https://mastodon.social/@CppCon
---

Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd: https://events.digital-medium.co.uk
---

#cpp #cplusplus #cppcon #cppprogramming #cplusplusprogramming #softwaredevelopment #softwareengineering #coding #code #computerscience #technology #technews #programming #programmer

Back To Basics: C++ Strings and Character Sequences - Nicolai Josuttis - CppCon 2025

Sanitize for your Sanity: Sanitizers tools for Modern C++ - Evgenii Seliverstov - Meeting C++ 2025
Slides: https://slides.meetingcpp.com

Even with the best C++ practices, memory errors and concurrency issues remain a challenge. The modern tooling available in GCC and LLVM can help to catch these problems at runtime. This talk provides a deep dive into address and memory sanitizers with a practical case study of instrumenting an application.

Attendees will learn how to integrate these tools into their projects and build systems, avoid common pitfalls, and handle typical challenges encountered during their use, such as performance overhead and the scope of checks, leading to a clearer understanding of memory issues. A special emphasis will be given to working across isolation boundaries, such as cross-language calls with Rust and Python, and low-level hardware interfaces.

Sanitize for your Sanity: Sanitizers tools for Modern C++ - Evgenii Seliverstov - Meeting C++ 2025

React Conferences by GitNation

How to scale frontend architecture across hundreds of teams and achieve independent deployment? 🏗️ Solving the primary pain points of micro-frontends.

Luca Mezzalira (Principal Architect at AWS, Author of "Building Micro-Frontends") shares architectural strategies derived from working with 100+ AWS engineering teams👨‍💻

You will learn:
✔️ Optimizing for Team Independence over Code Reusability.
✔️ Using Coarse-Grained Splitting to reduce cognitive load.
✔️ Designing technology-agnostic and stable Application Shells.
✔️ Implementing Dynamic Discovery Schemas for flexible routing.
✔️ Managing Canary Releases and instant rollbacks on the Edge.
✔️ Data sharing via BFF and Event Emitters instead of Global State.

✍️ Talk: Luca Mezzalira | The Dark Side of Micro‑Frontends
🌎 This Talk was recorded at React Advanced London 2025, Website:
https://reactadvanced.com/?utm_source=youtube&utm_medium=radv-LucaMezzalira

Follow the link to watch the full version of all the conference talks, QnA’s with speakers and hands-on workshop recordings:
🔗 https://gitnation.com/events/react-advanced-conference-2025?utm_source=youtube&utm_medium=radv-LucaMezzalira

📌 Looking for more advanced technical talks and a chance to ask top speakers questions live? 
👉🏻 Join us at our upcoming events. Pick your event via the link and secure your spot at the best rate:
https://gitnation.com/events?utm_source=youtube&utm_medium=radv-LucaMezzalira

Timestamps:

00:00 - Distributed systems: Lessons from 100+ AWS teams
01:00 - The "Distributed Mess" trap in runtime composition
02:39 - Scaling beyond code: Culture and Team Topology
03:38 - The core trade-off: Reusability vs. Team Independence
05:48 - Driving Fast Flow and reducing external blockers
06:32 - Start big: Why coarse-grained splitting works better
07:27 - Granularity heuristics: When to split or aggregate
08:56 - Building stable, tech-agnostic Application Shells
10:29 - Mastering global vs. local routing boundaries
11:07 - Meta-shell patterns for independent horizontal scaling
13:57 - Why hardcoded webpack configs fail in production
15:20 - Moving to dynamic Discovery Schemas (JSON)
17:58 - Low latency: Moving discovery logic to the Edge
18:42 - Canary releases and instant rollbacks on CDN
20:05 - Encapsulation: The danger of shared global state
21:15 - Better data sharing: BFF and Event Emitters
22:39 - Automated governance via Architectural Fitness Functions
24:29 - Software growth: Moving away from the "build" mindset


#ReactAdvanced #ReactAdvancedLondon #GitNation #Nextjs #AppRouter #WebPerformance #SoftwareArchitecture #Nextjs16 #ReactJS #PartialPrerendering #PPR #WebDevelopment #Vercel #FrontendEngineering #Caching #RSC #ServerComponents #Programming

React Advanced 2025

Scaling micro frontends across hundreds of teams without tight coupling is possible. Watch this talk for concrete tips: favor team independence over shared code, use coarse-grained splitting, build tech-agnostic "shells", move discovery to the edge with CDN, ...

Scaling Micro‑Frontends Without Coupling | AWS Strategies | Luca Mezzalira

InfoQ

In this InfoQ video, Red Hat Principal Engineer Andrea Peruffo reveals how WebAssembly is moving beyond the browser to revolutionize enterprise backend systems. He introduces Chicory, a pure-Java Wasm runtime that allows you to run polyglot code (C, Rust, Go, Python) directly on the JVM without escaping the security sandbox or sacrificing observability.

Learn how to unlock high-performance plugin systems, run C-based parsers at JIT speed, and solve the "native dependency" nightmare in cloud-native environments.

⏱️ Video Timestamps (For Navigation)
0:00 - Introduction: Wasm in the Enterprise 
1:15 - Why Wasm isn't just for the Browser anymore 
3:45 - The Power of Polyglot Interfaces on the Backend 
5:10 - Introducing Chicory: Pure Java Wasm Runtime 
7:30 - Why FFI and Native Libraries are a Risk 
10:15 - Case Study 1: Accelerating JRuby with C-based Parsers 
13:40 - Performance Gains: AOT Compilation vs. Interpreters 
16:20 - Case Study 2: Running CPython in TrinoDB 
20:15 - Case Study 3: High-Performance Go Plugins in Debezium 
23:50 - SQLite on the JVM: Solving the Memory-Grow Bottleneck 
28:10 - Conclusion: When to choose Wasm for your Stack 
30:45 - Q&A: The Future of Chicory, WasmGC, and Quarkus Integration

🔗 Transcript available on InfoQ:  https://bit.ly/4aUbJLN           
  
#WebAssembly #Java #SoftwareArchitecture #Wasm #RedHat #microservices

QCon London 2025

WebAssembly for the JVM: Beyond the Browser with Chicory

This talk was recorded at NDC TechTown in Kongsberg, Norway. #ndctechtown #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndctechtown.com/

Subscribe to our YouTube channel and learn every day:   
/      @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#os 

In an always-connected world, the ability to push updates to embedded devices in the field isn't just a nice-to-have — it's critical. But implementing secure, reliable, and maintainable over-the-air (OTA) update systems is still one of the trickiest parts of embedded development.

In this talk, we’ll go beyond theory and dive into what it really takes to deliver OTA at scale. You’ll get a breakdown of architectural patterns, tooling options, and the real-world tradeoffs you’ll face when deploying firmware updates to constrained devices — often with unreliable connectivity, limited storage, and mission-critical uptime requirements.

OTA Updates in the Wild: Lessons from the Field - Jana Perić - NDC TechTown 2025

Data Science Conference

Heiko Hotz, Generative AI Global Blackbelt at Google, and Teodora Danilovic, AI Engineer at AutogenAI, shared real-world case studies showing the shift from static RAG workflows toward dynamic, multi-agent systems. Teodora introduced how her role transitioned from traditional prompt engineering to context engineering, the art of providing all necessary context for an LLM to solve a task. Heiko provided a theoretical overview of AI agents and demonstrated an agent-driven evidencing process with dynamic, multi-step reasoning and collaboration between agents. The session included a live demo showing how these concepts translate into tangible productivity gains for complex tasks like bid writing.

This talk by Heiko Hotz and Teodora Danilovic was held on November 20th at DSC Europe 2025 in Belgrade.

Follow us on social media :
LinkedIn: https://www.linkedin.com/company/data-science-conference/ 
Instagram: https://www.instagram.com/datasciconf/ 
Facebook page: https://www.facebook.com/DataSciConference 
Website: https://datasciconference.com/

DSC EUROPE 2025

From Prompt Engineering to Agentic AI | Heiko Hotz & Teodora Danilovic | DSC EUROPE 25

This talk was recorded at NDC TechTown in Kongsberg, Norway. #ndctechtown #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndctechtown.com/

Subscribe to our YouTube channel and learn every day:   
/      @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#cplusplus 

A program is nothing else than a bunch of instructions modifying chunks of memory based on some inputs to produce some outputs. When these chunks of memory are defined at runtime, we call it dynamic memory allocation. In C++ there are multiple situations where dynamic memory allocation is performed. A user can allocate dynamic memory explicitly in different ways, but dynamic memory allocation can also happen implicitly. There are multiple features of C++ that require dynamic memory allocation, but this is not always necessarily clear to the user. This might become a problem in certain fields. In safety critical systems some guidelines forbid the use of dynamic memory allocation.
In this talk we will analyse certain features of the C++ library to see if they dynamically allocate or not. We will also learn what are the challenges with dynamic memory allocation in safety critical systems and what alternatives do we have. By the end of the talk you will have gained the knowledge to dynamically allocate memory in safety critical systems in a safer way.

Dynamic memory allocation challenges in safety critical systems - Xavier Bonaventura

This talk was recorded at NDC TechTown in Kongsberg, Norway. #ndctechtown #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndctechtown.com/

Subscribe to our YouTube channel and learn every day:   
/      @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/



Parsers are everywhere, either explicitly written by you or implicitly used in a tool you use. Parsers are the things that verifies if some input is well-formed, and allows you to extract structured data from it.

If you've ever used a regex, a programming language, markup language or even a data format, there has most likely been a parser involved. Maybe even a parser generator!

In this session, we'll be exploring the process of parsing. We'll start from scratch with the basics and expand our knowledge. Armed with some fundamentals, we'll look at real-world applications like regexes and programming languages and show how the different types of parsers are suited for different tasks.

A bird's eye view of a parser - Joakim Lier - NDC TechTown 2025

Subscribe to our channel: https://youtube.pl/c/DevoxxPoland?sub_confirmation=1

We can't deliver good code on the first write. We first have to make the code work, then we have to make it better from different points of view: ease of change, better quality, reducing complexity, and so on. We all know that we have to constantly refactor the code, but what are some of the tenets we should follow for better journey through refactoring. This presentation will discuss the dos and don's when refactoring and way to become effective at it.

Recorded at Devoxx Poland 2024

Twitter: https://twitter.com/DevoxxPL
Instagram: https://www.instagram.com/DevoxxPL

Join us also here:
Devflix: https://devflix.pl

#Devoxx #DevoxxPoland #IT #Development #SoftwareDevelopment

How to Approach Refactoring • Venkat Subramaniam • Devoxx Poland 2024

Domain-Driven Design Europe

Domain-Driven Design Europe 2025 - Organised by Aardling (https://aardling.eu/)

https://dddeurope.com
https://newsletter.dddeurope.com/ 
https://be.linkedin.com/company/domain-driven-design-europe
https://bsky.app/profile/dddeu.bsky.social
https://mastodon.social/@dddeu@m.aardling.social


What actually happens when we make a decision about a software architecture? How do we map from a business context to a component structure? How do we make decisions about granularity and arrive at monoliths or microservices? Is it heuristic? Is it a repeatable pattern? How do we know if it’s right? Why do we get this wrong so often?

This session takes a step back and looks at the relationship between a business context and software structure using tools from the complexity sciences that help us to clarify our decision making and understand the forces that drive us to think in certain patterns. The session will take traditional methods like process and capability mapping and add a new layer of understanding that will help architects and developers avoid the mistakes of the past. The session will help us to think about where the levers are to make our designs more flexible and identify the places where we can copy from others and, most importantly, where we need to think for ourselves.

About Barry O'Reilly:
CEO/Founder at Black Tulip Technology
Barry is a certified Architect who has held Chief Architect positions at Microsoft among others. He has also been a startup CTO, the Worldwide Lead for the Solutions Architecture Community at Microsoft, and founder of the Swedish Azure User Group. He is also a PhD candidate in software design and complexity science.

DDD Europe 2025

Model Drift and Software Attractors - Barry O'Reilly - DDD Europe 2025

Background — As a test automation engineer at Indeed, I focus on testing job boards that share common components, such as search functionality. When I started working on one job board, I quickly recognized a significant opportunity to improve test automation across multiple teams and applications. I proposed a solution to make the test automation framework reusable and scalable across the organization. This approach has revolutionized how we approach automation, reducing test implementation time and increasing collaboration.

Problem Statement — In large organizations, In large organizations, teams often face two main challenges when scaling test automation: Lack of Collaboration and Holistic Testing: Testing is siloed, with different teams tackling similar technical challenges in isolation. Developers and other roles aren't always involved in testing, making it difficult to foster a holistic quality mindset across the organization. Duplication and Inefficiency: Multiple teams work on automating the same or similar components, such as a search bar, but often take different approaches. This leads to inefficiencies, duplicated efforts, and inconsistency in test strategies. The need for a reusable and scalable test automation framework is clear, but the question is: how can we implement it effectively and ensure it benefits all teams, applications, and environments?

Solution — We developed a centralized test automation framework designed to be scalable and reusable across teams and applications. The framework addresses common problems like duplication of efforts, inefficiencies, and inconsistency in testing strategies by providing a shared platform for test automation. Key components of the framework include: Test Runner: To handle running tests efficiently in different environments. Parallelization: Both locally and remotely, at the spec and test levels, speeding up execution. Retries: At both the test level and for failing requests, reducing flakiness. Test Reporter: Providing isolated test execution details for better reporting. Configuration Management: Allowing for easy adjustment of execution parameters. Execution Metrics Collection: Tracking key metrics like success rate, flakiness, and test duration. This framework enables teams to quickly implement tests and share solutions, reducing redundancy and ensuring high-quality, maintainable automation.

Key Takeaways — Attendees of this session will learn: How to scale test automation across different teams and applications without compromising quality. Strategies to improve test reusability, reducing duplication of effort. Methods for addressing flakiness and improving test reliability. Approaches to monitoring and maintaining a central framework, with key insights into tracking execution metrics. How to reduce test implementation time from 5 hours to 30 minutes through efficient, reusable practices.

Outline — Introduction (25%): Problem definition, emphasizing the benefits of a reusable and distributed test framework. Strategy (30%): Key considerations for building a scalable and reusable test automation framework. Framework Architecture (15%): Overview of the key components (test runner, parallelization, retries, etc.). Monitoring & Maintenance (15%): How to track execution metrics and maintain quality. Summary & Q&A (15%): Recap and open floor for audience questions.

How This Talk is Different — This talk is more than just a technical deep dive into test automation frameworks. It's a practical, experience-based report on how to scale test automation efforts in real-world scenarios. I'll provide insights on solving everyday challenges that test automation engineers face, such as maintaining consistency, avoiding duplicated effort, and ensuring reliability at scale. The focus on scaling, collaboration, and reusability makes this session stand out from other test automation talks.

Summary — In this talk, I will share my journey of scaling test automation across teams and environments at Indeed. We started with a small, siloed effort and transformed it into a central framework that drastically reduced implementation time and improved efficiency across the organization. By making the framework reusable and scalable, we not only improved collaboration but also ensured consistency in quality across different applications.

Mesut Durukal - Scaling Test Automation: Building Reusability for 10x Speed and Efficiency

Java

Dive deep into the Java Virtual Machine and discover how it masterfully balances static analysis with dynamic execution. John Rose explores what makes the JVM both powerful and efficient, from theoretical computer science to real-world optimization techniques.

AOT static overview of this talk.
1. Words: What are these words we use? What do static and dynamic mean?
2. Realities: Why reasoning about computation is hard but also required.
3. Furtive Workarounds: Java and the JVM contrive to cheat anyway, secretly.
4. Blatant Workarounds: Java and the JVM adjust the rules to allow “good cheats”

Presented by *John Rose* - JVM Senior Architect (Java Platform Group - Oracle) during the 2025 JVM Language Summit (CA, August 2025).

• Slides ➤ https://cr.openjdk.org/~jrose/pres/202508-DynamicStatic.pdf
• https://www.youtube.com/playlist?list=PLX8CzqL3ArzUOgZpIX6GsoRhPbnij-sco Playlist
• JVMLS ➤ https://jvmlanguagesummit.com/

Tags: #Java #OpenJDK #JDK

JVM Language Summit 2025

The Static Dynamic JVM – A Many Layered Dive #JVMLS

Every project / app starts small and grows and grows until it becomes a hot mess of spaggetti Carbonara. You try to follow all the best practices and advice and in the end the result is the same. In this talk I will go though my case study on how I managed to scale my application to millions of users and keep the code tidy and clean. Starting a startup is one thing - scaling it is another beast entirely. 

In this practical, experience-driven talk, I'll take you through our two-year journey of building and scaling a JavaScript application from ground zero. Rather than theoretical concepts, you'll hear real stories about the technical challenges we faced and the solutions we implemented. We will discuss how to handle: - building a component library - building a scalable release process - internationalisation of the app - performance issues at scale - and some funny bugs

Dan Neciu - How not to end up your app to a hot mess of spaghetti Carbonara

These videos are from the XO Ruby conference series, lovingly captured on-site by the XO Ruby organizers themselves using Confreaks borrowed gear and their best efforts. As a friend of the community, Confreaks is handling all editing and post-production so these talks could be preserved and shared with everyone. The footage and audio reflect the grassroots, volunteer-run nature of the event — real humans doing their absolute best under conference conditions. We’re proud to help bring these talks to you and hope you enjoy the content! 

We use the term "architecture" in computer programming quite a bit. But is it a valid and useful analogy (or borrowing of the term)? What could we learn by taking another look at the architecture of buildings? We'll take a look at the history of patterns in building architecture, and how our industry adopted a similar way of thinking. What have we missed? Why do we only consider large architectural issues, and ignore smaller issues that still might be considered architectural?

Video Production by Confreaks
Follow Confreaks 👇
https://confreaks.com
https://x.com/confreaks
https://confreaks.bsky.social

New talks

AI Engineer 2025 (6)

API Conference Berlin 2025 (3)

AWS re:Invent 2025 (6)

CascadiaJS 2025 (2)

CityJS Athens 2025 (6)

CityJS London 2025 (4)

Clojure/Conj 2025 (6)

Code BEAM Europe 2025 (1)

CppCon 2025 (6)

DDD Europe 2025 (1)

DSC EUROPE 2025 (2)

Devoxx Poland 2024 (4)

ElixirConf EU 2025 (2)

EuroRust 2025 (4)

GOTO Copenhagen 2025 (1)

GeeCON 2024 (2)

GeeCON 2025 (2)

GopherCon 2024 (1)

GopherCon 2025 (1)

JVM Language Summit 2025 (1)

LeadDev Berlin 2025 (2)

LeadDev New York 2025 (3)

MQ Summit 2025 (1)

Meeting C++ 2025 (4)

NDC Copenhagen 2025 (6)

NDC TechTown 2025 (16)

PyData Global 2025 (83)

PyData Prague #32, 2025 (2)

QCon London 2025 (1)

React Advanced 2025 (2)

React Conf 2025 (24)

Rust Global 2025 (5)

Spacewalk 2026 (1)

StaffPlus New York 2025 (3)

Swift Craft 2025 (1)

TechLead London Conference 2025 (1)

XO Ruby 2025 (12)

ng-conf 2025 (2)