Typst Solves High Volume PDF Generation for Spring Boot Teams

GraphCompose v1.1.0 is live. It started as a way to generate PDFs in Java without descending into the usual coordinate-based chaos where one small layout change somehow becomes a personal attack. With v1.1.0, GraphCompose moves further away from low-level PDF drawing and closer to something more useful in real projects: a document layout engine that actually helps you build documents, not just manually suffer through them. What’s new: • compose-first built-in templates • QR codes, barcodes, watermarks, headers/footers, bookmarks, metadata, and page breaks • layout snapshot testing for pagination and geometry regressions • runnable examples for CVs, cover letters, invoices, proposals, and weekly schedules • benchmark and diff tooling • an experimental live preview workflow for faster template iteration The goal is simple: Describe the document structure, and let the engine handle layout, wrapping, pagination, and rendering. That sounds obvious, but anyone who has worked with PDF generation long enough knows it usually is not. Too often, “document generation” really means “draw everything manually and hope page 2 behaves.” This release pushes GraphCompose further toward being a practical platform for real applications, not just a thin wrapper over PDF drawing primitives. Repository: https://lnkd.in/eyJ2DK5b Release: https://lnkd.in/eEASVcVJ Feedback is very welcome. #Java #OpenSource #PDF #DocumentGeneration #SoftwareEngineering

EF Core’s Hidden Gem: MaxBy / MinBy Did you know that Entity Framework Core 7+ now supports MaxBy and MinBy directly in LINQ queries? This makes it super easy to fetch the entity with the maximum or minimum value for a given property without writing extra boilerplate. ✨ Why it matters: • MaxBy / MinBy returns the entire entity, not just the scalar value. • Cleaner, more expressive LINQ, less manual OrderBy + FirstOrDefault. • EF Core translates it into efficient SQL (TOP(1) + ORDER BY). This is a small but powerful feature that makes your queries more readable and maintainable. 🔗 Have you started using MaxBy / MinBy in your EF Core projects, or are you still relying on OrderBy + FirstOrDefault? 📌 Save for later. ♻️ Repost to help other engineers learn and grow. ➕ Follow Rehan Akbar + turn on notifications. #dotnet #efcore #csharp #linq #entityframework #sql #fullstackdevelopment #codingtips #softwareengineering #developers

Ever wondered how to turn tedious Word document handling into a seamless, code‑driven service? Modern software increasingly depends on automated document generation and manipulation. Whether you need to create contracts, reports, or personalized letters at scale, a reliable backend service can turn a repetitive task into a streamlined workflow. Python developers now have a powerful option to meet this demand. The Aspose Words MCP Server, built on Aspose Words for Python via .NET, exposes full Word processing capabilities through the Model Context Protocol. It lets you create, edit, and export DOCX, PDF, and other formats programmatically, and makes these functions accessible to AI agents and any MCP‑compatible client. Getting started is straightforward: install the package with pip or build from source, then launch the server with a single command. It supports HTTP, gRPC, and WebSocket transports, giving you flexibility to integrate with web services, micro‑services, or desktop applications without extensive wiring. The server offers flexible licensing options and can be embedded in existing Python environments or containerized for cloud deployment. By centralizing document logic, teams reduce code duplication and improve maintainability. Explore how this approach can accelerate your projects and elevate document automation. #Python #DocumentAutomation #MCP #AIIntegration https://lnkd.in/dPdmfb-W

Ever opened a file called UserManager.py only to discover it’s 3,000 lines long and handles literally everything from database connections to sending emails? 😅 We’ve all been there. In my daily work as a Back-end Developer, I've seen firsthand how these "God Classes" can turn a simple feature update into a terrifying game of Jenga. That’s why I’m kicking off a new series on Medium deep-diving into the SOLID principles, starting with the foundation: the Single Responsibility Principle (SRP). In this first article, we break down: - The danger of the "Swiss Army Knife" approach to coding - Real-world Python examples showing the exact "Before & After" of a refactor - The top 3 red flags to spot SRP violations in your own projects If you are looking to ditch the clutter and write cleaner, highly modular code, check out the full article here: https://lnkd.in/dxBcDgds What is the most outrageous "God Class" you have ever encountered in the wild? Let me know in the comments! #CleanCode #SoftwareEngineering #Python #SOLID #Backend #DeveloperLife #TechWriting

𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 𝗢𝗢𝗣 𝗚𝘂𝗶𝗱𝗲 Stop writing long scripts with random functions. Organize your code into objects. Think of a house blueprint. A blueprint is a class. It is a plan. A builder uses one plan to build ten houses. Each house is an object. Classes define two things: - Properties: Data like color or name. - Methods: Actions like run or stop. Use the new keyword to create an object. This is instantiation. The constructor method runs when you create an object. It sets initial values. The this keyword assigns values to the specific object you create. Encapsulation bundles data and methods. It hides inner logic. Use a # symbol to make variables private. This stops external code from changing your data. OOP makes your code easy to reuse. It helps you scale your projects. Source: https://lnkd.in/gitXHVQE

New open-source release: OpenApiWeaver — a C# Source Generator that builds type-safe HTTP clients from OpenAPI definitions at compile time. Two things I want to highlight: 1️⃣ Code quality was the whole point. Existing tools (OpenAPI Generator, NSwag, etc.) all work, but I wanted generated code that felt hand-written — proper NRT, `required` modifiers, XML doc comments from OpenAPI descriptions, and string enums modeled as `readonly record struct` instead of C# enums (which handle unknown values gracefully). 2️⃣ This was built almost entirely with AI coding tools. PoC in Codex with GPT-5.4, then implementation via GitHub Copilot Chat using GPT-5.4 and Claude Opus 4.6. Hand-writing Source Generators has always felt prohibitively painful to me — AI tooling let me focus on API design decisions while the assistant handled the mechanical code emission. PoC to public release, docs included: about 3 days. Full write-up on dev.to: https://lnkd.in/gSzYnCqz #dotnet #csharp #OpenAPI #OpenSource #AICoding #DeveloperTools

I've finally started a deep dive into C++ templates. It's no news how incredibly powerful templates are; I've just not been able to fully master them. To be fair, templates have a steep learning curve and can certainly become complicated very quickly. On the bright side, the trade-off in flexibility and performance is often worth the effort. If you're asking how complicated it is? There's literally a 2500+ page book on C++ templates alone and several cppcon talks on it. You get the gist. For starters, a template in C++ is essentially a blueprint to tell the compiler how a function or a class should be defined (or created) at compile time. We basically tell the compiler to generate a family of functions or a family of classes during compile-time based on the parameterized type used during instantiation. Templates are similar to generics in other languages, albeit infinitely more powerful, flexible, and elegant than generics. Templates in C++ are a powerful mechanism for meta-programming since we get the compiler to generate code (or programs) based on the program we already wrote. One way I trivialize templates in my head is to assume that the compiler is running a subprogram during compilation. The output of this subprogram is executed as a part of the original program. So when you encounter a template definition in your code, pause and think of it as some process that runs during compilation. A key thing to note about templates: Templates are compiled using a two-phase compilation process: 1st phase: The compiler performs a static analysis of everything independent of the template parameters, static type checking, syntax, and grammar validation, non-templated signature validation, etc. 2nd Phase: The type is instantiated when the templated function or class is invoked. The compiler assesses the validity of the template parameters and the operations on these parameters. ref: https://lnkd.in/eZD-V3kE

🚀 LeetCode 207 – Course Schedule | From Multiple Approaches → Cleaner Thinking While working on graph problems, I revisited Course Schedule and explored multiple implementations in Java — not just to solve it, but to understand why each approach works. 🔍 Core Idea Courses + prerequisites → Directed Graph Goal → Check if graph has a cycle 👉 If cycle exists → ❌ cannot finish all courses 👉 If no cycle → ✅ valid ordering exists (DAG) 💡 Approach 1: BFS (Kahn’s Algorithm) Build graph + compute in-degree Process nodes with in-degree = 0 Count processed nodes ✔ Intuitive (layer-by-layer removal) ✔ Great for topological sorting ❗ Slight overhead (separate passes) 💡 Approach 2: DFS (Visited + Recursion Stack) Track visited[] and recStack[] Detect back-edge → cycle ✔ Strong conceptual clarity ✔ Useful for many graph problems ❗ Extra space for 2 arrays 💡 Approach 3: Optimized BFS (Single Pass) ⭐ Build graph + in-degree together Use ArrayDeque for performance No extra passes ✔ Cleaner ✔ More efficient in practice ✔ Interview-friendly 💡 Approach 4: DFS with State Array (Latest Submission) 🔥 // 0 = unvisited, 1 = visiting, 2 = visited Replace visited[] + recStack[] with single state[] Detect cycle when visiting a node already in state = 1 ✔ Same time complexity → O(V + E) ✔ Reduced space usage ✔ Cleaner logic (less bookkeeping) 🔥 What Changed My Understanding Same problem. Same complexity. But different implementations gave me: Better control over graph traversal patterns Clear understanding of cycle detection Ability to optimize space without changing logic 📌 Takeaway Don’t stop at “Accepted” ✅ Push further: Try another approach Optimize space or structure Compare trade-offs That’s where real growth happens. #Java #DSA #Graphs #LeetCode #TopologicalSort #BackendDevelopment #LearningInPublic

For those who are interested in offline reading, I've been working on the idea of putting together a unified manual for TidesDB. This includes pretty much everything on the website, such as design write-ups, references for all the different languages and integrations, and more. I know it is 600+ pages, but the reality is that a very long time and potentially hundreds of hours went into just the write-ups on the system, many, many revisions. It is quite fascinating to see it all come together and to appreciate the scale of it all. I do hope that, in the end, what I write and what I compose comes through in an understandable way and benefits you all. https://lnkd.in/ePX3zZUm #manual #doc #tidesdb #mariadb #kafka

Your agent is reading files blindly. There's a better way. Every time your coding agent needs context, it reads raw files. All of them. Every session. From scratch. That's fine when you have 5 files. It falls apart at 50. Graphify fixes this. It's a Claude Code skill. Type /graphify ./your-folder and it reads your files once, builds a knowledge graph, and hands you back structure you didn't know was there. What concepts everything connects through. Surprising cross-file relationships. Questions the graph is uniquely positioned to answer. The number that got me was 71.5x fewer tokens per query on a real mixed corpus of code, papers, and images compared to reading raw files. And they show the worked examples in the repo so you can verify it yourself. You also get an interactive HTML graph you can click around, an Obsidian vault, and a wiki mode where an agent navigates the whole knowledge base by just reading markdown. No JSON parsing, no re-reading everything from scratch every session. Every edge is tagged EXTRACTED, INFERRED, or AMBIGUOUS. You always know what it found vs what it guessed. That kind of honesty is rare in tooling like this. 14.6k stars. Worth checking out. https://lnkd.in/gqtMBjKF