Software Development Basics

Software Architecture Fundamentals

Layered Architecture

Organizes code into horizontal layers with specific responsibilities

Presentation Layer

Business Logic Layer

Data Access Layer

Database Layer

Microservices Architecture

Breaks applications into small, independent services

User Service

Order Service

Payment Service

Notification Service

MVC Pattern

Separates application logic into Model, View, and Controller

Model
Data & Logic

View
User Interface

Controller
Input Handler

Architecture Implementation Examples

Layered Architecture in Python

# Presentation Layer
class UserController:
    def __init__(self, user_service):
        self.user_service = user_service

    def create_user(self, user_data):
        try:
            user = self.user_service.create_user(user_data)
            return {"status": "success", "user": user}
        except Exception as e:
            return {"status": "error", "message": str(e)}

# Business Logic Layer
class UserService:
    def __init__(self, user_repository):
        self.user_repository = user_repository

    def create_user(self, user_data):
        if not self._validate_user_data(user_data):
            raise ValueError("Invalid user data")

        # Business logic
        user_data['email'] = user_data['email'].lower()
        return self.user_repository.save(user_data)

    def _validate_user_data(self, data):
        return 'email' in data and '@' in data['email']

# Data Access Layer
class UserRepository:
    def __init__(self, database):
        self.database = database

    def save(self, user_data):
        query = "INSERT INTO users (email, name) VALUES (?, ?)"
        return self.database.execute(query, user_data['email'], user_data['name'])

    def find_by_email(self, email):
        query = "SELECT * FROM users WHERE email = ?"
        return self.database.execute(query, email)

Layered Architecture in Go

package main

import (
    "errors"
    "strings"
)

// Domain Layer
type User struct {
    ID    int    `json:"id"`
    Email string `json:"email"`
    Name  string `json:"name"`
}

// Data Access Layer
type UserRepository interface {
    Save(user User) (*User, error)
    FindByEmail(email string) (*User, error)
}

type userRepository struct {
    db Database
}

func (r *userRepository) Save(user User) (*User, error) {
    query := "INSERT INTO users (email, name) VALUES ($1, $2) RETURNING id"
    err := r.db.QueryRow(query, user.Email, user.Name).Scan(&user.ID)
    return &user, err
}

// Business Logic Layer
type UserService struct {
    repo UserRepository
}

func (s *UserService) CreateUser(userData User) (*User, error) {
    if err := s.validateUserData(userData); err != nil {
        return nil, err
    }

    // Business logic
    userData.Email = strings.ToLower(userData.Email)
    return s.repo.Save(userData)
}

func (s *UserService) validateUserData(data User) error {
    if data.Email == "" || !strings.Contains(data.Email, "@") {
        return errors.New("invalid email")
    }
    return nil
}

// Presentation Layer
type UserController struct {
    service *UserService
}

func (c *UserController) CreateUser(userData User) map[string]interface{} {
    user, err := c.service.CreateUser(userData)
    if err != nil {
        return map[string]interface{}{
            "status": "error",
            "message": err.Error(),
        }
    }

    return map[string]interface{}{
        "status": "success",
        "user":   user,
    }
}

SOLID Principles

S - Single Responsibility Principle

A class should have only one reason to change

❌ User class handling data + email + logging

✅ User + EmailService + Logger

O - Open/Closed Principle

Open for extension, closed for modification

❌ Modifying existing code for new features

✅ Extending through interfaces/inheritance

L - Liskov Substitution Principle

Objects should be replaceable with instances of their subtypes

❌ Square breaking Rectangle behavior

✅ Proper inheritance hierarchy

I - Interface Segregation Principle

Clients shouldn't depend on interfaces they don't use

❌ Fat interfaces with unused methods

✅ Small, focused interfaces

D - Dependency Inversion Principle

Depend on abstractions, not concretions

❌ Direct dependency on concrete classes

✅ Dependency on interfaces

Single Responsibility Principle Examples

                                ❌ Violating SRP
                                class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email

    def save_to_database(self):
        # Database logic
        pass

    def send_email(self):
        # Email logic
        pass

    def log_activity(self):
        # Logging logic
        pass
                            

                                ✅ Following SRP
                                class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email

class UserRepository:
    def save(self, user):
        # Database logic
        pass

class EmailService:
    def send_email(self, user, message):
        # Email logic
        pass

class Logger:
    def log_activity(self, user, activity):
        # Logging logic
        pass
                            

                                ❌ Violating SRP
                                type User struct {
    Name  string
    Email string
}

func (u *User) SaveToDatabase() error {
    // Database logic
    return nil
}

func (u *User) SendEmail() error {
    // Email logic
    return nil
}

func (u *User) LogActivity() error {
    // Logging logic
    return nil
}
                            

                                ✅ Following SRP
                                type User struct {
    Name  string
    Email string
}

type UserRepository struct{}

func (r *UserRepository) Save(user *User) error {
    // Database logic
    return nil
}

type EmailService struct{}

func (e *EmailService) SendEmail(user *User, message string) error {
    // Email logic
    return nil
}

type Logger struct{}

func (l *Logger) LogActivity(user *User, activity string) error {
    // Logging logic
    return nil
}
                            

Open/Closed Principle Examples

                                ❌ Violating OCP
                                class ShapeCalculator:
    def calculate_area(self, shapes):
        total_area = 0
        for shape in shapes:
            if shape["type"] == "rectangle":
                total_area += shape["width"] * shape["height"]
            elif shape["type"] == "circle":
                total_area += 3.14159 * shape["radius"] ** 2
            # Adding new shape requires modifying this method
        return total_area
                            

                                ✅ Following OCP
                                from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self) -> float:
        pass

class Rectangle(Shape):
    def __init__(self, width: float, height: float):
        self.width = width
        self.height = height

    def area(self) -> float:
        return self.width * self.height

class Circle(Shape):
    def __init__(self, radius: float):
        self.radius = radius

    def area(self) -> float:
        return 3.14159 * self.radius ** 2

class ShapeCalculator:
    def calculate_total_area(self, shapes) -> float:
        return sum(shape.area() for shape in shapes)
                            

                                ❌ Violating OCP
                                type ShapeCalculator struct{}

func (sc *ShapeCalculator) CalculateArea(shapes []ShapeData) float64 {
    totalArea := 0.0
    for _, shape := range shapes {
        switch shape.Type {
        case Rectangle:
            totalArea += shape.Width * shape.Height
        case Circle:
            totalArea += math.Pi * shape.Radius * shape.Radius
        // Adding new shape requires modifying this method
        }
    }
    return totalArea
}
                            

                                ✅ Following OCP
                                type Shape interface {
    Area() float64
}

type Rectangle struct {
    Width  float64
    Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

type ShapeCalculator struct{}

func (sc *ShapeCalculator) CalculateTotalArea(shapes []Shape) float64 {
    totalArea := 0.0
    for _, shape := range shapes {
        totalArea += shape.Area()
    }
    return totalArea
}
                            

Liskov Substitution Principle Examples

                                ❌ Violating LSP
                                class Bird:
    def fly(self):
        print("Flying...")

class Penguin(Bird):
    def fly(self):
        raise Exception("Penguins can't fly!")  # Violates LSP
                            

                                ✅ Following LSP
                                class Bird:
    def move(self):
        print("Moving...")

class FlyingBird(Bird):
    def fly(self):
        print("Flying...")

class SwimmingBird(Bird):
    def swim(self):
        print("Swimming...")

class Eagle(FlyingBird):
    def fly(self):
        print("Eagle soaring high...")

class Penguin(SwimmingBird):
    def swim(self):
        print("Penguin swimming gracefully...")
                            

                                ❌ Violating LSP
                                type Bird interface {
    Fly()
}

type Eagle struct{}

func (e Eagle) Fly() {
    fmt.Println("Eagle flying...")
}

type Penguin struct{}

func (p Penguin) Fly() {
    panic("Penguins can't fly!") // Violates LSP
}
                            

                                ✅ Following LSP
                                type Bird interface {
    Move()
}

type FlyingBird interface {
    Bird
    Fly()
}

type SwimmingBird interface {
    Bird
    Swim()
}

type Eagle struct{}

func (e Eagle) Move() {
    fmt.Println("Eagle moving...")
}

func (e Eagle) Fly() {
    fmt.Println("Eagle soaring high...")
}

type Penguin struct{}

func (p Penguin) Move() {
    fmt.Println("Penguin moving...")
}

func (p Penguin) Swim() {
    fmt.Println("Penguin swimming gracefully...")
}
                            

Interface Segregation Principle Examples

                                ❌ Violating ISP
                                from abc import ABC, abstractmethod

class Worker(ABC):
    @abstractmethod
    def work(self):
        pass

    @abstractmethod
    def eat(self):
        pass

    @abstractmethod
    def sleep(self):
        pass

class RobotWorker(Worker):
    def work(self):
        print("Robot working...")

    def eat(self):
        # Robots don't eat!
        raise NotImplementedError("Robots don't eat")

    def sleep(self):
        # Robots don't sleep!
        raise NotImplementedError("Robots don't sleep")
                            

                                ✅ Following ISP
                                from typing import Protocol

class Workable(Protocol):
    def work(self) -> None:
        ...

class Eatable(Protocol):
    def eat(self) -> None:
        ...

class Sleepable(Protocol):
    def sleep(self) -> None:
        ...

class HumanWorker:
    def work(self):
        print("Human working...")

    def eat(self):
        print("Human eating...")

    def sleep(self):
        print("Human sleeping...")

class RobotWorker:
    def work(self):
        print("Robot working...")
                            

                                ❌ Violating ISP
                                type Worker interface {
    Work()
    Eat()
    Sleep()
}

type RobotWorker struct{}

func (r RobotWorker) Work() {
    fmt.Println("Robot working...")
}

func (r RobotWorker) Eat() {
    panic("Robots don't eat!") // Forced to implement
}

func (r RobotWorker) Sleep() {
    panic("Robots don't sleep!") // Forced to implement
}
                            

                                ✅ Following ISP
                                type Workable interface {
    Work()
}

type Eatable interface {
    Eat()
}

type Sleepable interface {
    Sleep()
}

type HumanWorker struct{}

func (h HumanWorker) Work() {
    fmt.Println("Human working...")
}

func (h HumanWorker) Eat() {
    fmt.Println("Human eating...")
}

func (h HumanWorker) Sleep() {
    fmt.Println("Human sleeping...")
}

type RobotWorker struct{}

func (r RobotWorker) Work() {
    fmt.Println("Robot working...")
}
                            

Dependency Inversion Principle Examples

                                ❌ Violating DIP
                                class MySQLDatabase:
    def save(self, data: str):
        print(f"Saving to MySQL: {data}")

class UserService:
    def __init__(self):
        self.database = MySQLDatabase()  # Direct dependency

    def save_user(self, user_data: str):
        self.database.save(user_data)
                            

                                ✅ Following DIP
                                from abc import ABC, abstractmethod

class Database(ABC):
    @abstractmethod
    def save(self, data: str) -> bool:
        pass

class MySQLDatabase(Database):
    def save(self, data: str) -> bool:
        print(f"Saving to MySQL: {data}")
        return True

class PostgreSQLDatabase(Database):
    def save(self, data: str) -> bool:
        print(f"Saving to PostgreSQL: {data}")
        return True

class UserService:
    def __init__(self, database: Database):
        self.database = database  # Depends on abstraction

    def save_user(self, user_data: str):
        return self.database.save(user_data)
                            

                                ❌ Violating DIP
                                type MySQLDatabase struct{}

func (db *MySQLDatabase) Save(data string) error {
    fmt.Printf("Saving to MySQL: %s\n", data)
    return nil
}

type UserService struct {
    database *MySQLDatabase // Direct dependency on concrete type
}

func NewUserService() *UserService {
    return &UserService{
        database: &MySQLDatabase{}, // Tightly coupled
    }
}
                            

                                ✅ Following DIP
                                type Database interface {
    Save(data string) error
    Find(query string) (map[string]interface{}, error)
}

type MySQLDatabase struct{}

func (db *MySQLDatabase) Save(data string) error {
    fmt.Printf("Saving to MySQL: %s\n", data)
    return nil
}

type UserService struct {
    database Database // Depends on abstraction
}

func NewUserService(database Database) *UserService {
    return &UserService{
        database: database,
    }
}
                            

Design Patterns

Singleton Pattern

Ensures only one instance of a class exists

🏛️ Single Instance

Factory Pattern

Creates objects without specifying exact classes

🏭 Object Factory

Observer Pattern

Notifies multiple objects about state changes

📢 Publisher → Subscribers

Strategy Pattern

Defines family of algorithms and makes them interchangeable

🔄 Interchangeable Algorithms

Singleton Pattern Implementation

class DatabaseConnection:
    _instance = None
    _lock = threading.Lock()

    def __new__(cls):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
                    cls._instance._initialize()
        return cls._instance

    def _initialize(self):
        self.connection = "Database connection established"

    def query(self, sql):
        return f"Executing: {sql}"

# Usage
db1 = DatabaseConnection()
db2 = DatabaseConnection()
print(db1 is db2)  # True - same instance

package main

import (
    "sync"
)

type DatabaseConnection struct {
    connection string
}

var (
    instance *DatabaseConnection
    once     sync.Once
)

func GetDatabaseConnection() *DatabaseConnection {
    once.Do(func() {
        instance = &DatabaseConnection{
            connection: "Database connection established",
        }
    })
    return instance
}

func (db *DatabaseConnection) Query(sql string) string {
    return fmt.Sprintf("Executing: %s", sql)
}

// Usage
func main() {
    db1 := GetDatabaseConnection()
    db2 := GetDatabaseConnection()
    fmt.Println(db1 == db2) // true - same instance
}

Python vs Go Comparison

Language Characteristics

Feature	Python	Go
Type System	Dynamic	Static
Compilation	Interpreted	Compiled
Concurrency	Threading/Asyncio	Goroutines
Memory Management	Garbage Collected	Garbage Collected
Performance	Slower	Faster

Use Cases

Python Best For:

Data Science & ML
Web Development (Django/Flask)
Scripting & Automation
Rapid Prototyping
Scientific Computing

Go Best For:

Microservices
System Programming
Cloud Infrastructure
Network Services
High-Performance APIs

Side-by-Side Code Examples

HTTP Server Implementation

Python (Flask)

from flask import Flask, jsonify
import threading
import time

app = Flask(__name__)

# Simulated database
users = []
user_id_counter = 1

@app.route('/users', methods=['GET'])
def get_users():
    return jsonify(users)

@app.route('/users', methods=['POST'])
def create_user():
    global user_id_counter
    user = {
        'id': user_id_counter,
        'name': request.json.get('name'),
        'email': request.json.get('email'),
        'created_at': time.time()
    }
    users.append(user)
    user_id_counter += 1
    return jsonify(user), 201

@app.route('/users/', methods=['GET'])
def get_user(user_id):
    user = next((u for u in users if u['id'] == user_id), None)
    if user:
        return jsonify(user)
    return jsonify({'error': 'User not found'}), 404

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080, threaded=True)

Go (net/http)

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "strconv"
    "sync"
    "time"
    "github.com/gorilla/mux"
)

type User struct {
    ID        int       `json:"id"`
    Name      string    `json:"name"`
    Email     string    `json:"email"`
    CreatedAt time.Time `json:"created_at"`
}

var (
    users         []User
    userIDCounter int = 1
    usersMutex    sync.RWMutex
)

func getUsers(w http.ResponseWriter, r *http.Request) {
    usersMutex.RLock()
    defer usersMutex.RUnlock()

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(users)
}

func createUser(w http.ResponseWriter, r *http.Request) {
    var user User
    json.NewDecoder(r.Body).Decode(&user)

    usersMutex.Lock()
    user.ID = userIDCounter
    user.CreatedAt = time.Now()
    users = append(users, user)
    userIDCounter++
    usersMutex.Unlock()

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(user)
}

func getUser(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    userID, _ := strconv.Atoi(vars["id"])

    usersMutex.RLock()
    defer usersMutex.RUnlock()

    for _, user := range users {
        if user.ID == userID {
            w.Header().Set("Content-Type", "application/json")
            json.NewEncoder(w).Encode(user)
            return
        }
    }

    w.WriteHeader(http.StatusNotFound)
    json.NewEncoder(w).Encode(map[string]string{"error": "User not found"})
}

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/users", getUsers).Methods("GET")
    r.HandleFunc("/users", createUser).Methods("POST")
    r.HandleFunc("/users/{id}", getUser).Methods("GET")

    fmt.Println("Server starting on :8080")
    http.ListenAndServe(":8080", r)
}