DEV Community: Almat

SOLID Principles with Swift by building Library Management System

Almat — Sun, 31 Mar 2024 08:33:04 +0000

This article delves into the application of SOLID principles in Swift development through the creation of a library catalog. Exploring each principle—Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion—readers will grasp how to design flexible and scalable Swift code. Through practical examples, this piece illuminates the importance and implementation of SOLID principles for crafting robust software solutions in Swift.

1. Single Responsibility

The Single Responsibility Principle states that a class should be responsible for performing only one task. When a class takes on multiple responsibilities, it becomes more complex, making maintenance difficult and increasing the likelihood of errors.

In the following example, the LibraryManager class is tightly coupled as it assumes the responsibilities of managing both books and users within a single entity.

class LibraryManager {
    func addBook(_ book: Book) {
        // Add book to the library
    }

    func removeBook(_ book: Book) {
        // Remove book from the library
    }

    func registerUser(_ user: User) {
        // Register user
    }

    func deleteUser(_ user: User) {
        // Delete user
    }
}

Issue with Initial Design: Combining user and book management into one class can result in complexities. Modifying one function could unintentionally affect the other, potentially introducing errors.

Alternate SR Approach: Divide the responsibilities by creating separate entities: BookManager to handle book-related tasks exclusively, and UserManager to manage operations related solely to users.

class BookManager {
    func addBook(_ book: Book) {
        // Add book implementation
    }

    func removeBook(_ book: Book) {
        // Remove book implementation
    }
}

class UserManager {
    func registerUser(_ user: User) {
        // Register user implementation
    }

    func deleteUser(_ user: User) {
        // Delete user implementation
    }
}

Advantages of SR Approach: By separating concerns, this approach enhances clarity regarding responsibilities, facilitating easier comprehension, maintenance, and scalability of the software.

2. Open-Closed Principle (OCP)

The Open/Closed Principle states that software components should allow for extension without requiring modification to existing code. This principle enables the addition of new features without altering the current implementation, thereby preserving the stability of the system and minimizing the potential for introducing errors.

In the coupled example of a Library Management System, a single class called LibraryItem combines attributes and functionalities intended for both books and magazines, resulting in a mixture of characteristics specific to each type.

class LibraryItem {
    var title: String = ""
    var isbn: String = ""
    var author: String? // Specific to books
    var editor: String? // Specific to magazines
}

Issue with Initial Design: The class's rigid design makes it difficult to incorporate new item types. For example, adding a DVD would demand modifications to the class, posing a risk to existing functionalities.

Alternate OCP Approach: To mitigate this issue, employ an abstract LibraryItem class and create specific subclasses like Book and Magazine. This approach facilitates the introduction of new item types without the need to alter the existing code, ensuring flexibility and reducing the likelihood of unintended issues.

class LibraryItem {
    var title: String = ""
    var isbn: String = ""
}

class Book: LibraryItem {
    var author: String = ""
}

class Magazine: LibraryItem {
    var editor: String = ""
}

Advantages of OCP Approach: This hierarchical structure facilitates seamless incorporation of new item types, safeguarding the fundamental LibraryItem class from disruption.

3. Liskov Substitution Principle (LSP)

Subtypes should seamlessly substitute their base types, extending the functionality of the base class while preserving its expected behavior. This principle guarantees that any derived class can be used interchangeably with its base class without causing unexpected outcomes.

In the coupled example of a Library Management System, the DigitalBook class, despite being a subclass, introduces functionalities that are not aligned with those of the parent Book class.

class Book {
    func displayDetails() {
        // Display details implementation
    }
}

class DigitalBook: Book {
    func displayDetails() {
        // New behavior implementation
    }

    func download() {
        // Download implementation
    }
}

Issue with Initial Approach: Introducing the download method in the DigitalBook class could lead to unforeseen outcomes when DigitalBook instances are utilized in contexts that anticipate a standard Book.

Alternate LSP Approach: Guarantee that DigitalBook expands upon the behavior of Book while adhering to the expected functionalities of the base class.

class Book {
    func displayDetails() {
        // Display details implementation
    }
}

class DigitalBook: Book {
    override func displayDetails() {
        // Consistent behavior with parent class
    }
}

Advantages LSP Approach: This design upholds consistency across the system and simplifies the integration of new subclasses without disrupting existing functionality.

4.Interface Segregation Principle (ISP)

The Interface Segregation Principle suggests that interfaces should be concise, containing only the methods necessary for each implementing class. This prevents classes from becoming overly complex and reduces the chances of implementing unnecessary methods.

In a coupled Library Management System example, an interface named LibraryOperations attempts to combine various library operations, regardless of whether they are applicable to all library items.

protocol LibraryOperations {
    func borrow()
    func returnItem()
    func searchCatalog()
    func payFines()
}

Issue with Initial Approach: The bundled LibraryOperations interface includes methods that may not be applicable to all library items. For example, digital items may not support traditional borrowing, rendering the borrow and returnItem methods irrelevant.

Alternate ISP Approach: Address this by dividing the LibraryOperations interface into more specialized interfaces, such as Borrowable, Searchable, and FineManagement. This approach ensures that each interface pertains to specific functionalities, allowing for more flexibility and precise implementation.

protocol Borrowable {
    func borrow()
    func returnItem()
}

protocol Searchable {
    func searchCatalog()
}

protocol FineManagement {
    func payFines()
}

Advantages ISP Approach:
Specialized interfaces enable classes to implement only the methods that align with their behavior, promoting a cleaner and modular system design. This approach enhances code clarity and maintainability by ensuring that each class adheres to its specific responsibilities without unnecessary method implementations.

5. Dependency Inversion Principle (DIP)

The Dependency Inversion Principle dictates that high-level modules should not rely on low-level modules. Instead, both should depend on abstractions, such as interfaces or abstract classes. This principle fosters the creation of flexible systems by promoting decoupling and adaptability to changes.

In a coupled Library Management System example, the NotificationService is tightly coupled with the EmailService, which restricts flexibility when adapting to changes in notification mechanisms.

class NotificationService {
    var emailService: EmailService

    func sendOverdueNotification(user: User) {
        emailService.sendEmail(to: user.email, message: "Overdue Notification")
    }
}

Issue with Initial Approach: The direct reliance on EmailService creates inflexibility. If there's a need to switch notification mechanisms (e.g., to SMS or push notifications), modifications to the NotificationService class become necessary.

Alternate DIP Approach: Address this by introducing an abstraction, such as a Notifier protocol, and ensuring that NotificationService depends on this abstraction. This enables seamless substitution of various notification mechanisms without altering the NotificationService class.

protocol Notifier {
    func sendNotification(contact: String, message: String)
}

class EmailNotifier: Notifier {
    func sendNotification(contact: String, message: String) {
        // Email notification implementation
    }
}

class SMSNotifier: Notifier {
    func sendNotification(contact: String, message: String) {
        // SMS notification implementation
    }
}

class NotificationService {
    var notifier: Notifier

    func sendOverdueNotification(user: User) {
        notifier.sendNotification(contact: user.contact, message: "Overdue Notification")
    }
}

Advantages of DIP Approach: This design detaches the notification logic from the particular notification method, enhancing the system's adaptability and scalability. Modifying or introducing new notification methods becomes simple without affecting the core notification logic.

Conclusion: In summary, the SOLID principles provide essential guidelines for writing clean, maintainable, and scalable code. By following these principles, developers can enhance code quality, facilitate collaboration, and build software systems that are robust and adaptable to change. Embracing SOLID is key to creating resilient and efficient software solutions in today's dynamic technological landscape.

Credit for image: Dev Genius, medium.com

Beyond the Hype: Real-world Insights into AI/ML Integration Across Industries

Almat — Sun, 03 Mar 2024 16:15:58 +0000

We're witnessing a significant paradigm shift with the pervasive integration of AI into various aspects of our lives. Examples like Netflix's recommendation systems, ChatGPT and other chatbots, generative art transforming text into images or videos, and chatbots impersonating customer service agents online are becoming increasingly prevalent, reshaping our day-to-day experiences. Many leading companies across diverse industries are capitalizing on these advancements, recognizing them as the new engines for value creation.

While AI adoption was relatively low in previous years due to limitations in technology and supporting infrastructure, the landscape has evolved dramatically. Today, we're observing a surge in adoption rates. According to Forrester's Data and Analytics Survey (2022), 73% of data and analytics decision-makers are actively implementing AI technologies, with 74% reporting positive impacts within their organizations. This trend spans various sectors, including healthcare, finance, transportation, manufacturing, marketing, education, and retail.

We're currently at a pivotal moment in history where AI is poised to fundamentally transform company operations and drive organizational evolution. Those who swiftly embrace this change stand to gain a competitive advantage over their peers. Given AI's vast potential, its rapid adoption comes as no surprise.

To delve deeper into the current and future landscape of AI adoption, this article seeks to offer a comprehensive overview. Aimed to explore the current state of AI adoption, elucidate its benefits and challenges, and provide insights into future trends and predictions surrounding AI integration.

AI is the big one. I don't think Web3 was that big or that metaverse stuff alone was revolutionary but AI is quite revolutionary
-Bill Gates

Which Industries Currently Utilize AI the most?

Companies that use AI are motivated by three factors: the ability to cut expenses, develop faster, and grow profitability. However, each industry’s approach to AI applications, as well as its problems and outcomes, may differ.

Also we can see that businesses that are advanced with AI (“Leaders”) are pioneering widespread adoption of AI in comparison to other companies in the market

AI Adoption In Practice By Categories

Younger generations tend to adopt AI technology in their professional life easier and faster

Current availability of AI technology

At present, AI is predominantly integrated at the feature level rather than at the infrastructure level. This means that AI technologies are primarily utilized to enhance existing products and services by introducing new functionalities like voice or image recognition. These features are developed on top of existing infrastructure and leverage AI algorithms to execute specific tasks. While there have been endeavors to embed AI more profoundly into the infrastructure level, such as through edge computing, the bulk of AI usage remains concentrated at the feature level.

Biggest Challenges when Adopting AI

Fragmented Technology Stack: No standard for deploying AI systems. The AI community has not converged yet on formats and interfaces across the AI/ML stack

Misguided Strategy: Performance cannot be guaranteed on an ongoing basis. Lack of clear definitions of business goals and inflated expectations

Evolving AI Regulation: The technology environment is rapidly changing. Lack of GRC (government, risk & compliance) standards

AI Methodology: The definition of AI's proven playbooks, including designs, best practices, and technology pipelines.

AI-Business Alignment: Clear definitions of KPIs and KRis which are subject to ongoing assessment, evaluation and re-design.

New Business Requirements: Identifying new requirements and insights as they evolve. Embrace uncertainty

Current Regulation Highlights

What’s Hindering AI Adoption?

How to Mitigate Potential Risks?

Identify unique vulnerabilities: Determine where bias could creep into your datasets and algorithms and where it could cause major damage

Control your data: Pay special attention to issues in historical data and data acquired from third parties. This includes biased correlations between variables.

Keep governance up to speed: Governance should be continuous and enterprise-wide. Set frameworks, toolkits and controls to help spot problems before they may proliferate.

Validate independently and continuously: You can use wither an internal independent team or a third party to analyze your algorithms for fairness.

Diversify your team: Building diverse teams helps reduce the potential risk of bias falling through the cracks. People from different racial and gender identities and economic backgrounds will notice different biases.

Near-Future Value Capture Opportunities

Decision Making:Computer-based processes that uses AI to mimic and simulate real-world scenarios or system, allowing for the testing and optimization of various strategies, outcomes, and performances.

Simulation: The ability to process significant amount of historical data and produce and analyze future optional decision trees scenarios. Adoption rates are significant when it comes to areas of technology, operations and maintenance, and also CX and strategy.

Data Analysis: AI nowadays can help automate and streamline the data analysis process (e.g. cleansing) as well as significantly improve predictive models and analysis of unstructured data.

Where Will Adoption Increase Most?

Key Takeaways & Conclusion

Ethics & Governance

Algorithmic and data biases will likely be regulated in the near future and will create uncertainty regarding usage of certain AI models

Increased AI models regulations will force change in many companies’ systems and infrastructure

Applications of AI will not be fully implemented into enterprises until business cases and expected ROI will be fully understood

Industries with more consumer regulatory pressure will have lower AI adoption rates

AI governance will likely join cybersecurity as a board-level topic

Trends

AI is recession-resilient and continued AI investments will continue in 2023, particularly among business impacted by economic and supply chain disruptions

In 2023 low/no code AI tools will be more involved in the software development lifecycle

Image editing is going to be changed dramatically

Workforce

In the short term - AI will free up employees to focus on value-add tasks and will improve job satisfaction

AI applications still require human supervision and therefore it is unlikely that we will see dramatic HR changes in the near future, except certain functions

Management

Management’s decision making processes will not change significantly in the short term

25% of tech executives (e.g. CTO/CIO) will report to board/committee on AI governance

Adoption

AI adoption will probably still remain low in 2023-2024

10% of Fortune 500 enterprises will generate content with AI tools in 2023-2024

Company’s ability to completely change its processes will be hard, and therefore we expect adoption to be slow. It will be likely to be easier for companies to integrate AI into their core processes if they can spin off certain functions or form brand new business units

AI models still considered as black box for non-technological employees which will require training and upskilling

AI infrastructure challenges will surpass data associated issues as the biggest challenge for scaling AI/ML

AI tools tend to be highly accurate, but they are definitely not perfect and can make bizarre mistakes. Maintaining human oversight during the implementation and afterwards is crucial to ensuring quality, both for model training and for the final correction of the output in downstream processes. Leaders must stay vigilant about the potential risks and cognizant of the need for proper training and corporate governance. And we ordinary people need to actively participate in the discussion and determine our future ourselves.

Sources:

Forrester Predictions 2023: Artificial Intelligence, run:ao 2023 state of AI Infrastructure
“Understanding algorithmic bias and how to build trust in AI” - PwC US
The state of Machine Learning at the end of 2022 (cnvrg.io)
IBM Global AI Adoption index 2022
World Economic Forum.
Gartner