#solidprinciples — Bluesky Posts

@functionalprogramming.activitypub.awakari.com.ap.brid.gy

2 weeks ago

The Dependency Injection Secrets That Change How You Design Systems Introduction In object-oriented programming, Dependency Injection is one of the most...

The Dependency Injection Secrets That Change How You Design Systems Introduction In object-oriented programming, Dependency Injection is one of the most important design techniques for building sca...

#dependencyinversion #solidprinciples #systemdesign #oop

Origin | Interest | Match

0 0 0 0

@alaxhenry0121.bsky.social

1 month ago

SOLID Principles in iOS Development: Complete Interview Guide for Junior to Mid-Level Developers Practical answers to the most common iOS interview questions about SOLID principles, with production-ready Swift code samples that…

I just published SOLID Principles in iOS Development: Complete Interview Guide for Junior to Mid-Level Developers medium.com/p/solid-prin...
#iOS #iOSDevelopment #Swift #SOLIDPrinciples #CleanCode #iOSArchitecture #MobileDevelopment #TechnicalInterview #CodingInterview #SoftwareEngineering

0 0 0 0

@alaxhenry0121.bsky.social

1 month ago

SOLID Principles in Android Development: Complete Interview Guide for Junior to Mid-Level… Practical answers to the most common Android interview questions about SOLID principles, with production-ready Kotlin code samples that…

I just published SOLID Principles in Android Development: Complete Interview Guide for Junior to Mid-Level… medium.com/p/solid-prin...
#Android #AndroidDevelopment #Kotlin #SOLIDPrinciples #CleanCode #AndroidArchitecture #MobileDevelopment #TechnicalInterview #CodingInterview #SoftwareEngineering

0 0 0 0

@alaxhenry0121.bsky.social

1 month ago

SOLID Principles in Mobile Development: Flutter Interview Guide for Junior to Mid-Level Developers Practical answers to the most common Flutter interview questions about SOLID principles, with production-ready code samples that…

I just published SOLID Principles in Mobile Development: Flutter Interview Guide for Junior to Mid-Level Developers medium.com/p/solid-prin...
#Flutter #FlutterDevelopment #MobileDevelopment #SOLIDPrinciples #CleanCode #SoftwareArchitecture #DartProgramming #TechnicalInterview #CodingInterview

0 0 0 0

Mark Jack

@markjackmilian.bsky.social

2 months ago

Just a moment...

Explore the benefits of applying SOLID principles in .NET for enhanced codebase health! Dive into strategies for sustainable software design. #DotNet #SOLIDPrinciples

1 0 0 0

HackerNoon

@hackernoon.com

3 months ago

The Art of the Prompt: Engineering GenAI to Produce SOLID-Compliant Code

Generative AI writes code that works, but not code that lasts. Prompting with SOLID principles turns it from junior coder to senior architect. #solidprinciples

0 0 0 0

NareshIT

@nareshit.bsky.social

4 months ago

Master the S.O.L.I.D Principles – The Foundation to Clean Architecture!

Register Now: t.ly/FWSOLID-25OC

Trainer: Mr. Abhijeet Kumar
(IIT Delhi Alumni | Senior SDE @ Amazon)
Date: 25th October
Time: 6:00 PM (IST)

Upskill Now — It’s FREE for All!

#NareshIT #SOLIDPrinciples

1 0 0 0

DEV Community

@dev.to.web.brid.gy

9 months ago

Understanding the Decorator Pattern Through a MacBook Customization Example in C# The `Decorator Pattern` is a powerful structural design pattern that enables adding new behavior to objects dynamically without modifying their original code. This is especially useful when you want to extend functionalities without creating a complex hierarchy of subclasses. In this article, I’ll explain the Decorator Pattern using a practical example: customizing a MacBook with different configurations like upgrading RAM, SSD, and adding AppleCare protection. ## **What is the Decorator Pattern?** The Decorator Pattern allows you to "wrap" an object with additional features or responsibilities at runtime. Instead of creating many subclasses for every possible combination, decorators let you compose behaviors dynamically by stacking objects. ## **The MacBook Example Overview** We start with a base MacBook configuration: * 16GB RAM * 256GB SSD * Base price * Using decorators, we can: * Upgrade RAM to 24GB * Upgrade SSD to 512GB * Add AppleCare protection Each decorator modifies the price and relevant specs accordingly. ## **Core Components** **The Interface`IMacBook`** Defines the contract with methods like: * GetDescription() * GetPrice() * GetRamSize() * GetSSDSize() **The Base Class`BaseMacBook16Ram256SSD`** Implements `IMacBook` and represents the default MacBook configuration. **The Abstract Decorator`MackBookDecorator`** This class implements `IMacBook` and wraps another `IMacBook` instance. It delegates calls to the wrapped instance but can be extended to add or override behavior. **Concrete Decorators** * `MacBookWithAppleCare`: Adds AppleCare price and description. * `MacBook512SSD`: Adds extra SSD storage and price. * `MacBook24RAM`: Adds extra RAM and price. ## **How to Use It** You can compose different MacBook configurations by wrapping the base object with decorators like this: IMacBook macBook16Ram256SSD = new BaseMacBook16Ram256SSD(); IMacBook macBook16Ram512Sdd = new MacBook512SSD(macBook16Ram256SSD); IMacBook macBook24Ram512Sdd = new MacBook24RAM(macBook16Ram512Sdd); IMacBook macBook24Ram512SddWithAppleCare = new MacBookWithAppleCare(macBook24Ram512Sdd); Console.WriteLine(macBook16Ram256SSD); Console.WriteLine(macBook16Ram512Sdd); Console.WriteLine(macBook24Ram512Sdd); Console.WriteLine(macBook24Ram512SddWithAppleCare); Each line creates a new configuration by decorating the previous one. ## **Why Use the Decorator Pattern?** * **Open/Closed Principle:** Extend object behavior without changing existing code. * **Flexibility:** Combine decorators in any order to create new behaviors. * **Avoids Class Explosion:** No need to create a subclass for every combination. ## **Real-World Applications** The Decorator Pattern is widely used in software development: * Adding scrollbars or borders in UI frameworks. * Enhancing functionalities like logging, caching, or security by wrapping services. * Customizing product configurations dynamically, just like our MacBook example. ## **Conclusion** The Decorator Pattern is an elegant way to add responsibilities to objects dynamically and flexibly. Using this pattern, you keep your codebase maintainable and avoid unnecessary class proliferation. You can find the full source code for this example on my GitHub repository: DecoratorPattern

0 0 0 0

Forem

@forem.com.web.brid.gy

9 months ago

Understanding the Decorator Pattern Through a MacBook Customization Example in C# The `Decorator Pattern` is a powerful structural design pattern that enables adding new behavior to objects dynamically without modifying their original code. This is especially useful when you want to extend functionalities without creating a complex hierarchy of subclasses. In this article, I’ll explain the Decorator Pattern using a practical example: customizing a MacBook with different configurations like upgrading RAM, SSD, and adding AppleCare protection. ## **What is the Decorator Pattern?** The Decorator Pattern allows you to "wrap" an object with additional features or responsibilities at runtime. Instead of creating many subclasses for every possible combination, decorators let you compose behaviors dynamically by stacking objects. ## **The MacBook Example Overview** We start with a base MacBook configuration: * 16GB RAM * 256GB SSD * Base price * Using decorators, we can: * Upgrade RAM to 24GB * Upgrade SSD to 512GB * Add AppleCare protection Each decorator modifies the price and relevant specs accordingly. ## **Core Components** **The Interface`IMacBook`** Defines the contract with methods like: * GetDescription() * GetPrice() * GetRamSize() * GetSSDSize() **The Base Class`BaseMacBook16Ram256SSD`** Implements `IMacBook` and represents the default MacBook configuration. **The Abstract Decorator`MackBookDecorator`** This class implements `IMacBook` and wraps another `IMacBook` instance. It delegates calls to the wrapped instance but can be extended to add or override behavior. **Concrete Decorators** * `MacBookWithAppleCare`: Adds AppleCare price and description. * `MacBook512SSD`: Adds extra SSD storage and price. * `MacBook24RAM`: Adds extra RAM and price. ## **How to Use It** You can compose different MacBook configurations by wrapping the base object with decorators like this: IMacBook macBook16Ram256SSD = new BaseMacBook16Ram256SSD(); IMacBook macBook16Ram512Sdd = new MacBook512SSD(macBook16Ram256SSD); IMacBook macBook24Ram512Sdd = new MacBook24RAM(macBook16Ram512Sdd); IMacBook macBook24Ram512SddWithAppleCare = new MacBookWithAppleCare(macBook24Ram512Sdd); Console.WriteLine(macBook16Ram256SSD); Console.WriteLine(macBook16Ram512Sdd); Console.WriteLine(macBook24Ram512Sdd); Console.WriteLine(macBook24Ram512SddWithAppleCare); Each line creates a new configuration by decorating the previous one. ## **Why Use the Decorator Pattern?** * **Open/Closed Principle:** Extend object behavior without changing existing code. * **Flexibility:** Combine decorators in any order to create new behaviors. * **Avoids Class Explosion:** No need to create a subclass for every combination. ## **Real-World Applications** The Decorator Pattern is widely used in software development: * Adding scrollbars or borders in UI frameworks. * Enhancing functionalities like logging, caching, or security by wrapping services. * Customizing product configurations dynamically, just like our MacBook example. ## **Conclusion** The Decorator Pattern is an elegant way to add responsibilities to objects dynamically and flexibly. Using this pattern, you keep your codebase maintainable and avoid unnecessary class proliferation. You can find the full source code for this example on my GitHub repository: DecoratorPattern

0 0 0 0

Mark Jack

@markjackmilian.bsky.social

9 months ago

Deep dive into the Liskov Substitution Principle! 🖥️ Understand how it ensures objects of a superclass are replaceable with objects of a subclass without affecting functionality. Improve code flexibility & reliability. #Programming #SOLIDPrinciples

0 0 0 0

Mark Jack

@markjackmilian.bsky.social

9 months ago

I Thought I Understood SOLID Principles — Until My App Collapsed After almost five years of .NET experience, I could confidently say: “I understand SOLID.” But confidence and proper implementation are…

Understanding SOLID principles is key to building robust software. This guide explores common misconceptions and offers tips to prevent app collapse. Ensure your app's stability with these insights. #SOLIDPrinciples #SoftwareDevelopment

0 0 0 0

Forem

@forem.com.web.brid.gy

11 months ago

Open/Closed Principle in C#: Making Your Code Flexible Without Breaking Stuff Ever built a feature that worked great—until someone added a small change and it all fell apart? Welcome to the pain of code that violates the **Open/Closed Principle**. > Software entities should be open for extension, but closed for modification. It’s the “O” in **SOLID** , and it’s all about writing code that can grow new behaviors without you having to rewrite what already works. Let’s unpack that—with real C# code, not vague theory. ## Our Old Friend: The InvoiceProcessor We’ll pick up from where we left off in the SRP post. Here's a class that's responsible for calculating invoice totals: public class InvoiceCalculator { public decimal CalculateTotal(Invoice invoice) { decimal total = 0; foreach (var item in invoice.LineItems) { total += item.Price * item.Quantity; } return total; } } All good. But now your product manager wants to add **discounts**. Tomorrow, someone else might ask for **tax rules**. Next week? Promotional pricing based on customer loyalty. Do we keep modifying this method every time? ## 🚨 The Problem: Change Means Risk If you change this class for every new pricing rule, a few things happen: * You risk breaking existing logic. * You have to re-test everything. * Your code becomes a jungle of `if` statements. That’s not sustainable. ## Enter the Open/Closed Principle Rather than adding new logic _inside_ the class, we **extend behavior** from the outside—through **abstraction and composition**. So instead of modifying `InvoiceCalculator`, we give it a way to plug in pricing strategies. ## 🏗️ Refactoring for Extensibility Let’s define a new interface: public interface IPricingRule { decimal Apply(Invoice invoice, decimal currentTotal); } Then we create a base calculator that supports rule injection: public class FlexibleInvoiceCalculator { private readonly List<IPricingRule> _pricingRules; public FlexibleInvoiceCalculator(List<IPricingRule> pricingRules) { _pricingRules = pricingRules; } public decimal CalculateTotal(Invoice invoice) { decimal total = invoice.LineItems .Sum(item => item.Price * item.Quantity); foreach (var rule in _pricingRules) { total = rule.Apply(invoice, total); } return total; } } Now let’s add a discount rule: public class TenPercentDiscountRule : IPricingRule { public decimal Apply(Invoice invoice, decimal currentTotal) { return currentTotal * 0.9m; } } And another for tax: public class TaxRule : IPricingRule { public decimal Apply(Invoice invoice, decimal currentTotal) { return currentTotal * 1.05m; // 5% tax } } Here’s how you’d use the `FlexibleInvoiceCalculator` with both the discount and tax rules applied: // Example invoice setup var invoice = new Invoice { LineItems = new List<LineItem> { new LineItem { Price = 100, Quantity = 2 }, // $200 new LineItem { Price = 50, Quantity = 1 } // $50 } }; // Define pricing rules var pricingRules = new List<IPricingRule> { new TenPercentDiscountRule(), // 10% off new TaxRule() // Add 5% tax }; // Create calculator with rules var calculator = new FlexibleInvoiceCalculator(pricingRules); // Calculate final total decimal finalTotal = calculator.CalculateTotal(invoice); Console.WriteLine($"Final Total: {finalTotal:C}"); // Output: Final Total: $198.45 You can mix, match, and inject these rules without touching the calculator itself. ## Why This Works Your core logic (the calculator) is **closed for modification**. You’re not touching its internals anymore. But it’s **open for extension** —you can pass in any rule that implements `IPricingRule`. This means: * ✅ New logic = new classes, not risky edits. * ✅ Old logic stays safe. * ✅ Behavior is pluggable, testable, and isolated. ## 🔍 Real-World Benefits The Open/Closed Principle helps you: * ✨ Add features faster. * 🚫 Avoid regressions. * 🔧 Create modular code that adapts to new requirements without breaking old ones. * ✨ Encourage team collaboration—each rule can be owned/tested by different devs. ## 🧪 A Simple Test If adding a new behavior means **editing existing, working code** , you’re probably violating OCP. If you can write new logic without opening up stable code, you’re doing it right. ## Final Thoughts The Open/Closed Principle is about trust. You trust that your existing logic works, and you want to extend it **without messing it up**. Abstraction isn’t overengineering—it’s insurance for your codebase. When your app grows (and it will), code that’s open for extension and closed for modification will save you from a lot of late-night refactors. > Your code should welcome change like an open door, but guard its core like a vault.

0 0 0 0

DEV Community

@dev.to.web.brid.gy

11 months ago

Open/Closed Principle in C#: Making Your Code Flexible Without Breaking Stuff Ever built a feature that worked great—until someone added a small change and it all fell apart? Welcome to the pain of code that violates the **Open/Closed Principle**. > Software entities should be open for extension, but closed for modification. It’s the “O” in **SOLID** , and it’s all about writing code that can grow new behaviors without you having to rewrite what already works. Let’s unpack that—with real C# code, not vague theory. ## Our Old Friend: The InvoiceProcessor We’ll pick up from where we left off in the SRP post. Here's a class that's responsible for calculating invoice totals: public class InvoiceCalculator { public decimal CalculateTotal(Invoice invoice) { decimal total = 0; foreach (var item in invoice.LineItems) { total += item.Price * item.Quantity; } return total; } } All good. But now your product manager wants to add **discounts**. Tomorrow, someone else might ask for **tax rules**. Next week? Promotional pricing based on customer loyalty. Do we keep modifying this method every time? ## 🚨 The Problem: Change Means Risk If you change this class for every new pricing rule, a few things happen: * You risk breaking existing logic. * You have to re-test everything. * Your code becomes a jungle of `if` statements. That’s not sustainable. ## Enter the Open/Closed Principle Rather than adding new logic _inside_ the class, we **extend behavior** from the outside—through **abstraction and composition**. So instead of modifying `InvoiceCalculator`, we give it a way to plug in pricing strategies. ## 🏗️ Refactoring for Extensibility Let’s define a new interface: public interface IPricingRule { decimal Apply(Invoice invoice, decimal currentTotal); } Then we create a base calculator that supports rule injection: public class FlexibleInvoiceCalculator { private readonly List<IPricingRule> _pricingRules; public FlexibleInvoiceCalculator(List<IPricingRule> pricingRules) { _pricingRules = pricingRules; } public decimal CalculateTotal(Invoice invoice) { decimal total = invoice.LineItems .Sum(item => item.Price * item.Quantity); foreach (var rule in _pricingRules) { total = rule.Apply(invoice, total); } return total; } } Now let’s add a discount rule: public class TenPercentDiscountRule : IPricingRule { public decimal Apply(Invoice invoice, decimal currentTotal) { return currentTotal * 0.9m; } } And another for tax: public class TaxRule : IPricingRule { public decimal Apply(Invoice invoice, decimal currentTotal) { return currentTotal * 1.05m; // 5% tax } } Here’s how you’d use the `FlexibleInvoiceCalculator` with both the discount and tax rules applied: // Example invoice setup var invoice = new Invoice { LineItems = new List<LineItem> { new LineItem { Price = 100, Quantity = 2 }, // $200 new LineItem { Price = 50, Quantity = 1 } // $50 } }; // Define pricing rules var pricingRules = new List<IPricingRule> { new TenPercentDiscountRule(), // 10% off new TaxRule() // Add 5% tax }; // Create calculator with rules var calculator = new FlexibleInvoiceCalculator(pricingRules); // Calculate final total decimal finalTotal = calculator.CalculateTotal(invoice); Console.WriteLine($"Final Total: {finalTotal:C}"); // Output: Final Total: $198.45 You can mix, match, and inject these rules without touching the calculator itself. ## Why This Works Your core logic (the calculator) is **closed for modification**. You’re not touching its internals anymore. But it’s **open for extension** —you can pass in any rule that implements `IPricingRule`. This means: * ✅ New logic = new classes, not risky edits. * ✅ Old logic stays safe. * ✅ Behavior is pluggable, testable, and isolated. ## 🔍 Real-World Benefits The Open/Closed Principle helps you: * ✨ Add features faster. * 🚫 Avoid regressions. * 🔧 Create modular code that adapts to new requirements without breaking old ones. * ✨ Encourage team collaboration—each rule can be owned/tested by different devs. ## 🧪 A Simple Test If adding a new behavior means **editing existing, working code** , you’re probably violating OCP. If you can write new logic without opening up stable code, you’re doing it right. ## Final Thoughts The Open/Closed Principle is about trust. You trust that your existing logic works, and you want to extend it **without messing it up**. Abstraction isn’t overengineering—it’s insurance for your codebase. When your app grows (and it will), code that’s open for extension and closed for modification will save you from a lot of late-night refactors. > Your code should welcome change like an open door, but guard its core like a vault.

0 0 0 0

Alex Rusin

@alexrusin.com

11 months ago

Dependency Injection In Node.js

This video explores Dependency Injection in a Node.js application, demonstrating how to pass dependencies into a use case constructor. #DependencyInjection #NodeJS #CleanArchitecture #SOLIDPrinciples #SoftwareDesign

0 0 0 0

Alex Rusin

@alexrusin.com

11 months ago

Dependency Inversion Principle Explained

Learn Dependency Inversion Principle (DIP) from SOLID. #SOLIDPrinciples #DependencyInversion #NodeJS #CleanCode #SoftwareDesign

0 0 0 0

Taras Kovalenko

@tkovalenko.bsky.social

1 year ago

SOLID - фундамент адаптивної архітектури SOLID - це акронім п’яти фундаментальних принципів об’єктно-орієнтованого програмування та проєктування, представлених Робертом Мартіном. Ці принципи допомагають створювати програмні системи, які є:

🤖 У світі, де AI вже пише код та п'є каву з розробниками, базові принципи SOLID все ще залишаються загадкою для багатьох 😅

#programming #developers #dotnet #csharp #solidprinciples #softwareengineering #codinglife #cleancode #solid

taraskovalenko.github.io/posts/solid/

0 0 0 0

Arnaud Langlade

@arnolanglade.bsky.social

1 year ago

🤔 Even if the Single Responsibility Principle (SRP) is simple to grasp, is it simple to apply?

More info 🧵 👇

🖼️ Picture: @designedbyflores unsplash)

#SOLIDPrinciples #SOLID #SingleResponsibilityPrinciple #SRP #OOP #ObjectOrientedProgramming #ProgrammingTips

0 0 1 0

Arnaud Langlade

@arnolanglade.bsky.social

1 year ago

🧐 Struggling with unit tests? Does your code involve input/output (IO) operations?

I explain 🧵 👇 [1/3]

🖼️ Picture: unsplash.com/@gndclouds

#SOLIDPrinciples #SOLID #DependencyInversion #DIP #OOP #ObjectOrientedProgramming #ProgrammingTips

2 0 1 0

Arnaud Langlade

@arnolanglade.bsky.social

2 years ago

🚀 Excited to share my last blog post about the Dependency Inversion Principle (DIP), a crucial SOLID principle in Object-Oriented Programming (OOP)!

The link to the article 🧵 👇 [1/3]

🖼️ Picture: unsplash.com/@gndclouds

#SOLIDPrinciples #SOLID #DependencyInversion #DIP #OOP

1 0 1 0

Alvin Ashcraft

@alvinashcraft.com

2 years ago

JavaScript SOLID Principles: How to Write Maintainable Code (via @Syncfusion).

#javascript #webdev #solidprinciples #programming...

0 0 1 0