Software Design Patterns

🪜 Designing Better Progress Steps UX. With practical techniques to help people navigate and complete complex forms with or without progress steps ↓ ✅ Progress steps break a long form into small, manageable parts. ✅ They show where users are and how much they have left to go. 🤔 But: they are often overlooked and don’t scale well on mobile. 🤔 Difficult to design for dynamic flows with conditional sections. ✅ For simple forms, always start without a progress indicator. ✅ Tell users what they need and how much time it will take. ✅ Show progress as “Step [X] out of [Y]” with a text label. ✅ Add a drop-down to support quick jumps between steps. 🚫 For complex forms, don’t rely on visual progress bar alone. ✅ Always include text labels under each step for easy, precise jumps. ✅ Underline labels to make it clear that users can use them to navigate. ✅ Design 6 states: incomplete, active, complete, error, disabled, warning. 🤔 You can rarely display 5+ progress steps on mobile. ✅ Keep active label visible but hide future and past steps. ✅ Show a Back link on the top, Next button at the bottom. ✅ For long forms, repeat the Back link at the bottom, too. ✅ On desktop, vertical progress steps often work better. ✅ Set up an overview page with links to single steps (“task list”). ✅ Allow users to expand and collapse all steps and sub-steps. ✅ Don’t forget to highlight error status in the progress step. Only few things are more frustrating than a progress bar that seems to be stuck. Complex forms often have conditional sections, so users end up going in circles, staying on the same step as they move between sections. It’s a common problem with horizontal layout, and a common reason why people leave. With a vertical layout, we can always show all sections with all sub-steps, explaining to users where they are and what’s coming up next. We can expand and collapse some steps and support fast navigation and quick jumps. We can also highlight all errors or missing data and explain what’s actually missing. A few smaller pages usually perform better than one long page. One column layout usually causes fewer errors as multi-column layout. Give users one column with vertical progress steps, and you might be surprised how much faster they get through the entire form, despite its complexity and length. Useful resources: Stepped Progression, by Goldman Sachs https://lnkd.in/eHbB5EFu Multi-Step Wizard, by GE HealthCare https://lnkd.in/ezA__z_E Task List Pattern, by Gov.uk https://lnkd.in/eb3PzTEJ Form Design: From Zero to Hero, by Adam Silver https://lnkd.in/eTBQxBXg Wizards Design Recommendations, by Raluca Budiu https://lnkd.in/eYYxUUDM Loading And Progress Indicators, by Taras Bakusevych https://lnkd.in/e5KFPiiq #ux #design

Most people don’t fail in DSA because it’s hard. They fail because they try to learn everything instead of learning the right patterns. If you’re a fresher preparing for coding interviews, stop collecting questions. Start mastering patterns. Here’s the exact roadmap I recommend 👇 1️⃣ Arrays Core patterns you must know: • Two Pointers • Sliding Window (fixed and variable) • Prefix Sum • Kadane’s Algorithm • Hashing / Frequency Map • Sorting + Greedy • Cyclic Sort • Binary Search 2️⃣ Linked Lists Core patterns: • Fast & Slow Pointer • Dummy Node • Reversal (entire list / k-group) • Merge Lists • Pointer Rewiring 3️⃣ Stack & Queue Core patterns: • Monotonic Stack • Monotonic Queue • Stack for Previous / Next Greater • Sliding Window + Deque 4️⃣ Trees & Graphs Core patterns: • DFS (pre / in / post order) • BFS (level order) • Recursion • Backtracking on Trees • Dijkstra • Topological Sort • Union Find 5️⃣ Advanced Patterns • Binary Search on Answer • Greedy • Dynamic Programming ◦ 0/1 Knapsack ◦ Unbounded Knapsack ◦ DP on Strings • Heap (Top K, Merge K) • Bit Manipulation You don’t need 1000 problems. You need clarity on these patterns. Once you understand the pattern, 10 different questions start looking the same. That’s when preparation becomes smart. If you’re preparing for placements or switching jobs, save this post and follow for more such content ❤️

Most C# codebases don’t become messy overnight. They get there one switch case at a time. I published a new video where I take a complex OrderProcessor and refactor it using the Strategy Pattern. The starting point is a large switch statement that handles multiple shipping providers. It works, but every new provider means more changes in the same class, more dependencies leaking into the core flow, and more code that becomes harder to test over time. In the video, I show how to: - Extract the behavior behind an IShippingStrategy - Move each provider into its own class - Register strategies with DI - Resolve them through IEnumerable+IShippingStrategy - Simplify the OrderProcessor down to a dictionary lookup and delegation This refactor makes the code easier to extend, easier to reason about, and much easier to test in isolation. It also keeps provider-specific dependencies out of the central class, which is a big win once the logic starts getting more realistic. You can see the full breakdown here: https://lnkd.in/dRGk8aRy I also cover the tradeoff: you end up with more classes. But in real projects, that’s often a much better problem than one bloated class that keeps growing. If you’ve got a class full of conditionals that keeps getting “just one more case,” this pattern is worth knowing.

When Apple Inc. launched the original iPhone nearly two decades ago, the concept behind the software interface was fairly straightforward: mimicking the real world. That design ethos, known as skeuomorphism, meant the Notes app looked like an old school yellow notepad and the Maps software resembled the paper versions you may have kept in your car before GPS devices. Over time, Apple took this idea further. It made its Game Center app look like a blackjack table, complete with green felt, and its Podcasts interface was a tape recorder from the 1960s. The iPhone and iPad were some of the world’s first mainstream touch-screen devices, and using old-fashioned objects in software design helped people learn how to operate them. But customers soon grew accustomed to touch screens, and referencing ideas from 50 years earlier no longer made sense. https://lnkd.in/gw6tdWyu

- Memorizing solutions to 500 questions - Jumping straight into the IDE - Guessing the data structure - Trying to write perfect code from line one Here is what always works (The "Pattern Trigger" Strategy): 1. The 10-Minute Read + Match Do not start coding. Spend the first 10 minutes clarifying constraints and matching keywords to patterns. - Sorted input? → Binary Search. - Subarray or substring? → Sliding Window. - Pairs or triplets? → Two Pointers. - Frequency or grouping? → Hashmap. - Grid or connections? → Graph. - Repeated choices? → Dynamic Programming. - Next greater or histogram? → Monotonic Stack. 2. The 20-Minute "Safe Point" (Question 1) Write a simple approach first. Apply the identified pattern. Dry run on sample input immediately. Goal: Lock one correct solution. 3. The 10-Minute "Speed Mode" (Question 2) Do not chase perfection. Go with your first strong instinct. Goal: Reuse known patterns and try small constraints fast. 4. The 5-Minute Communication Close Explain time complexity. Explain space complexity. Goal: State why you chose this pattern and mention one alternative. What would you add? You do not win interviews by memorizing solutions. You win by recognizing patterns under pressure. Save this mapping for your next prep session. ♻️ Repost to help an engineer pass their interview. ➕ Follow me for more system design and engineering tips.

Case Study: How I decoupled Authentication logic with the Adapter Pattern While implementing authentication in one of my apps using Appwrite, I realized I didn’t want my app to be tightly coupled with Appwrite's API. Why? Because what if I decide to switch to Firebase or or my own Backend tomorrow? I’d have to go through the codebase and refactor all the logic. Not ideal. So I applied the Adapter Pattern. -------------------------------------------- What is the Adapter Pattern? Adapter Pattern is a structural design pattern that allows objects with incompatible interfaces to work together by translating one interface into another. Think of power adapter at your home! Your phone charger uses a USB-C plug, but the wall socket only accepts a standard power plug. So you use an adapter. The adapter doesn’t change how your charger works, it just makes it compatible with the socket. -------------------------------------------- There are multiple uses cases of this pattern - → normalizing data from different UI libraries → making Stripe, Razorpay, etc., follow your internal billing logic → making legacy APIs behave like REST or GraphQL If you ever find yourself writing if (isToolA) {...} else if (isToolB) {...} Try implementing an Adapter! Why? → to keep core logic clean and decoupled → to avoid unwanted refactoring → even for testing Have you used Adapter Pattern in your codebase before? Curious to hear your real-world examples.

How Apple changed screen design & what it teaches us about digital signage 🍎 When Apple launched the iPhone in 2007, its apps didn’t look futuristic. They looked familiar. 📇 Contacts = an old rolodex 📒 Notes = a yellow legal pad 🎙️ Voice recording = a studio mic 📆 Calendar = a ring-bound desk calendar This is skeuomorphism - designing digital interfaces to mimic physical objects. At the time, competitors like Microsoft & Nokia were racing towards sleek, minimalistic, & modern UIs. But they missed a key insight: 👉 Smartphones were new. 👉 Users needed a bridge between the physical & digital world. Apple’s designs made apps instantly understandable, easing users into a new way of interacting with technology. Fast forward to today, Apple has ditched skeuomorphism for flat design because we no longer need those visual crutches. The same shift is happening in digital signage. When a company adopts screens to communicate with their employees they will often lay them out like a digital noticeboard - clunky, chaotic, & mimicking old ways of communication. But that’s changing. The best digital signage today isn’t trying to look like a physical pinboard, it’s leaning into the medium & unlocking new possibilities. The content still serves the same purpose. But the experience is finally catching up. #ScreensThatCommunicate #Design #Skeuomorphism

Low Level Design (LLD) in Software Engineering =================================== Low Level Design (LLD) is crucial for building software that is modular, flexible, maintainable, and reusable. In interviews, you'll be assessed on your ability to apply Object-Oriented Design (OOD) principles and design patterns to solve real-world problems effectively. Here’s how to ace LLD interviews and demonstrate your design skills: What is LLD? ========= LLD is the component-level design process that involves refining system details step by step. It focuses on: -> Class diagrams with methods and class relationships -> Program specifications and low-level system details LLD is also known as Object-Oriented Design (OOD) and is fundamental for designing clean, efficient software systems. What Interviewers Expect? =================== In LLD interviews, you'll be judged based on your ability to create modular, flexible, and maintainable systems using OOD principles and design patterns. How to Prepare: -> Master an OOP Language: Familiarize yourself with one Object-Oriented Programming language (e.g., Java, C++, Python). -> Understand SOLID Principles: Study SOLID principles for clean, maintainable code. -> Learn Design Patterns: Gain a strong grasp of commonly used design patterns (Singleton, Factory, Strategy, etc.). -> Solve Common LLD Problems: Practice solving real-world problems to build your LLD skills. How to Tackle LLD Problems in Interviews =============================== -> Clarify the Problem: Ask relevant questions to ensure you fully understand the requirements before diving into the design. -> Identify Core Classes/Objects: Break down the system into its main components (classes and objects). -> Establish Relationships: Observe how different objects interact and define their relationships. -> Define Methods: Identify and define the methods needed for each class to fulfil the requirements. -> Apply OOD Principles & Patterns: Use appropriate design patterns and principles to enhance the system’s readability, maintainability, and reusability. -> Write Clean Code: If tasked with implementation, ensure your code is well-structured and adheres to clean coding practices.

What separates good code from great code? It’s often the design. Mastering design patterns gives you the power to solve common problems with reusable, clean solutions that make your code efficient, maintainable, and easy to collaborate on. 💡Efficiency in Problem Solving Trial and error can waste precious time, especially when you’re dealing with common coding challenges. Design patterns offer proven solutions that cut down on guesswork and speed up development. Example: Without patterns: You might end up writing repetitive code to create objects, leading to duplication and hard-to-manage logic. With patterns: The Factory pattern allows you to create objects cleanly, without changing client code, and makes it easy to manage different types of products in a flexible, reusable way. 💡Understanding Object-Oriented Principles Better Design patterns aren’t just about solving problems, they’re also a deeper dive into the core principles of object-oriented programming like encapsulation, inheritance, and polymorphism. Mastering these patterns sharpens your understanding of these concepts. Example: The Strategy pattern uses polymorphism to allow a class to change its behavior at runtime. Instead of cluttering your code with conditionals, you can encapsulate behaviors in separate classes and switch them dynamically. By applying design patterns, you’ll enhance your ability to create cleaner, more maintainable systems based on solid object-oriented principles. 💡Making Code More Maintainable Design patterns are all about modularity and separation of concerns. These principles make your code easier to extend and maintain over time, ensuring you don’t have to constantly rewrite or refactor. Example: The Decorator pattern adds functionality to an object without altering its code, staying true to the Open/Closed Principle. It allows you to extend behavior without changing the core object, making future changes smoother. 💡Designing with Flexibility in Mind Design patterns promote loose coupling and high cohesion, which makes your systems easier to modify and scale, especially as they grow in complexity. Example: The Observer pattern allows objects to react to changes in other objects without being tightly coupled. When a subject changes, all observers are automatically notified without needing direct references to each other. This separation makes your system more flexible and scalable. You can add or remove components with minimal impact on the rest of the system. 💡Recognizing Reusable Solutions Design patterns provide a catalog of reusable solutions that help you solve recurring challenges more efficiently. Example: The Command pattern is used for implementing task scheduling or user actions in applications, where each action encapsulated as an object. This way you can queue, undo, or log actions without tightly coupling the logic to the user interface/main application flow. #software #tech #techblogs #designpatterns

How to Nail Theme Switching (Light/Dark) Yourself Dark mode isn’t just a toggle—it’s a test of how well you understand UI structure. When you practice building theme switchers, you learn: 1️⃣ Using CSS variables for scalable color systems. 2️⃣ Applying context/state management (ThemeProvider in React, for example). 3️⃣ Ensuring persistence (localStorage, cookies). AI can hand you snippets, but only real practice shows you: → Where styles leak → Where variables break → How to keep performance smooth And when you nail it? You’ve built a reusable skill every product team values. 👉 Try coding a light/dark theme switcher at iocombats.com A tutorial with NextJS may like: https://lnkd.in/dv8dXfvY --- Follow Ghazi Khan & iocombats for frontend/full-stack development & jobs-related stuff.