Microsoft sponsored. Best way to build vertical agents. Server and Tool kit for Model Context Protocol server written in python. Run multiple tools on a single server.

As programmers, we spend a lot of time typing, but we often overlook how keyboard designs affect our comfort and productivity. In this talk, we'll explore custom keyboards and how Python can help us create our own typing experiences. 

We'll start by looking at the history of keyboard design and the limits of standard layouts like QWERTY. Then, we’ll discuss the advantages of alternative layouts, such as ortholinear and split designs, which can help reduce strain and improve typing speed. 

Next, we’ll go through how to design a custom keyboard PCB and learn from Python tools like GDSFactory. You’ll learn to arrange the keys based on your hand shape and create a layout that focuses on the keys you use most in your favorite programming languages. 

Once we have our PCB design, we’ll move on to building our custom keyboard. We’ll cover basic assembly to turn our design into a real device. Finally, we’ll talk about getting used to our new keyboard layout. We’ll look at online tools and Python scripts to analyze our typing habits, helping us identify our most common keys and monitor our progress as we retrain our fingers. 

No prior experience with keyboard building or PCB design is needed – just bring your curiosity and eagerness to create a custom typing experience. By the end of this talk, you’ll know to question the design of your current keyboard and might want to build and improve your own custom keyboard using Python.

Outline

• Setting up a test harness. How to use parameterized tests to refactor safely.

• Simplifying conditionals 

• Guard clauses and early returns

• Method extraction vs inlining. Tradeoffs (“Clean Coder Uncle Bob” vs “Philosophy of Software Design Ousterhout).

• Pattern matching with Python 3.10+ `match-case`

• Boolean logic tricks (from discrete math)

• DeMorgan’s Law

• Double negation

• Distributive laws

• Understanding Python boolean semantics

• Short-circuit evaluation

• `and` / `or` behavior return-value behavior

• Tripwires: when truthy expressions return unexpected values

• Decoupling Behavior from Branching

• Intro example

• Strategy pattern in functional style. Dispatching callables with dicts.

• functools.singledispatch for type-based dispatch

• Strategy pattern in OOP style

• With duck typing

• With inheritance-based polymorphism

• With protocol-based structural typing

• If IF ain’t broke, then don’t fix it. 

• Evaluating design tradeoffs. 

• When the overhead of encapsulation or indirection might not be worth it.

• Recap: when to use what

• Summary of techniques, tradeoffs, and when each is favorable

Every word from the Federal Reserve moves markets, but their statements are often cryptic. In this talk, I’ll aim to break down my work for a class I took in college on using machine learning and natural language processing (NLP) to analyze Federal Open Market Committee (FOMC) statements and minutes to “predict” interest rate changes. By applying sentiment analysis, text processing, and neural network modeling, I tried to explore whether AI can help us potentially decode central bank language and anticipate monetary policy shifts. I will share some key findings and challenges.

I'm one of the authors of Beyond Cracking the Coding Interview (the official sequel to CTCI) and the founder of interviewing.io.

I've been around eng hiring for almost 20 years, as a candidate, and eng leader, a recruiter (both in-house and agency), and finally as the founder of a mock interview and recruiting platform.

I keep seeing engineers make the same, very avoidable mistakes. In this talk, I'll walk you through them. Note that there are no shortcuts to getting good at technical interviews. There, you have to practice. But, there are a bunch of job search things that you can get good at after a short talk, and those are the ones I'll focus on.

According to the StackOverflow annual survey, Python and Java are ranked in the top ten programming languages in terms of popularity.  This talk will contrast these languages, with the goal of helping those coming from Java understand the key features of Python.

Development (and execution) environments for Ansible can be tricky. I’ll go over how utilizing the devcontainer spec can make it easy to develop Ansible plugins, run Ansible, and share environments with a team so that everyone has the same experience. This concept also extends to python environments in general and can help with complex setups that might include databases, web front ends, and so on.   

In this talk, I’ll take you on a journey through the creation of xsNumPy, a minimalist implementation of core NumPy features using Python’s standard library. I’ll begin by sharing the inspiration behind the project — my curiosity to unravel the mechanics of NumPy and deepen my understanding of numerical computing. Then, we’ll explore the step-by-step development process, including designing a basic array object, implementing element-wise operations, and tackling challenges like scalability and performance optimization without external libraries. Along the way, I’ll highlight the Pythonic principles and best practices that guided the project, compare xsNumPy’s functionality with NumPy, and reflect on the lessons learned. Finally, I’ll discuss how xsNumPy can serve as a learning tool for developers and educators, and invite the community to join this open-source experiment in computational discovery.

I have a lamp—I love my lamp. I’ve placed it in the perfect spot, but the on/off switch is so remote that I have to crawl over my couch just to reach it. Wouldn't it be nice if I could simply gesture to my lamp and turn it on? That's exactly what I set out to do. Before long, I was elbow-deep in experiments with MediaPipe for hand tracking, Python for prototyping, NumPy for data crunching, and GPIO for bridging the digital and physical worlds. Little by little, that wild idea took shape, transforming into a live system that lets you wave goodbye to remotes forever.

Join me at ChiPy, where I’ll share how this gesture-recognition project grew from a late-night epiphany into a fully functional smart home solution. We’ll explore how combining computer vision and IoT opens up new ways to interact with our environment—no more clunky remotes or app-hopping. Get ready for a glimpse into the future of home automation, driven by intuitive gestures and powered by Python.

Quick script to pull data from an API and perform some basic cleaning/transformation/filtering using Pandas.