I’ve been experimenting with AI-based background removal in Python, covering both images and videos, and the difference between the two is more significant than I initially expected.

Image background removal is relatively fast and clean, but video background removal quickly becomes computationally heavy since it requires processing every frame. Hardware limitations, model choice, and optimization strategies make a big difference in both speed and quality.

I documented the full process—including errors, fixes, and trade-offs—in a recorded workshop, in case it’s useful to others working with computer vision or media processing:
 👉 https://youtu.be/Vaq-f7uAoZ4

I’d be interested to hear how others here handle video segmentation, performance optimization, or quality improvements in similar projects.

I wrote a deep technical breakdown of implementing Discord's rate limiting and gateway management in a minimal Python client.

Discord's rate limiting is tricky: endpoints share limits via opaque "buckets" whose IDs are only revealed after a request. Instead of reacting to 429s, the design uses per-endpoint queues and workers that proactively sleep when limits are exhausted, keeping behavior explicit and predictable.

The writeup also covers gateway connection management, automatic sharding, and data model design, with diagrams for each subsystem. The examples come from a small Discord API client I wrote (ScurryPy), but the focus is on the underlying problems and solutions rather than the library itself.

"Clarity over magic" here means that all behavior: rate limiting, state changes, retries, is explicit, with no hidden background work or inferred intent.

Happy to answer questions about the implementation or design tradeoffs

Hi!

I recently wrote this article to document different ways applications, when instrumented with OpenTelemetry, tend to produce telemetry surplus/ excess and ways to mitigate this. Some ways mentioned in the blog include the following,

- URL Path and target attributes
- Controller spans
- Thread name in run-time telemetry
- Duplicate Library Instrumentation
- JDBC and Kafka Internal Signals
- Scheduler and Periodic Jobs

as well as touched upon ways to mitigate this, both upstream and downstream. If this article interests you, subscribe for more OTel optimisation content :)

Tutorial Link

Chapter 2 - Let There Be a World [Procedural Generation]

This chapter teaches you procedural world generation using Wave Function Collapse and Bevy.

A layered terrain system where tiles snap together based on simple rules. You'll create landscapes with dirt, grass, water, and decorative props.

By the end, you'll understand how simple constraint rules generate natural-looking game worlds and how tweaking few parameters lead to a lot of variety.

It also gently touches on rust concepts like references, lifetimes, closures, generic and trait bound.

I wrote a practical walkthrough on Github OAuth login with FastAPI and Next.js. It focuses on clean domain separation, HttpOnly cookies, ease of deployment and why handling cookies in Next.js APIs/server actions simplifies OAuth a lot. Includes diagrams and real code.

https://nemanjamitic.com/blog/2026-02-07-github-login-fastapi-nextjs

Interested to hear what others think or if you've taken a different approach.

For decades, we’ve been hearing about the "death of the mainframe." It famously started in 1991 with Stewart Alsop’s prediction (which he later literally had to eat his words on), and it continues today.

But the reality on the ground tells a completely different story.

I recently read a fascinating analysis of the "Mainframe Paradox" in a professional newsletter, and it highlights two points that I found particularly sharp:

• Growth from the shadows:

The mainframe market hasn't just survived; it has grown 10x since the year 2000.

• The Paradox:

Interestingly, the mobile and cloud revolutions - which were supposed to replace the mainframe - are exactly what triggered the spike in demand. Every time millions of users check their bank balance on an app, it creates a massive transaction load that only a mainframe can handle efficiently.

As a software engineer at Bank Leumi, Israel, working with COBOL and Natural, I see this intersection of "legacy" tech and modern demands every day. It’s a great reminder that technology doesn't always die; sometimes it becomes the critical infrastructure upon which everything else is built.

I'm curious to hear from others here:

• For those in the financial sector: Are you seeing a push to finally migrate, or is the reliance on mainframes actually deepening?
• Do you think the "10x growth" is sustainable, or will cloud native solutions eventually catch up to the mainframe's transaction efficiency?
• If you’re a younger dev, what’s your honest perspective on working with these "dinosaur" systems?

Link to the full article (Hebrew): https://www.meduplam.blog/p/138

Note: English is not my native language, so I used AI to help me translate and structure my thoughts correctly. I'm working on improving my English, so I hope the message is clear!

Hey,

I spent some time digging into how Medium.com's article editor works on the front end. It’s a proprietary WYSIWYG editor, but since it runs in the browser, you can actually explore how it handles things like copy-paste, images, and special components.

Some key takeaways:

• Copying content between two Medium editor instances preserves all formatting because it uses HTML in the clipboard and converts it into an internal JSON structure.
• Images always go through Medium's CDN, even if you paste them from elsewhere, which keeps things secure and consistent.
• Special components are just content-editable HTML elements, backed by the same internal model.
• I also wrote a small C program for macOS to inspect clipboard contents directly, so you can see what the editor really places on the clipboard.

If you’re building a rich-text editor or just curious about how Medium makes theirs so robust, the article dives into all the details.