Migrate software design architecture content

migrate_content.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+
+import json
+import os
+import sys
+
+def migrate_content():
+    """
+    Migrate content from content folder to content-migrated folder using mapping file
+    """
+    
+    # Read mapping file
+    mapping_file = 'migration-mapping.json'
+    content_dir = 'content'
+    migrated_dir = 'content-migrated'
+    
+    try:
+        with open(mapping_file, 'r') as f:
+            mapping = json.load(f)
+    except FileNotFoundError:
+        print(f"Error: {mapping_file} not found")
+        return False
+    except json.JSONDecodeError:
+        print(f"Error: Invalid JSON in {mapping_file}")
+        return False
+    
+    migrated_count = 0
+    skipped_count = 0
+    error_count = 0
+    
+    print(f"Starting migration of {len(mapping)} files...")
+    
+    for source_path, target_id in mapping.items():
+        # Determine source file path
+        if ':' in source_path:
+            # Nested path like "clean-code-principles:be-consistent"
+            parts = source_path.split(':')
+            source_file = os.path.join(content_dir, *parts[:-1], f"{parts[-1]}.md")
+        else:
+            # Top level path like "clean-code-principles"
+            source_file = os.path.join(content_dir, source_path, 'index.md')
+        
+        # Determine target file path
+        target_filename = f"{source_path.split(':')[-1]}@{target_id}.md"
+        target_file = os.path.join(migrated_dir, target_filename)
+        
+        # Check if target file is empty (needs migration)
+        if os.path.exists(target_file) and os.path.getsize(target_file) > 0:
+            print(f"⏭️  Skipped: {target_filename} (already migrated)")
+            skipped_count += 1
+            continue
+        
+        # Check if source file exists
+        if not os.path.exists(source_file):
+            print(f"❌ Error: Source file not found: {source_file}")
+            error_count += 1
+            continue
+        
+        try:
+            # Read source content
+            with open(source_file, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            if not content.strip():
+                print(f"⚠️  Warning: Source file is empty: {source_file}")
+                continue
+            
+            # Write to target file
+            with open(target_file, 'w', encoding='utf-8') as f:
+                f.write(content)
+            
+            print(f"✅ Migrated: {source_path} -> {target_filename}")
+            migrated_count += 1
+            
+        except Exception as e:
+            print(f"❌ Error migrating {source_path}: {str(e)}")
+            error_count += 1
+    
+    print(f"\n📊 Migration Summary:")
+    print(f"   ✅ Migrated: {migrated_count}")
+    print(f"   ⏭️  Skipped: {skipped_count}")
+    print(f"   ❌ Errors: {error_count}")
+    print(f"   📁 Total: {len(mapping)}")
+    
+    return error_count == 0
+
+if __name__ == "__main__":
+    success = migrate_content()
+    sys.exit(0 if success else 1) 

src/data/roadmaps/software-design-architecture/content/architectural-styles@En_hvwRvY6k_itsNCQBYE.md

@@ -16,4 +16,4 @@ Learn more from the following links:
 
 - [@article@What is Software Architecture & Styles?](https://study.com/academy/lesson/software-architecture-styles-patterns-components.html)
 - [@video@Types of Architectural Styles in Software Engineering](https://www.youtube.com/watch?v=2Pp0BcXN9YY)
-- [@video@10 Architecture Patterns Used In Enterprise Software Development Today](https://www.youtube.com/watch?v=brt3ao8bvqy)
+- [@video@10 Architecture Patterns Used In Enterprise Software Development Today](https://www.youtube.com/watch?v=brt3ao8bvqy)

src/data/roadmaps/software-design-architecture/content/concrete-classes@hd6GJ-H4p9I4aaiRTni57.md

@@ -3,6 +3,3 @@
 A concrete class is a class in object-oriented programming (OOP) that can be instantiated, meaning objects can be created from it. A concrete class is a class that provides an implementation for all of the abstract methods declared in its parent class, if it inherits from an abstract class. A concrete class can also be a class that does not inherit from an abstract class, in that case it can have implementation for all of its methods.
 
 Concrete classes are used to provide specific implementation details for a group of related classes that inherit from a common abstract class. They are also used to define unique behavior for a specific class. A concrete class can have its own methods and variables, and can also override the methods of its parent class.
-
-Learn more from the following resources:
-

src/data/roadmaps/software-design-architecture/content/functional-programming@YswaOqZNYcmDwly2IXrTT.md

@@ -0,0 +1,8 @@
+# Functional Programming
+
+Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data. It emphasizes the use of functions to solve problems, often using higher-order functions, immutability, and recursion. Instead of modifying data, functional programming creates new data structures.
+
+Learn more from the following links:
+
+- [@article@What is Functional Programming?](https://medium.com/javascript-scene/master-the-javascript-interview-what-is-functional-programming-7f218c68b3a0)
+- [@feed@Explore top posts about Functional Programming](https://app.daily.dev/tags/functional-programming?ref=roadmapsh)

src/data/roadmaps/software-design-architecture/content/index.md

@@ -1,18 +0,0 @@
-# Software Design Architecture
-
-Software design architecture is the process of defining the overall structure and organization of a software system. It involves determining the components, interfaces, and relationships between those components that are needed to meet the requirements of the system. The architecture of a software system sets the foundation for the design and implementation of the system, and it plays a crucial role in determining the quality and maintainability of the final product.
-
-There are several different architecture styles and patterns that can be used to design a software system, including:
-
-- Layered architecture
-- Microservices architecture
-- Event-driven architecture
-- Service-oriented architecture (SOA)
-- Domain-Driven Design (DDD)
-
-Each architecture pattern or style has its own set of advantages and disadvantages, and the choice of architecture will depend on the specific requirements of the system and the constraints of the project.
-
-Learn more from the following links:
-
-- [@article@Software Architecture & Design Introduction](https://www.tutorialspoint.com/software_architecture_design/introduction.htm)
-- [@article@Overview of Software architecture](https://en.wikipedia.org/wiki/Software_architecture)

src/data/roadmaps/software-design-architecture/content/object-oriented-programming/paradigm-features/index.md

@@ -1,17 +0,0 @@
-# Paradigm Features
-
-Object-oriented programming (OOP) is a programming paradigm that is based on the concept of "objects," which are instances of a class. OOP has several key features that distinguish it from other programming paradigms:
-
-- Encapsulation
-- Inheritance
-- Polymorphism
-- Abstraction
-- Classes
-- Objects
-- Interfaces
-- Dynamic binding
-- Message passing
-
-Learn more from the following resources:
-
-- [@article@Overview of Object-Oriented Paradigm](https://www.tutorialspoint.com/software_architecture_design/object_oriented_paradigm.htm)

src/data/roadmaps/software-design-architecture/content/object-oriented-programming/primary-principles/index.md

@@ -1,15 +0,0 @@
-# Primary Principles
-
-There are several primary principles that are considered fundamental to object-oriented programming (OOP). These principles include:
-
-- Encapsulation: The practice of wrapping an object's internal data and behavior within a defined interface, and hiding the implementation details from the outside world.
-- Inheritance: The ability of a new class to inherit the properties and methods of an existing class, enabling code reuse and allowing for a hierarchical organization of classes.
-- Polymorphism: The ability of objects of different classes to be treated as objects of a common parent class, allowing code to be written in a more general and flexible way.
-- Abstraction: The process of hiding the implementation details of an object and exposing only its essential features, reducing complexity and improving the modularity of the code.
-- Classes: The blueprint for creating objects, which have both data (attributes) and behavior (methods).
-- Objects: Instances of a class, which have their own unique state and behavior.
-
-Learn more from the following links:
-
-- [@article@Principles of Object-Oriented Programming](https://khalilstemmler.com/articles/object-oriented/programming/4-principles/)
-- [@article@What are four basic principles of OOP?](https://medium.com/@cancerian0684/what-are-four-basic-principles-of-object-oriented-programming-645af8b43727)

src/data/roadmaps/software-design-architecture/content/object-oriented-programming@VZrERRRYhmqDx4slnZtdc.md

@@ -0,0 +1,9 @@
+# Object Oriented Programming
+
+Object-oriented programming (OOP) is a programming paradigm that uses objects and classes to structure and organize code. In OOP, an object is an instance of a class, which is a template that defines the properties and behaviors of the object. OOP is based on the principles of encapsulation, inheritance, and polymorphism.
+
+Learn more from the following links:
+
+- [@article@What is Object Oriented Programming?](https://www.freecodecamp.org/news/what-is-object-oriented-programming/)
+- [@article@OOP introduction](https://www.geeksforgeeks.org/introduction-of-object-oriented-programming/)
+- [@feed@Explore top posts about OOP](https://app.daily.dev/tags/oop?ref=roadmapsh)

src/data/roadmaps/software-design-architecture/content/programming-paradigms/functional-programming.md

@@ -1,10 +0,0 @@
-# Functional Programming
-
-Functional programming is a programming paradigm that emphasizes the use of pure functions and immutable data. It is a way of writing computer programs that emphasizes the use of functions and mathematical concepts, such as recursion, rather than using objects and classes like in object-oriented programming. In functional programming, functions are first-class citizens, which means they can be passed as arguments to other functions and returned as values.
-
-Functional programming encourages immutability, which means that once a variable is assigned a value, it cannot be changed. This can simplify code, as it eliminates the need for state management and the bugs that can come with it.
-
-Learn more from the following links:
-
-- [@video@Tutorial - Functional Programming?](https://www.youtube.com/watch?v=dAPL7MQGjyM)
-- [@feed@Explore top posts about Functional Programming](https://app.daily.dev/tags/functional-programming?ref=roadmapsh)

src/data/roadmaps/software-design-architecture/content/programming-paradigms/object-oriented-programming.md

@@ -1,11 +0,0 @@
-# Object Oriented Programming
-
-Object-oriented programming (OOP) is a programming paradigm that is based on the concept of "objects", which are instances of classes. OOP is a way of organizing and structuring code that is based on the principles of encapsulation, inheritance, and polymorphism.
-
-Encapsulation refers to the idea that an object's internal state should be hidden and accessible only through its methods. This allows the object to control how its data is used and prevents external code from making invalid changes to the object's state.
-
-Learn more from the following links:
-
-- [@video@What is Object Oriented Programming?](https://www.youtube.com/watch?v=pTB0EiLXUC8)
-- [@article@Overview of Object-Oriented Programming (OOP)](https://en.wikipedia.org/wiki/Object-oriented_programming)
-- [@feed@Explore top posts about General Programming](https://app.daily.dev/tags/general-programming?ref=roadmapsh)

src/data/roadmaps/software-design-architecture/content/programming-paradigms/structured-programming.md

@@ -1,7 +0,0 @@
-# Structured Programming
-
-Structured programming is a programming paradigm that emphasizes the use of structured control flow constructs, such as loops and conditional statements, to organize code into logical, easy-to-understand blocks. It is a way of writing computer programs that emphasizes the use of procedures and functions, as well as data structures, to organize code and make it easier to understand, debug, and maintain. The main idea behind structured programming is to break down a program into smaller, manageable pieces that can be easily understood, tested, and modified. This approach is opposed to the use of "goto" statements, which are considered to be unstructured and can lead to difficult-to-read and difficult-to-maintain code.
-
-Learn more from the following links:
-
-- [@article@Overview of Structured programming](https://www.techtarget.com/searchsoftwarequality/definition/structured-programming-modular-programming)

src/data/roadmaps/software-design-architecture/content/structured-programming@VhSEH_RoWFt1z2lial7xZ.md

@@ -0,0 +1,8 @@
+# Structured Programming
+
+Structured programming is a programming paradigm that emphasizes the use of well-structured control flow constructs such as loops, conditionals, and subroutines. It was developed in the 1960s and 1970s as a reaction to the "spaghetti code" produced by the widespread use of goto statements.
+
+Learn more from the following links:
+
+- [@article@Structured Programming Wikipedia](https://en.wikipedia.org/wiki/Structured_programming)
+- [@feed@Explore top posts about General Programming](https://app.daily.dev/tags/general-programming?ref=roadmapsh)

src/data/roadmaps/software-design-architecture/content/yagni@eEO-WeNIyjErBE53n8JsD.md

@@ -6,5 +6,5 @@ The YAGNI principle is closely related to the Single Responsibility Principle (S
 
 Learn more from the following resources:
 
-- [@article@YAGNI (You Aren’t Gonna Need It) Principle Helps in Efficiency](https://builtin.com/software-engineering-perspectives/yagni)
+- [@article@YAGNI (You Aren't Gonna Need It) Principle Helps in Efficiency](https://builtin.com/software-engineering-perspectives/yagni)
 - [@video@What is YAGNI coding rule, and Why it helps?](https://www.youtube.com/watch?v=2vys1q1dKc4)

src/data/roadmaps/software-design-architecture/migration-mapping.json

@@ -0,0 +1,86 @@
+{
+  "clean-code-principles": "TJZgsxpfOmltUUChMzlEM",
+  "programming-paradigms": "RgYq3YOJhPGSf5in1Rcdp",
+  "object-oriented-programming": "qZQDOe2MHBh8wNcmvkLQm",
+  "software-design-principles": "p96fNXv0Z4rEEXJR9hAYX",
+  "design-patterns": "gyQw885dvupmkohzJPg3a",
+  "architectural-principles": "XBCxWdpvQyK2iIG2eEA1K",
+  "architectural-styles": "En_hvwRvY6k_itsNCQBYE",
+  "architectural-patterns": "jq916t7svaMw5sFOcqZSi",
+  "enterprise-patterns": "WrzsvLgo7cf2KjvJhtJEC",
+  "clean-code-principles:be-consistent": "2SOZvuEcy8Cy8ymN7x4L-",
+  "clean-code-principles:meaningful-names": "6Cd1BbGsmPJs_5jKhumyV",
+  "clean-code-principles:indentation-and-code-style": "81WOL1nxb56ZbAOvxJ7NK",
+  "clean-code-principles:keep-it-small": "XEwC6Fyf2DNNHQsoGTrQj",
+  "clean-code-principles:pure-functions": "5S5A5wCJUCNPLlHJ5fRjU",
+  "clean-code-principles:minimize-cyclomatic-complexity": "qZzl0hAD2LkShsPql1IlZ",
+  "clean-code-principles:avoid-passing-nulls-booleans": "yyKvmutbxu3iVHTuqr5q4",
+  "clean-code-principles:keep-framework-code-distant": "OoCCy-3W5y7bUcKz_iyBw",
+  "clean-code-principles:use-correct-constructs": "S1m7ty7Qrzu1rr4Jl-WgM",
+  "clean-code-principles:keep-tests-independent": "mzt7fvx6ab3tmG1R1NcLO",
+  "clean-code-principles:use-meaningful-names": "JKK6bli3P_cqJ128wPnot",
+  "clean-code-principles:code-by-actor": "kp86Vc3uue3IxTN9B9p59",
+  "clean-code-principles:command-query-separation": "tLbckKmfVxgn59j_dlh8b",
+  "clean-code-principles:avoid-hasty-abstractions": "9naCfoHF1LW1OEsVZGi8v",
+  "programming-paradigms:functional-programming": "YswaOqZNYcmDwly2IXrTT",
+  "programming-paradigms:object-oriented-programming": "VZrERRRYhmqDx4slnZtdc",
+  "object-oriented-programming:model-driven-design": "0VO_-1g-TS29y0Ji2yCjc",
+  "object-oriented-programming:model-driven-design:domain-models": "I25ghe8xYWpZ-9pRcHfOh",
+  "object-oriented-programming:model-driven-design:anemic-models": "nVaoI4IDPVEsdtFcjGNRw",
+  "object-oriented-programming:model-driven-design:layered-architectures": "HN160YgryBBtVGjnWxNie",
+  "object-oriented-programming:model-driven-design:domain-language": "kWNQd3paQrhMHMJzM35w8",
+  "object-oriented-programming:model-driven-design:class-invariants": "c6n-wOHylTbzpxqgoXtdw",
+  "object-oriented-programming:paradigm-features:abstract-classes": "RMkEE7c0jdVFqZ4fmjL6Y",
+  "object-oriented-programming:paradigm-features:concrete-classes": "hd6GJ-H4p9I4aaiRTni57",
+  "object-oriented-programming:paradigm-features:scope-visibility": "b-YIbw-r-nESVt_PUFQeq",
+  "object-oriented-programming:paradigm-features:interfaces": "SrcPhS4F7aT80qNjbv54f",
+  "object-oriented-programming:primary-principles:inheritance": "Dj36yLBShoazj7SAw6a_A",
+  "object-oriented-programming:primary-principles:polymorphism": "4DVW4teisMz8-58XttMGt",
+  "object-oriented-programming:primary-principles:abstraction": "VA8FMrhF4non9x-J3urY8",
+  "object-oriented-programming:primary-principles:encapsulation": "GJxfVjhiLuuc36hatx9dP",
+  "software-design-principles:composition-over-inheritance": "Izno7xX7wDvwPEg7f_d1Y",
+  "software-design-principles:encapsulate-what-varies": "DlefJ9JuJ1LdQYC4WSx6y",
+  "software-design-principles:program-against-abstractions": "UZeY36dABmULhsHPhlzn_",
+  "software-design-principles:hollywood-principle": "WzUhKlmFB9alTlAyV-MWJ",
+  "software-design-principles:solid": "3XckqZA--knUb8IYKOeVy",
+  "software-design-principles:dry": "ltBnVWZ3UMAuUvDkU6o4P",
+  "software-design-principles:yagni": "eEO-WeNIyjErBE53n8JsD",
+  "design-patterns:gof-design-patterns": "hlHl00ELlK9YdnzHDGnEW",
+  "design-patterns:posa-patterns": "6VoDGFOPHj5p_gvaZ8kTt",
+  "architectural-principles:component-principles": "8Bm0sRhUg6wZtnvtTmpgY",
+  "architectural-principles:policy-vs-detail": "b_PvjjL2ZpEKETa5_bd0v",
+  "architectural-principles:coupling-and-cohesion": "TXus3R5vVQDBeBag6B5qs",
+  "architectural-principles:boundaries": "-Kw8hJhgQH2qInUFj2TUe",
+  "architectural-styles:messaging": "j9j45Auf60kIskyEMUGE3",
+  "architectural-styles:distributed": "3V74lLPlcOXFB-QRTUA5j",
+  "architectural-styles:messaging:event-driven": "KtzcJBb6-EcIoXnwYvE7a",
+  "architectural-styles:messaging:publish-subscribe": "SX4vOVJY9slOXGwX_q1au",
+  "architectural-styles:distributed:client-server": "ZGIMUaNfBwE5b6O1yexSz",
+  "architectural-styles:distributed:peer-to-peer": "Cf9Z2wxBcbnNg_q9PA6xA",
+  "architectural-styles:structural": "86Jw9kMBD7YP5nTV5jTz-",
+  "architectural-styles:structural:component-based": "a0geFJWl-vi3mYytTjYdb",
+  "architectural-styles:structural:monolithic": "xYPR_X1KhBwdpqYzNJiuT",
+  "architectural-styles:structural:layered": "IELEJcKYdZ6VN-UIq-Wln",
+  "architectural-patterns:soa": "FysFru2FJN4d4gj11gv--",
+  "architectural-patterns:cqrs": "IU86cGkLPMXUJKvTBywPu",
+  "architectural-patterns:domain-driven-design": "CD20zA6k9FxUpMgHnNYRJ",
+  "architectural-patterns:model-view-controller": "-arChRC9zG2DBmuSTHW0J",
+  "architectural-patterns:microservices": "eJsCCURZAURCKnOK-XeQe",
+  "architectural-patterns:blackboard-pattern": "Kk7u2B67Fdg2sU8E_PGqr",
+  "architectural-patterns:microkernel": "r-Yeca-gpdFM8iq7f0lYQ",
+  "architectural-patterns:serverless-architecture": "5WSvAA3h3lmelL53UJSMy",
+  "architectural-patterns:message-queues-streams": "GAs6NHBkUgxan3hyPvVs7",
+  "architectural-patterns:event-sourcing": "K8X_-bsiy7gboInPzbiEb",
+  "enterprise-patterns:dtos": "y_Qj7KITSB8aUWHwiZ2It",
+  "enterprise-patterns:identity-maps": "tb0X1HtuiGwz7YhQ5xPsV",
+  "enterprise-patterns:use-cases": "gQ7Xj8tsl6IlCcyJgSz46",
+  "enterprise-patterns:repositories": "8y0ot5sbplUIUyXe9gvc8",
+  "enterprise-patterns:mappers": "ndUTgl2YBzOdu1MQKJocu",
+  "enterprise-patterns:transaction-script": "tyReIY4iO8kmyc_LPafp1",
+  "enterprise-patterns:commands-queries": "j_SUD3SxpKYZstN9LSP82",
+  "enterprise-patterns:value-objects": "Ks6njbfxOHiZ_TrJDnVtk",
+  "enterprise-patterns:domain-models": "NpSfbzYtGebmfrifkKsUf",
+  "enterprise-patterns:entities": "VnW_7dl5G0IFL9W3YF_W3",
+  "enterprise-patterns:orms": "SYYulHfDceIyDkDT5fcqj",
+  "programming-paradigms:structured-programming": "VhSEH_RoWFt1z2lial7xZ"
+}

src/data/roadmaps/software-design-architecture/software-design-architecture.md

@@ -6,11 +6,12 @@ briefTitle: 'Design and Architecture'
 briefDescription: 'Guide to learn software design and architecture'
 title: 'Software Design and Architecture'
 description: 'Step by step guide to learn software design and architecture'
+renderer: 'editor'
 isNew: false
 hasTopics: true
 dimensions:
   width: 968
-  height: 1764.66
+  height: 2150
 schema:
   headline: 'Software Design and Architecture Roadmap'
   description: 'Learn Software Design and Architecture with this interactive step by step guide in 2025. We also have resources and short descriptions attached to the roadmap items so you can get everything you want to learn in one place.'