Add more social medias to speaker profiles, and update content

src/content/.gitattributes

@@ -0,0 +1 @@
+*.mdx text eol=lf

src/content/config.ts

@@ -63,8 +63,10 @@ const speakers = defineCollection({
     submissions: z.array(reference("sessions")),
     affiliation: z.string().nullable(),
     homepage: z.string().nullable(),
-    twitter: z.string().nullable(),
-    mastodon: z.string().nullable(),
+    gitx: z.string().nullable(),
+    linkedin_url: z.string().url().nullable(),
+    mastodon_url: z.string().url().nullable(),
+    twitter_url: z.string().url().nullable(),
   }),
 });
 
@@ -75,7 +77,7 @@ const sessions = defineCollection({
     title: z.string(),
     speakers: z.array(reference("speakers")),
     submission_type: z.string(),
-    track: z.string(),
+    track: z.string().nullable(),
     state: z.enum(["confirmed"]),
     tweet: z.string(),
     duration: z.string(),
@@ -84,11 +86,12 @@ const sessions = defineCollection({
     room: z.string().nullable(),
     start: z.string().nullable(),
     end: z.string().nullable(),
+    website_url: z.string().url(),
     talks_in_parallel: z.string().nullable(),
     talks_after: z.string().nullable(),
-    next_talk_code: z.string().nullable(),
-    prev_talk_code: z.string().nullable(),
-    website_url: z.string().url(),
+    talks_before: z.string().nullable(),
+    next_talk: z.string().nullable(),
+    prev_talk: z.string().nullable(),
   }),
 });
 

src/content/sessions/3XXR79.mdx

@@ -4,8 +4,9 @@ delivery: in-person
 duration: '45'
 end: null
 level: beginner
-next_talk_code: null
-prev_talk_code: null
+next_talk: null
+prev_talk: null
+resources: null
 room: null
 slug: learning-to-code-in-the-age-of-ai
 speakers:
@@ -14,6 +15,7 @@ start: null
 state: confirmed
 submission_type: Talk (long session)
 talks_after: null
+talks_before: null
 talks_in_parallel: null
 title: Learning to code in the age of AI
 track: Software Engineering & Architecture

src/content/sessions/7CJVKM.mdx

@@ -4,8 +4,9 @@ delivery: in-person
 duration: '30'
 end: null
 level: intermediate
-next_talk_code: null
-prev_talk_code: null
+next_talk: null
+prev_talk: null
+resources: null
 room: null
 slug: streamlining-testing-in-a-large-python-codebase
 speakers:
@@ -14,21 +15,22 @@ start: null
 state: confirmed
 submission_type: Talk
 talks_after: null
+talks_before: null
 talks_in_parallel: null
 title: Streamlining Testing in a Large Python Codebase
 track: DevOps and Infrastructure (Cloud & Hardware)
 tweet: ''
 website_url: https://ep2024.europython.eu/session/streamlining-testing-in-a-large-python-codebase
 ---
 
-Maintaining code quality through effective testing becomes increasingly challenging as codebases expand and developer teams grow. In our rapidly expanding codebase, we encountered common obstacles such as increasing test suite execution time, slow test coverage reporting and delayed test startup. By leveraging innovative strategies using open-source tools, we achieved remarkable enhancements in testing efficiency and code quality.
-Challenges Faced:
-- Test Suite Execution Time: The duration of test suite execution escalated significantly as we added more tests over time, hampering development speed.
-- Slow Test Startup: Complex test setup led to prolonged test startup times, impeding developer productivity.
-- Test Coverage Reporting Overhead: Coverage tools introduced substantial overhead and impacted test performance.
-
-Solutions Implemented:
-- Parallel Test Execution: We applied pytest-xdist to distribute tests across multiple runners, significantly reducing test suite execution time and enabling faster development iterations.
-- Optimized Test Startup: Pre-installing dependencies in a Docker image and utilizing Kubernetes for auto-scaling continuous integration runners helped expedite test startup times, improving developer efficiency. For local development, we used pytest-hot-reloading to reload tests fast after code editing.
-- Efficient Test Coverage Reporting: Customizing the coverage tool to collect data only on updated files of pull requests minimized overhead on test coverage reporting.
+Maintaining code quality through effective testing becomes increasingly challenging as codebases expand and developer teams grow. In our rapidly expanding codebase, we encountered common obstacles such as increasing test suite execution time, slow test coverage reporting and delayed test startup. By leveraging innovative strategies using open-source tools, we achieved remarkable enhancements in testing efficiency and code quality.
+Challenges Faced:
+- Test Suite Execution Time: The duration of test suite execution escalated significantly as we added more tests over time, hampering development speed.
+- Slow Test Startup: Complex test setup led to prolonged test startup times, impeding developer productivity.
+- Test Coverage Reporting Overhead: Coverage tools introduced substantial overhead and impacted test performance.
+
+Solutions Implemented:
+- Parallel Test Execution: We applied pytest-xdist to distribute tests across multiple runners, significantly reducing test suite execution time and enabling faster development iterations.
+- Optimized Test Startup: Pre-installing dependencies in a Docker image and utilizing Kubernetes for auto-scaling continuous integration runners helped expedite test startup times, improving developer efficiency. For local development, we used pytest-hot-reloading to reload tests fast after code editing.
+- Efficient Test Coverage Reporting: Customizing the coverage tool to collect data only on updated files of pull requests minimized overhead on test coverage reporting.
 As a result, in the past year, our test case volume increased by 8000, test coverage was elevated to 85%, and Continuous Integration (CI) test duration was maintained under 15 minute

src/content/sessions/7DF7VC.mdx

@@ -4,8 +4,9 @@ delivery: in-person
 duration: '45'
 end: null
 level: advanced
-next_talk_code: null
-prev_talk_code: null
+next_talk: null
+prev_talk: null
+resources: null
 room: null
 slug: deconstructing-the-text-embedding-models
 speakers:
@@ -14,6 +15,7 @@ start: null
 state: confirmed
 submission_type: Talk (long session)
 talks_after: null
+talks_before: null
 talks_in_parallel: null
 title: Deconstructing the text embedding models
 track: 'PyData: Deep Learning, NLP, CV'
@@ -23,6 +25,6 @@ tweet: Tokenizers are the most underrated parts of not only LLMs but also text e
 website_url: https://ep2024.europython.eu/session/deconstructing-the-text-embedding-models
 ---
 
-Selecting the optimal text embedding model is often guided by benchmarks such as the Massive Text Embedding Benchmark (MTEB). While choosing the best model from the leaderboard is a common practice, it may not always align perfectly with the unique characteristics of your specific dataset. This approach overlooks a crucial yet frequently underestimated element - the tokenizer.
-
+Selecting the optimal text embedding model is often guided by benchmarks such as the Massive Text Embedding Benchmark (MTEB). While choosing the best model from the leaderboard is a common practice, it may not always align perfectly with the unique characteristics of your specific dataset. This approach overlooks a crucial yet frequently underestimated element - the tokenizer.
+
 We will delve deep into the tokenizer's fundamental role, shedding light on its operations and introducing straightforward techniques to assess whether a particular model is suited to your data based solely on its tokenizer. We will explore the significance of the tokenizer in the fine-tuning process of embedding models and discuss strategic approaches to optimize its effectiveness.

src/content/sessions/7F87N3.mdx

@@ -4,8 +4,9 @@ delivery: in-person
 duration: '30'
 end: null
 level: intermediate
-next_talk_code: null
-prev_talk_code: null
+next_talk: null
+prev_talk: null
+resources: null
 room: null
 slug: mastering-design-patterns-crafting-elegant-solutions-with-a-confidence
 speakers:
@@ -14,15 +15,16 @@ start: null
 state: confirmed
 submission_type: Talk
 talks_after: null
+talks_before: null
 talks_in_parallel: null
 title: 'Mastering Design Patterns: Crafting Elegant Solutions with a Confidence'
 track: Software Engineering & Architecture
 tweet: ''
 website_url: https://ep2024.europython.eu/session/mastering-design-patterns-crafting-elegant-solutions-with-a-confidence
 ---
 
-Join us for an illuminating 30-minute journey into the world of design patterns at EuroPython 2024. Design patterns aren't just abstract concepts; they are the architectural blueprints that empower developers to create elegant and maintainable software solutions. In this session, we bridge the gap between theory and practice, offering practical insights for developers of all levels.
-
-We'll delve into a curated selection of design patterns, from foundational creational patterns to advanced behavioral patterns, showcasing their real-world applications and transformative impact on Python development. Through a blend of theory and practice, attendees will gain a comprehensive understanding of how to identify common design problems and apply appropriate patterns to solve them efficiently.
-
+Join us for an illuminating 30-minute journey into the world of design patterns at EuroPython 2024. Design patterns aren't just abstract concepts; they are the architectural blueprints that empower developers to create elegant and maintainable software solutions. In this session, we bridge the gap between theory and practice, offering practical insights for developers of all levels.
+
+We'll delve into a curated selection of design patterns, from foundational creational patterns to advanced behavioral patterns, showcasing their real-world applications and transformative impact on Python development. Through a blend of theory and practice, attendees will gain a comprehensive understanding of how to identify common design problems and apply appropriate patterns to solve them efficiently.
+
 Using engaging examples and hands-on exercises, we'll equip attendees with the knowledge and skills needed to architect cleaner, more maintainable codebases. Whether you're a seasoned veteran or a curious novice, this presentation offers a comprehensive roadmap for mastering Python design patterns and architecting software solutions with grace.

src/content/sessions/7GRP3T.mdx

@@ -4,8 +4,9 @@ delivery: in-person
 duration: '30'
 end: null
 level: intermediate
-next_talk_code: null
-prev_talk_code: null
+next_talk: null
+prev_talk: null
+resources: null
 room: null
 slug: the-art-of-the-pull-request
 speakers:
@@ -14,13 +15,14 @@ start: null
 state: confirmed
 submission_type: Talk
 talks_after: null
+talks_before: null
 talks_in_parallel: null
 title: The Art of the Pull Request
 track: Software Engineering & Architecture
 tweet: ''
 website_url: https://ep2024.europython.eu/session/the-art-of-the-pull-request
 ---
 
-*Want to be a better teammate? Want to get your work merged faster?*
-
+*Want to be a better teammate? Want to get your work merged faster?*
+
 For a lot of devs (especially newer ones) the important part of a PR is the code, not the structure of the PR. However, the way commits in a PR are put together to guide a reviewer can be massively impactful. This talk looks at how to effectively craft that review experience.

src/content/sessions/7PEXTK.mdx

@@ -4,8 +4,9 @@ delivery: in-person
 duration: '45'
 end: null
 level: intermediate
-next_talk_code: null
-prev_talk_code: null
+next_talk: null
+prev_talk: null
+resources: null
 room: null
 slug: rapid-prototyping-proof-of-concepts-django-is-all-we-need
 speakers:
@@ -14,6 +15,7 @@ start: null
 state: confirmed
 submission_type: Talk (long session)
 talks_after: null
+talks_before: null
 talks_in_parallel: null
 title: 'Rapid Prototyping & Proof of Concepts: Django is all we need'
 track: Python Libraries & Tooling
@@ -23,34 +25,34 @@ tweet: We know Django is great for building mature & long-lasting applications.
 website_url: https://ep2024.europython.eu/session/rapid-prototyping-proof-of-concepts-django-is-all-we-need
 ---
 
-In this modern day and age, 2 things are for certain:
-
-1. Time-to-market for our products & features matters.
-2. We can easily drown in complexity and be carried away by over-engineering.
-
-Having the ability to rapidly develop prototypes and proof of concepts is very powerful, because we can iterate towards the right thing, with code.
-
-We know that we can use Django for building mature & long-lasting applications.
-
-But what about building rapid prototypes and proof of concepts?
-
-In this talk, we’ll show that Django can do that job, reliably, as well.
-
-We’ll look at what Django & the rich 3rd party ecosystem has to offer us, when it comes to building rapid prototypes.
-
-We’ll focus on topics like:
-
-1. How to approach rapid prototyping with the correct mindset.
-2. Being quick with Django models.
-3. Realizing that types can be our friends.
-4. Realizing that Django admin may be all the UI we need (at least, in the beginning).
-5. Using HTMX where it makes sense.
-6. Components in Django templates are a good idea.
-
-The talk will be practical & pragmatic, with the aim to provide good examples, derived from experience, that’ll highlight the main topics and ideas.
-
-The talk is great for both beginners, as well as seasoned Django developers.
-
-The final goal is to give clear evidence, supported by examples, that we can use Django, reliably, to rapidly build prototypes & proof of concepts.
-
+In this modern day and age, 2 things are for certain:
+
+1. Time-to-market for our products & features matters.
+2. We can easily drown in complexity and be carried away by over-engineering.
+
+Having the ability to rapidly develop prototypes and proof of concepts is very powerful, because we can iterate towards the right thing, with code.
+
+We know that we can use Django for building mature & long-lasting applications.
+
+But what about building rapid prototypes and proof of concepts?
+
+In this talk, we’ll show that Django can do that job, reliably, as well.
+
+We’ll look at what Django & the rich 3rd party ecosystem has to offer us, when it comes to building rapid prototypes.
+
+We’ll focus on topics like:
+
+1. How to approach rapid prototyping with the correct mindset.
+2. Being quick with Django models.
+3. Realizing that types can be our friends.
+4. Realizing that Django admin may be all the UI we need (at least, in the beginning).
+5. Using HTMX where it makes sense.
+6. Components in Django templates are a good idea.
+
+The talk will be practical & pragmatic, with the aim to provide good examples, derived from experience, that’ll highlight the main topics and ideas.
+
+The talk is great for both beginners, as well as seasoned Django developers.
+
+The final goal is to give clear evidence, supported by examples, that we can use Django, reliably, to rapidly build prototypes & proof of concepts.
+
 It turns out that Django is all we need.

src/content/sessions/7XMZGV.mdx

@@ -4,8 +4,9 @@ delivery: in-person
 duration: '30'
 end: null
 level: intermediate
-next_talk_code: null
-prev_talk_code: null
+next_talk: null
+prev_talk: null
+resources: null
 room: null
 slug: demystifying-asyncio-building-your-own-event-loop-in-python
 speakers:
@@ -14,6 +15,7 @@ start: null
 state: confirmed
 submission_type: Talk
 talks_after: null
+talks_before: null
 talks_in_parallel: null
 title: 'Demystifying AsyncIO: Building Your Own Event Loop in Python'
 track: Python Internals & Ecosystem
@@ -23,19 +25,19 @@ tweet: Explore AsyncIO's core by building a custom event loop in Python to power
 website_url: https://ep2024.europython.eu/session/demystifying-asyncio-building-your-own-event-loop-in-python
 ---
 
-**AsyncIO** has emerged as a vital tool in Python's ecosystem, particularly in web development, IO-bound tasks, and network programming. However, its internal mechanics often remain obscure, even to seasoned Python developers. This talk aims to demystify AsyncIO by guiding you through creating your own event loop in Python, culminating in running a FastAPI application with it.
-
-In this talk, we’ll build an event loop from scratch in Python, capable of running an HTTP server through a FastAPI application.
-
-**Plan:**
-
-- **Introduction to AsyncIO**
-- **Core Concepts:** Deep dive into Event loop, Futures, Tasks, and coroutines
-- **Hands-On Building:** Constructing an event loop from scratch
-    - Scheduling callbacks
-    - Executing tasks and coroutines
-    - Handling network calls
-- **Practical Application:** Running a FastAPI HTTP server with our loop
-- **Performance Insights:** Comparing our event loop with the fastest ones
-
+**AsyncIO** has emerged as a vital tool in Python's ecosystem, particularly in web development, IO-bound tasks, and network programming. However, its internal mechanics often remain obscure, even to seasoned Python developers. This talk aims to demystify AsyncIO by guiding you through creating your own event loop in Python, culminating in running a FastAPI application with it.
+
+In this talk, we’ll build an event loop from scratch in Python, capable of running an HTTP server through a FastAPI application.
+
+**Plan:**
+
+- **Introduction to AsyncIO**
+- **Core Concepts:** Deep dive into Event loop, Futures, Tasks, and coroutines
+- **Hands-On Building:** Constructing an event loop from scratch
+    - Scheduling callbacks
+    - Executing tasks and coroutines
+    - Handling network calls
+- **Practical Application:** Running a FastAPI HTTP server with our loop
+- **Performance Insights:** Comparing our event loop with the fastest ones
+
 By the end of this talk, you'll be able to understand the internal workings of AsyncIO and create a basic event loop capable of running a FastAPI application.

src/content/sessions/7Z8LFA.mdx

@@ -4,8 +4,9 @@ delivery: in-person
 duration: '30'
 end: null
 level: intermediate
-next_talk_code: null
-prev_talk_code: null
+next_talk: null
+prev_talk: null
+resources: null
 room: null
 slug: writing-python-like-it-s-rust-more-robust-code-with-type-hints
 speakers:
@@ -14,6 +15,7 @@ start: null
 state: confirmed
 submission_type: Talk
 talks_after: null
+talks_before: null
 talks_in_parallel: null
 title: Writing Python like it's Rust - more robust code with type hints
 track: Software Engineering & Architecture
@@ -22,8 +24,8 @@ tweet: 'The many benefits of type hints in Python: leveraging types to gain more
 website_url: https://ep2024.europython.eu/session/writing-python-like-it-s-rust-more-robust-code-with-type-hints
 ---
 
-Using type hints in Python has many advantages, some of which might not be obvious at first. We will see that it allows us to explicitly encode invariants in our code, which reduces the amount of tests that we need to write, it improves development speed and maintainability, and perhaps most importantly, it can give us more confidence that our code does what we expect it to do.
-
-We will also go through code examples that will show us how to leverage typing in Python to design APIs that cannot be easily misused, to create robust programs that we can trust.
-
+Using type hints in Python has many advantages, some of which might not be obvious at first. We will see that it allows us to explicitly encode invariants in our code, which reduces the amount of tests that we need to write, it improves development speed and maintainability, and perhaps most importantly, it can give us more confidence that our code does what we expect it to do.
+
+We will also go through code examples that will show us how to leverage typing in Python to design APIs that cannot be easily misused, to create robust programs that we can trust.
+
 Audience members are expected to be able to read and understand Python code.

src/content/sessions/833AAG.mdx

@@ -4,8 +4,9 @@ delivery: remote
 duration: '30'
 end: null
 level: beginner
-next_talk_code: null
-prev_talk_code: null
+next_talk: null
+prev_talk: null
+resources: null
 room: null
 slug: you-are-sharing-your-code-wrong-and-what-to-do-about-it
 speakers:
@@ -14,6 +15,7 @@ start: null
 state: confirmed
 submission_type: Talk
 talks_after: null
+talks_before: null
 talks_in_parallel: null
 title: You are sharing your code wrong (and what to do about it)
 track: Python Internals & Ecosystem