The Adapter Pattern is one of the foundational patterns introduced in the legendary “Gang of Four” (GoF) book — Design Patterns: Elements of Reusable Object-Oriented Software It’s a timeless design approach that allows software components with incompatible interfaces to work together seamlessly. Whether you’re coming from iOS, Android, backend, or frontend, understanding design patterns like … Continue reading 🧩 Leveraging the Adapter Pattern in Flutter — A Transferrable Skill for Every Software Engineer
IOS Modularization and Unit Testing Feedback Speed
When an app is actively being developed, it tends to grow larger day by day. Over time, as engineers, we need to manage and maintain this growing codebase efficiently. If we don’t modularize it properly, we will eventually face significant challenges. Some of these include: Difficulty in maintenance Difficulty in adapting to new changes Slower … Continue reading IOS Modularization and Unit Testing Feedback Speed
Dependency Inversion Principle (DIP) in iOS Swift
The Dependency Inversion Principle (DIP) is a fundamental concept in software development that helps create flexible and maintainable code. In this article, I'll explore its history, the problem of tight coupling, and different approaches to applying DIP in Swift. History of the Dependency Inversion Principle The Dependency Inversion Principle (DIP) was introduced by Robert C. Martin, also known … Continue reading Dependency Inversion Principle (DIP) in iOS Swift
Understanding the Liskov Substitution Principle (LSP) in Swift
The Liskov Substitution Principle (LSP) is one of the five SOLID principles of object-oriented design. It states that: "Objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program.” (Paraphrased from Barbara Liskov’s) Barbara Liskov, a pioneering computer scientist, introduced this principle in 1987 as part of her research … Continue reading Understanding the Liskov Substitution Principle (LSP) in Swift
Open/Closed Principle (OCP) in Swift using Decorator Pattern
SOLID: Open Close Principle Overview The Open/Closed Principle (OCP) is one of the fundamental principles of object-oriented design, forming part of the SOLID principles. The concept is simple: “Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification.” This principle encourages building systems where new functionality can be added without altering existing code. This leads to … Continue reading Open/Closed Principle (OCP) in Swift using Decorator Pattern
SOLID : Single Responsibility Principle (SRP)
What is SRP? The Single Responsibility Principle (SRP) is one of the SOLID principles in software design. It states that a component should have only one reason to change. In other words, a class, struct, or any components, should have a single purpose and should not be modified for multiple reasons. Consider the following Swift struct: struct … Continue reading SOLID : Single Responsibility Principle (SRP)
Clean Architecture: A Blueprint for Scalable and Maintainable Software
Clean Architecture is a software design philosophy that helps developers build flexible, maintainable, testable, and scalable applications. It emphasizes separation of concerns, ensuring that different parts of the application have clear responsibilities and do not mix unrelated logic. Think of it like designing a beautiful city with a well-planned infrastructure—roads, districts, utilities, and zoning regulations all working together efficiently. A well-architected city makes … Continue reading Clean Architecture: A Blueprint for Scalable and Maintainable Software
Understanding the Decorator Pattern in Swift: A Practical Example
Overview Design patterns are a cornerstone of software development, providing reusable solutions to common problems. The Decorator Pattern is a structural design pattern that allows you to dynamically add new behavior to objects without altering their structure. It follows the Open/Closed Principle, which states that a class should be open for extension but closed for modification. In this … Continue reading Understanding the Decorator Pattern in Swift: A Practical Example
4 Part 4 – iOS – TDD – Random Character App – MVVM ViewModel
In this new series, we will be learning how we can use Test Driven Development on a networking based iOS project app, and in this case, we will fetch random character from `rickandmortyapi` and display it to the screen! In this video, we will learn how we can build our ViewModel component using Test Driven … Continue reading 4 Part 4 – iOS – TDD – Random Character App – MVVM ViewModel
#8 Swift – TDD + Delete Duplicates in Sorted List (Linked List)
Hi everyone, TDD is helpful, and now, I am going to share how we can use TDD on solving Delete Duplicates in sorted LinkedList problem! website - https://arifinfrds.com/ GitHub repository https://github.com/arifinfrds/ LeetCode: https://leetcode.com/problems/remove-duplicates-from-sorted-list/solutions/3073732/solution-using-swift-using-current-and-previous-node-pointer/ #deleteduplicatesinlinkedlist #tdd #testdrivendevelopment #swiftprogramming #dsa #datastructuresandalgorithms #arifinfrds #leetcode #leetcodesolution #programmer #softwaredeveloper #softwareengineer https://youtu.be/ymmSCNWo3NA
Arifin Firdaus Blog 