Artem Demchyshyn’s Post

GraphCompose v1.4 is live. https://lnkd.in/eyJ2DK5b The last time I properly posted about GraphCompose here, it was v1.1.0. Since then, I did what every developer promises not to do: “I’ll just improve a few things.” A few things later, GraphCompose is no longer just a Java PDF generation project. It has moved much closer to a declarative document layout engine. The idea is simple: Instead of manually fighting PDF coordinates, margins, page breaks, and layout edge cases, you describe the document structure: sections, modules, paragraphs, tables, rows, layers, themes. GraphCompose handles layout, pagination, snapshots, and PDFBox rendering behind the scenes. The new v1.4 line adds: table column spans layer stacks for overlay-style layouts page and section backgrounds fluent rich text DSL reusable BusinessTheme design tokens visual regression scaffolding for generated PDFs stronger documentation and release guardrails Basically, I wanted PDF documents to feel less like drawing on a cave wall with coordinates and more like building UI layouts with components. Still Java. Still PDFBox underneath. But now with a much stronger layout engine on top. This release is a big step for the project: from “generate a PDF” toward “compose a designed document.” Repo: GraphCompose by DemchaAV hashtag #Java #OpenSource #PDFGeneration #SoftwareEngineering #BackendDevelopment #JavaDeveloper #PDFBox

🚀 C# Switch Statement: Old vs New Syntax Explained C# has evolved significantly, and one of the most impactful improvements is the introduction of the switch expression (C# 8.0+) — making code more concise, readable, and safer. 🔹 Old Switch Statement (C# 1.0+) Statement-based structure Requires break to prevent fall-through Doesn’t return a value directly Better for complex logic with multiple operations 🔹 New Switch Expression (C# 8.0+) Expression-based (returns a value) No break needed No fall-through (safer by design) Supports pattern matching, type checks, and conditions Cleaner and more maintainable 💡 When to use what? Use switch statements when handling complex logic blocks Use switch expressions for simple, value-returning conditions ⚡ Why it matters Modern C# encourages writing less code with more clarity. Switch expressions reduce boilerplate and help avoid common bugs like accidental fall-through. ✅ Pro Tip: Prefer switch expressions for most scenarios in modern applications — especially when working with mappings, transformations, or pattern matching. 📌 Final Thought: Write code that’s not just functional, but also readable and maintainable. #CSharp #DotNet #Programming #SoftwareDevelopment #CleanCode #Developers #Coding #Tech

Most developers write this kind of code at some point: if (obj instanceof File) else if (obj instanceof Folder) It works. But it doesn’t scale. As your system grows, this approach leads to: Increasing conditional logic Tight coupling Code that is hard to extend and maintain This is where the Composite Design Pattern becomes powerful. Instead of asking: "What type of object is this?" You design your system so that every object responds to the same behavior. Now you simply write: root.show(); No type checking. No conditional branching. Just clean, extensible code. The key idea: Treat individual objects and groups of objects uniformly. This pattern is widely used in: File systems UI component trees (Angular, React) Organization hierarchies Menu structures Why it matters in real projects: Reduces complexity Improves readability Makes systems easier to extend without modifying existing code Good design is not about making code work. It is about making code evolve. If you are preparing for interviews or working on scalable systems, this is a pattern worth mastering. #Java #SystemDesign #DesignPatterns #CleanCode #SoftwareEngineering #BackendDevelopment #InterviewPreparation

🚀 Day 24 – Builder Pattern: Designing Objects the Right Way The Builder Pattern is one of the most powerful creational patterns in Java. It solves the age-old problem of complex object creation — without telescoping constructors, without confusion, and without unreadable code. Here’s why the Builder Pattern is a must-have in modern Java architecture: 🔹 1. Solves the Telescoping Constructor Problem Without Builder: new User("Kuldeep", "Vyas", 32, "Pune", true, false); ➡ Hard to read ➡ Easy to misplace parameters With Builder: User.builder().name("Kuldeep").age(32).isActive(true).build(); ➡ Self-descriptive ➡ Error-proof 🔹 2. Enables Immutable Object Design Builder pattern encourages creating: ✔ final fields ✔ immutable objects ✔ side-effect-free models ➡ A perfect fit for microservices, domain models, and concurrency. 🔹 3. Highly Readable & Fluent APIs Builder methods produce code that reads like English: new Order.Builder().withId(1).withItems(items).withTotal(999).build(); ➡ Cleaner code → fewer bugs → easier maintenance. 🔹 4. Handles Optional Fields Gracefully Not every object needs every field. Builder allows selective initialization: ✔ Only required fields ✔ Ignore optional ones ➡ No confusing constructor overloads. 🔹 5. Supports Validation During Build You can enforce rules in build() like: ✔ required fields ✔ non-null checks ✔ business constraints ➡ Prevents invalid object states. 🔹 6. Works Beautifully With Lombok & Records Lombok’s @Builder makes implementation effortless Records + Custom Builders → perfect for DTOs & API models 🔹 7. Clean Separation of Construction vs Representation Builders focus on how objects are created. Objects focus on what they represent. ➡ A clean architectural separation that scales. 🔥 Architect’s Takeaway The Builder Pattern is not just a convenience — it is a design philosophy. It gives you: ✔ Safer object creation ✔ More readable code ✔ Immutable designs ✔ Fewer bugs ✔ Cleaner domain models Exactly what modern enterprise systems need. #100DaysOfJavaArchitecture #BuilderPattern #CleanCode #Java #DesignPatterns #Microservices #SoftwareArchitecture

Ctrl+Z. You've used it a hundred times today. Ever wonder how it actually works? Every action you take — typing a word, deleting a line, changing a font — gets wrapped in a small object. That object knows two things: how to do the action, and how to undo it. Your editor keeps a stack of these objects. Ctrl+Z pops the last one and executes the undo operation. Ctrl+Y pushes it back and calls redo. The editor doesn't remember what you did. The objects do. That's the Command pattern. Instead of calling a function and forgetting about it, you turn the call into an object. Now you can store, queue replay it, or reverse it. Where you've already seen this: → Git commits — a diff that can be applied or reverted → Redux actions — `{ type: 'ADD_ITEM', payload }` dispatched to a store → Database transactions — statements that can be committed or rolled back → Task queues — jobs that sit in a queue until a worker picks them up and executes When NOT to use it: if your actions are simple and never need to be undone, queued, or logged. Wrapping every function call in an object when you'll never look at it again is a ceremony for nothing. #SoftwareEngineering #Programming #DesignPatterns #Architecture

You can now add properties, operators, and static methods to ANY type in C#. Including string. Including int. Including sealed classes. C# 14 Extension Members are the biggest language change since records. Before, we only had extension methods: → public static bool IsEmail(this string s) — works but ugly → Buried in a random static class → Can't add properties or operators Now, with extension blocks: public static class StringExtensions { extension(string str) { public bool IsEmail => str.Contains("@") && str.Contains("."); public int WordCount => str.Split(' ').Length; } } And usage is completely natural: if (user.Email.IsEmail) { ... } var words = title.WordCount; No more StringExtensions.IsEmail(email) scattered across utility classes. What you can now extend: • Instance properties • Static methods • User-defined operators (+=, -, ==, etc.) • Even sealed classes and built-in types Why this matters for real projects: • Domain-specific extensions that feel native • Fluent APIs without owning the target type • Cleaner validation — "price.IsValid" reads better than "PriceValidator.Validate(price)" • Less boilerplate in every layer of your code The limitation: Extension members can't have state. No backing fields that persist between calls. They're computed, not stored. This is intentional. Extensions enhance types — they don't fundamentally alter them. My take: This is a feature that changes how .NET libraries will be designed going forward. Every major NuGet package will adopt this. What type would you extend first? #dotnet #csharp #csharp14 #extensionmembers #programming #softwareengineering

If you're still writing if-else chains in C#, you're missing one of the best features added in the last 5 years. Pattern matching with switch expressions makes your code shorter, safer, and faster. Here's the evolution: 𝗦𝘁𝗮𝗴𝗲 𝟭 — Old way (if-else): → 15 lines of nested if-else → Easy to forget a case → Hard to read 𝗦𝘁𝗮𝗴𝗲 𝟮 — Classic switch: → Better than if-else → Still verbose → No way to return values directly 𝗦𝘁𝗮𝗴𝗲 𝟯 — Switch expression: → Single expression → Returns a value → Compiler enforces exhaustiveness → Pattern matching on types, properties, and tuples Real example I use all the time: Instead of this: → if order is null → throw exception → else if order.Status == "Pending" → process → else if order.Status == "Cancelled" → reject → else → log warning You write: var result = order switch { null => throw new ArgumentNullException(), { Status: "Pending" } => Process(order), { Status: "Cancelled" } => Reject(order), _ => LogWarning(order) }; 3 lines instead of 15. Same logic. Clearer intent. What pattern matching unlocks: • Property patterns — match on object properties • Tuple patterns — match on multiple values at once • Relational patterns — use >, <, >= directly in switches • List patterns — match on collections (C# 11+) • Type patterns — combined with deconstruction The compiler also warns you when you miss a case. Your bugs become impossible to ship. If your codebase is full of long if-else chains, you have an easy refactoring win waiting. What C# feature changed how you write code? #dotnet #csharp #patternmatching #cleancode #programming #softwareengineering

🚀 Java Design Patterns – Simple & Practical Guide Design patterns are proven solutions to common problems in software design. Here’s a quick breakdown with real use cases 👇 🔹 Creational Patterns (Object Creation) • Singleton – One instance (e.g., DB connection) • Factory Method – Object creation logic hidden • Abstract Factory – Create related objects • Builder – Build complex objects step by step • Prototype – Clone existing objects 🔹 Structural Patterns (Structure) • Adapter – Convert interface • Bridge – Separate abstraction & implementation • Composite – Tree structure (parent-child) • Decorator – Add behavior dynamically • Facade – Simplified interface • Flyweight – Memory optimization • Proxy – Control access 🔹 Behavioral Patterns (Interaction) • Observer – Event notification • Strategy – Change behavior dynamically • Command – Encapsulate request • Iterator – Traverse collection • Mediator – Central communication • Memento – Save/restore state • State – Change behavior based on state • Template Method – Define steps of algorithm • Visitor – Add operations without modifying class • Chain of Responsibility – Request handling chain 💡 Why use them? ✔ Clean code ✔ Reusability ✔ Scalability ✔ Better design #Java #DesignPatterns #SpringBoot #SoftwareEngineering #Coding

Why do we use public static void Main(){} in C# ? static (The Most Critical Keyword):: This is the one that usually trips people up. In C#, you usually need to create an "instance" (an object) of a class to use its methods. The Catch: If Main were not static, the CLR would have to create an object of your class first. But to create an object, it needs to run code... and it can't run code until it finds Main. The Solution: By making it static, the method belongs to the class itself, not an object. The CLR can just call Program.Main() directly as soon as the app starts. public (The Gateway):: While modern C# (and certain compilers) allows private or internal entry points, public is the standard. Why: It tells the CLR, "This method is visible and accessible from outside this specific file/assembly." It ensures the execution engine has "permission" to walk through the front door of your code. void (The Result):: The Meaning: It tells the operating system, "I’m going to do my job and then just stop." The Alternative: Sometimes you’ll see static int Main(). In that case, the program returns a number (an Exit Code) to the OS. (e.g., return 0; means success, return 1; means an error occurred). Main (The Identifier):: The Rule: C# is case-sensitive. It must be capitalized Main. If you name it main, the compiler will look right past it and tell you that your program is missing an entry point.

This Scientific Writing Tool Solved Our High Volume PDF Nightmare Most Spring Boot teams default to JasperReports or iText for PDF generation. We took a different path—and our documents now compile 3x faster. 🔴 The Problem with Traditional Tools: JasperReports → XML templates, slow compilation, memory-heavy iText → Verbose code, complex layouts, performance issues at scale HTML-to-PDF → CSS limitations, unpredictable rendering, browser overhead We needed something better. 🔬 The Unconventional Solution: Enter Typst—a modern typesetting system built for scientific papers that we repurposed for enterprise documents. ✨ Why It Changed Everything: ✅ 3-5x faster than JasperReports ✅ Clean syntax without XML boilerplate ✅ Lightweight—shell out to compiler, minimal JVM overhead ✅ Maintainable—stakeholders can edit templates ✅ Predictable output—no browser quirks ✅ Data-driven—perfect for parameterized templates ⚙️ The Integration: Fetch Template → Load Data → typst compile → PDF Ready No heavy dependencies. No compilation overhead. Just fast, reliable generation. 💡 The Insight: We stopped asking "What PDF library should we use?" We started asking "What produces the best PDFs fastest?" Typst was designed for academic journals, but its core strength—converting structured data into professionally formatted documents—is exactly what enterprise PDF generation needs. ⚖️ The Tradeoff: You're shelling out to an external process instead of pure Java. But for bulk generation, the performance gains demolish any "architectural purity" concerns. 🎯 The Takeaway: Don't let tool categorization limit your solutions. Sometimes the best enterprise tool comes from a completely different domain. 📖 Want the technical deep-dive? I wrote a detailed guide on implementation, benchmarks, and lessons learned: 👉https://lnkd.in/gT_QvfAp #Java #SpringBoot #PDFGeneration #Typst #BackendEngineering #PerformanceOptimization #SoftwareArchitecture #EnterpriseJava #TechDecisions #SystemDesign