Skyvern's open source project now uses uv, a faster Python package manager.

Build Your Own Forum with FastAPI: Step 1 - A Minimal Forum There are already many forum products on the market, but are you still frustrated because none of them meet your unique needs? If so, why not build a forum from scratch yourself? Don't be intimidated by giant forum SaaS platforms like Discourse; building a forum isn't as difficult as it seems. In the upcoming series of articles, we will guide you step-by-step from scratch to build a fully functional, modern forum website using the popular Python web framework, FastAPI. This tutorial series is tailored for beginners. By the end of this first article, you will have a runnable mini-forum, just like the one shown below: Without further ado, let's get started: First, let's prepare the development environment. Create a dedicated folder for the project and create a virtual environment within it. For simplicity, we'll use Python's built-in venv module. There are many other great virtual environment tools, such as poetry, which you can explore on your own. # Create and enter the project directo https://lnkd.in/ghF3Eq2N

I found a better way to create Claude Skills. Claude recently launched “Skills”, which you can generate directly inside Claude Web, great for simple setups. But I wanted more control and speed. So I switched to Cursor and honestly, it’s way better. Here’s how I do it: 1. Paste Anthropic’s docs and ask it to scaffold a create-skills project 2. It generates skill. md with YAML metadata & detailed instructions 3. Adds Python validators, templates, and linked resources automatically 4. I iterate fast, tweak prompts, rerun validation, and refine structure 5. Finally, zip and upload the finished skill to Claude Capabilities No more waiting for the web interface to catch up, Cursor turns it into a smooth, local workflow. Here’s a short demo showing how I build and deploy Claude Skills entirely inside Cursor 👇

While building my FastAPI project, I came across Python’s leading underscores: _, __, and even __dunder__ methods. I knew they existed, but I never really understood what they meant or why they matter until now. It’s one of those small Python details that can make your code cleaner and easier to maintain once you actually get it. I dropped a short note on my GitHub for anyone who wants a quick reference 👇 https://lnkd.in/d84Nb7GR

🚀 LeetCode 2598 – Smallest Missing Non-negative Integer After Operations Today’s problem was an interesting blend of math + logic + modular thinking 🔢 🧩 Problem Summary: - You’re given an array nums and an integer value. - In one operation, you can add or subtract value from any element any number of times. - After doing this for all elements, find the maximum MEX (minimum excluded non-negative integer). ⚙️ Approach Summary: 1️⃣ Compute remainder frequencies → Counter(n % value) 2️⃣ Iterate mex = 0, 1, 2... 3️⃣ If freq[mex % value] > 0, decrement it and continue 4️⃣ Else, return mex 🧠 Example: nums = [1, -10, 7, 13, 6, 8], value = 5 Remainders → [1, 0, 2, 3, 1, 3] We can form 0, 1, 2, 3, but not 4 → MEX = 4 📊 Complexity: Time: O(n) Space: O(value) 💬 It’s always fun to see how simple modular patterns can turn a tricky problem into something elegant. #LeetCode #ProblemSolving #Python #DSA #Coding #LearningEveryday #100DaysOfCode

When building an agentic RAG app, one question is: Framework (e.g. LangChain) vs. rolling your own (Python + Pydantic)? For my project Knowledge Navigator, the flow is pretty simple: take docs → embed → query → send to LLM In theory, I didn’t need a heavy framework. But I still chose LangChain - for these reasons: Pros of LangChain ⚡ Rapid prototyping: a RAG pipeline in ~20 lines. Momentum mattered for an MVP. 🔌 Integrations: retrievers, vector stores, tool calling already wired up. 📚 Huge community: examples + tutorials everywhere. Cons I ran into 🧳 Heavy dependency footprint (15+ imports was common). 🎛️ Opinionated abstractions: may feel restrictive. 🐛 Debugging: extra layers can make it harder to see what’s breaking. Some engineers skip frameworks entirely and use Python + Pydantic, which avoids: 1. Unnecessary abstraction / complexity. 2. Framework instability - libs can change every few months. For me, LangChain was the right tradeoff to ship faster. But long-term? I can see myself swapping parts out for full control over APIs and workflows. 👉 Curious: if you’ve built RAG or agentic AI apps, did you go framework or bare-bones Python? How did it play out?

Day 8: When One Function Wears Many Masks — Understanding Polymorphism in C++ 🎭 Ever noticed how the same word can mean totally different things depending on the situation? Take the word “play.” 🎮 For kids — it’s a game. 🎵 For musicians — it’s a song. 🎭 For actors — it’s a performance. That’s Polymorphism — one name, many forms. In C++, it allows functions or methods to behave differently based on the context. ✨ Compile-time Polymorphism (Static Polymorphism) This happens when the compiler decides which version of a function to run — before the program starts. The most common way is through Function Overloading, which means — Having multiple functions with the same name but different parameter types or counts. class Calculator { public: int add(int a, int b) { return a + b; } // adds integers double add(double a, double b) { return a + b; } // adds doubles }; When you call add(2, 3) or add(2.5, 3.5), the compiler automatically picks the right version — same name, different behavior. It’s like having one “toolbox” but different tools that fit the job perfectly. 🐾 Run-time Polymorphism (Dynamic Polymorphism) This happens when the exact function to execute is decided while the program is running. It usually happens through Function Overriding, which means — A derived class redefines a function already defined in its base class. class Animal { public: virtual void sound() { cout << "Some generic sound"; } }; class Dog : public Animal { public: void sound() override { cout << "Bark!"; } }; int main() { Animal* pet = new Dog(); pet->sound(); // Output: Bark! } Here, even though pet is an Animal pointer, it calls the Dog version of sound(). It’s like an actor taking the same script but performing it in their own unique style. 💡Polymorphism makes your code flexible, reusable, and easy to extend. #Day8 #CPP #OOP #Polymorphism #100DaysOfCode #ProgrammingJourney #CodeBetter #LearningInPublic #Internship #apprenticeship

The v0.13.0 release is now live 🥳 🙌 We bring an exciting new feature and several smaller improvements. This release introduces a new method implementation, PrototypeRepresentationLearner, which is based on the work of Zemel et al. (2013). It is a preprocessing algorithm and a classifier that aims to learn a latent representation of the data that minimises reconstruction error, while simultaneously obfuscating information about sensitive features. The algorithm works by solving an optimisation problem that balances the trade-off between classification accuracy, group and individual fairness, and reconstruction error. Thank you Tahar Allouche for the implementation efforts and the whole team of maintainers for the detailed review. To learn more: https://lnkd.in/eeNmnk-f Additionally, this release includes several improvements to existing functionality: - enhanced support for relaxed constraints and multi-dimensional input data in postprocessing optimisation methods - performance improvements through vectorisation - updated support for a Python version and user-impacting cleanups - first efforts concerning Narwhals (https://lnkd.in/ePzTbFuC) integration to speed up and make the backend more flexible and enjoyable to use. Thanks to Francesco Bruzzesi for his continuous efforts here. Among the others, this release also contains contributions from the participants of the PyLadies Berlin sprint ❤️ We are looking forward to the PyladiesCon sprint soon! Celebrating the new contributors of this release: Niha Pereira, Stefanie Senger, PhD, Emma Carballal Haire, Mariam Haji, Parul G., Camila Ayres, Edoardo Abati, Henrieke Max, Sanjana Kandi, Keshav Trivedi, Lesia Tkacz, Viet Anh Pham Nhu, Dr. Dimitra Gkogkou, Milena Arne Schedle, Melek E., and Mohamed Salah Allouche. Link to the release on Github: https://lnkd.in/eQDzzWs9

Open Source 001 🚀 Auto File Organizer Drowning in a messy Downloads folder? I built a tiny, zero-dependency Python CLI that automatically sorts files into neat subfolders by type: Images, Documents, Archives, Videos, Audio, Code, Misc. Why I built it? -> My Downloads and project drop folders were chaos. I wanted a “preview first, then clean” flow that’s safe by default and easy to customize. What it does ✅ Auto-categorizes by file extension ✅ Safe defaults (non-recursive; no-extension files stay put unless you ask) ✅ Duplicate handling (adds “(1)”, “(2)”, …) 🧪 Comes with tests + GitHub Actions CI ⚙️ Flags: --recursive to include subfolders --dry-run to preview actions (no changes) --move-noext to move files without extensions into Misc Check out the repo: https://lnkd.in/eMg__XiM Next up -> Custom config for categories -> Undo logs -> Easy scheduling with cron/systemd If this saves you time, I’d love a star ⭐, your feedback, or a PR. Let’s make everyday DevTools simpler. #Python #OpenSource #Productivity #DevTools #CLI

🚀 DSA Progress – Day 103 ✅ Problem #472: Concatenated Words 🧠 Difficulty: Hard | Topics: String, DFS, Dynamic Programming, Memoization 🔍 Approach: Implemented a DFS + Memoization strategy to identify all words that can be formed by concatenating two or more other words from the given list. Step 1 (Preparation): Store all words in a set for O(1) lookups. Step 2 (Recursive Checking): For each word, split it into all possible prefix–suffix pairs. If the prefix exists in the set, check if the suffix is either directly in the set or can be recursively formed using other words. Step 3 (Memoization): Use a dictionary (mp) to cache previously computed results to avoid redundant recursive calls. Step 4 (Result Collection): If a word can be formed by concatenation, add it to the result list. 🕒 Time Complexity: O(n × L²) n = number of words L = maximum word length Each word may be split at every position. 💾 Space Complexity: O(n + L) For the word set, recursion stack, and memoization dictionary. 📁 File: https://lnkd.in/gHA3vtD5 📚 Repo: https://lnkd.in/g8Cn-EwH 💡 Learned: This problem taught me how to efficiently combine recursion and memoization for overlapping subproblems. It felt like solving an advanced version of the Word Break problem but applied across an entire list of words. Breaking down the logic into small, reusable parts (isConcat + main loop) made the implementation clean and scalable. ✅ Day 103 complete — pieced together words like a linguistic puzzle master 🧩✨ Every big problem is just smaller words glued smartly together! 💬🔠 #LeetCode #DSA #Python #Recursion #DynamicProgramming #Strings #Memoization #WordProblems #100DaysOfCode #DailyCoding #InterviewPrep #GitHubJourney