Welcome to Part 5 of my homelab journey series! After setting up my Lenovo M920 Tiny with Proxmox (as you saw in Part 4), I've been exploring various self-hosted applications. Today, I want to share what has become my absolute favorite service: Paperless-ngx! 😄

Why Paperless-ngx Changed My Life

If you're anything like me, you've experienced that moment of panic when you need an important document—insurance certificate, warranty, medical record—and have absolutely no idea where you put it. Before Paperless-ngx, my "filing system" consisted of various folders, drawers.

Paperless-ngx solved this problem so elegantly. As their website puts it: "Paperless-ngx is a community-supported open-source document management system that transforms your physical documents into a searchable online archive so you can keep, well, less paper."

What Makes Paperless-ngx So Powerful?

1. Comprehensive Document Organization

Paperless-ngx doesn't just store your documents—it makes them truly searchable and organized:

• Full-text search: Find any document by searching its contents, not just the filename

• Tagging system: Create custom tags for easy categorization

• Custom fields: My favorite feature! I created a "Physical Location" field so I can note exactly where the original document is stored in my home

• Automatic document parsing: It can extract dates, correspondents, and other information automatically

2. Smart Document Processing

The OCR (Optical Character Recognition) capabilities are impressive:

• Converts scanned images to searchable text

• Supports multiple languages (I use French and English)

• Can automatically categorize documents based on content

• Creates thumbnails for easy visual identification

3. Flexible Input Methods

Getting documents into the system is remarkably flexible:

• Direct upload through the web interface

• Mobile app for scanning on the go

• Watch folder for automatic importing

My Paperless Workflow

After some experimentation, I've settled on a workflow that works perfectly for me:

1. Document scanning: I use my phone to scan documents via the Google Drive app (it has excellent document scanning capabilities)

2. Automatic import: A Node.js script I wrote monitors my Google Drive folder hourly and copies new documents to Paperless-ngx's consumption folder

3. Processing: Paperless-ngx automatically OCRs the documents and makes an initial attempt at classification

4. Organization: Once a week, I log into the dashboard to verify and adjust tags, categories, and add any custom field information

5. Search and retrieve: Whenever I need a document, a quick search brings it up instantly!

The mobile app has been a game-changer for quick document retrieval. No more digging through filing cabinets when I need to reference something while on the phone with my insurance company!

Setting Up Paperless-ngx

I won't sugar-coat it—setting up Paperless-ngx wasn't as straightforward as some of my other services. But the effort was absolutely worth it! Here's the Docker Compose configuration that's been working flawlessly for me:

services:
  broker:
    image: docker.io/library/redis:7
    restart: unless-stopped
    volumes:
      - /data/paperless/redis:/data

  db:
    image: docker.io/library/postgres:16.0-alpine
    restart: unless-stopped
    volumes:
      - /data/paperless/db:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: paperless
      POSTGRES_USER: paperless
      POSTGRES_PASSWORD: paperless

  webserver:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    restart: unless-stopped
    depends_on:
      - db
      - broker
    ports:
      - "8033:8000"
    volumes:
      - /data/paperless/data:/usr/src/paperless/data
      - /data/paperless/media:/usr/src/paperless/media
      - /data/paperless/export:/usr/src/paperless/export
      - /data/paperless/consume:/usr/src/paperless/consume
    environment:
      PAPERLESS_ADMIN_USER: "your_username"
      PAPERLESS_ADMIN_PASSWORD: "your_secure_password"
      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_DBHOST: db
      USERMAP_UID: 1000
      USERMAP_GID: 1000
      PAPERLESS_SECRET_KEY: "generate_a_long_random_string_here"
      PAPERLESS_TIME_ZONE: Europe/Paris
      PAPERLESS_OCR_LANGUAGE: fra+eng
      PAPERLESS_URL: "https://your.domain.or.ip"
      PAPERLESS_CSRF_TRUSTED_ORIGINS: "https://your.domain.or.ip"
      PAPERLESS_CORS_ALLOWED_HOSTS: "your.domain.or.ip"

A few important configuration notes:

• Make sure to replace the placeholder values with your actual username, password, and domain/IP

• The PAPERLESS_OCR_LANGUAGE setting is crucial—set it to the languages your documents use

• The consume folder is where new documents will be picked up automatically

• You'll need to adjust the USERMAP_UID and USERMAP_GID to match your system's user/group IDs

Tips From My Experience

After using Paperless-ngx for several months, I've gathered some helpful insights:

1. Invest time in creating a tagging system that makes sense for your documents before importing too many files

2. Set up document types early to help with automatic classification

3. Use custom fields creatively—I track physical location, importance level, and action required

4. Configure corresponding parties for common senders like your bank, insurance, etc.

Of all the services in my homelab, Paperless-ngx has had the most tangible impact on my day-to-day life. The time savings from not hunting for documents, the peace of mind from having everything securely backed up, and the satisfaction of a well-organized system make it the crown jewel of my setup.

If you're on the fence about setting up a document management system, I can't recommend Paperless-ngx enough. Yes, there's an initial time investment to scan and organize your backlog of documents, but the long-term benefits are enormous.

I'm excited to share BackPair with you today – a desktop application I developed to streamline local backups between folders and devices. This project emerged from two needs: simplifying my own backup process for my PC and homelab, and deepening my knowledge of Rust programming.

What BackPair Does

BackPair makes backing up folders to internal or external devices quick and efficient through a profile-based approach. Instead of manually copying folders one by one, you create profiles with source and destination folder pairs, then execute complete backups with a single click.

Key Features

Profile Management – Create and manage multiple backup profiles for different purposes (work, personal, homelab configurations).

Folder Pairing – Define specific source ("From") and destination ("To") folder pairs within each profile.

One-Click Backup – Select a profile and launch the backup process with a single button click.

Backup Logs – View real-time progress as your files are copied, with detailed status tracking.

Cross-Platform – Works on Windows, macOS, and Linux thanks to Tauri.

Clean Interface – Modern UI built with React.js and shadcn components keeps things intuitive.

Getting Started

Getting started with BackPair is straightforward:

1. Download – Get the latest version from the Releases page (note: not code-signed yet, so you may see security warnings).

2. Create Profiles – Navigate to "Add Profile," name it, and add your folder pairs.

3. Run Backups – Select your profile and click "Launch Backup." The logs will show progress in real-time.

4. Review History – Check the "History" section to see records of past backup operations.

If you're looking for a straightforward way to manage local backups without the complexity of enterprise solutions, give BackPair a try. It transforms a tedious manual process into a simple, one-click operation – whether you're backing up important documents, media files, or homelab configurations.

Links:

• Download BackPair

• Source Code

Happy backing up!

After playing around with my Raspberry Pi 4 setup for a while (as you saw in my previous articles), I started feeling the itch to try something with a bit more muscle. Don't get me wrong, the Pi has been amazing for getting my feet wet in the homelab world, but I was starting to bump into its limitations when trying to run multiple services at once.

This led me to make the jump to a Lenovo M920 Tiny with an Intel i5 8th Generation processor, 32GB RAM, and a 2TB SSD. It's compact, but packs enough power to let me explore all those cool self-hosted applications I've been eyeing on r/homelab! 😄

Why Upgrade from Raspberry Pi?

None :D, Let's be honest, once you catch the homelab bug, you're always thinking about the next expansion! 🤓

1. Setting Up Proxmox VE as My Hypervisor

What is Proxmox?

One of the first things I kept seeing mentioned in homelab communities was Proxmox Virtual Environment (Proxmox VE). Their website describes it as "a complete open-source platform for enterprise virtualization. With the built-in web interface, you can easily manage VMs and containers."

Basically, it's an operating system designed specifically for running and managing virtual machines and containers, all through a nice web interface. After digging into Reddit threads and YouTube videos, I was sold on giving it a try!

Why Proxmox?

The more I researched, the more Proxmox seemed like the perfect fit:

• It's completely free and open-source

• Comes with a user-friendly web interface

• Has a super active community (which is great when you inevitably get stuck!)

• Seems powerful enough for my needs but not overly complicated

1.1 Proxmox Installation

Rather than boring you with step-by-step instructions (which would just be me copy-pasting from better guides), I'll share the resources that saved me a ton of headaches:

• Best Proxmox course : https://www.youtube.com/playlist?list=PLT98CRl2KxKHnlbYhtABg6cF50bYa8Ulo

• How to install proxmox: https://www.youtube.com/watch?v=u8E3-Zy9NvI&list=PLT98CRl2KxKHnlbYhtABg6cF50bYa8Ulo

I just created a bootable USB drive with the Proxmox VE ISO, plugged it into my Lenovo, and followed the guided installation. It was surprisingly straightforward, and within about 30 minutes I had Proxmox up and running!

2. Creating My Main Home Server VM

With Proxmox happily installed, the next step was to create a virtual machine to be my main home server. I went with Ubuntu Server 24.04 LTS because it's what I'm most familiar with.

2.1 VM Configuration

For my home server VM, I allocated:

• 4 CPU cores

• 8GB RAM (keeping some headroom for other VMs)

• 100GB storage (plenty for Docker containers)

• Bridged network adapter so it would get its own IP on my network

2.2 Software Stack

I stuck with the same software stack I was already using on my Raspberry Pi:

• Docker: For running containerized applications

• Portainer: For easy container management

• Nginx Proxy Manager (NPM): For handling reverse proxy and SSL stuff

• AdGuard Home: For network-wide ad blocking

The migration was surprisingly smooth - Docker makes it easy to export/import settings between systems, which saved me tons of time!

3. My Current Homelab Architecture

So now my homelab has evolved into something a bit more complex but way more capable:

1. Internet Router/Firewall: The usual gateway to the internet

2. Lenovo M920 Tiny running Proxmox VE: The new powerhouse of my setup

   • Main Home Server VM (Ubuntu 24.04): Running with all these services:

     • Homepage, AdGuard Home, Nginx Proxy Manager, Stirling PDF

     • N8n, Kavita, YTB Audio (one of the web applications I built), , SnippetBox

     • Kuma, PaperLess, Wallos, Watchower

   • Kali Linux VM: Because why not have a security testing playground?

3. Raspberry Pi 4 (8GB RAM): Now dedicated to running just one thing:

   • Immich: My self-hosted Google Photos alternative that I talked about in Part 3

I've included a diagram of the setup below to make it easier to visualize:

3.1 Why Keep the Raspberry Pi for Immich?

You might be wondering why I kept Immich running on the Raspberry Pi instead of moving it to the new server. A few reasons:

1. It's working perfectly: As I mentioned in Part 3, I went through the whole process of setting up Immich with an external HDD on the Pi, and it's been running flawlessly

2. Dedicated photo machine: Having a separate device just for photo backups means I can tinker with the main server without worrying about my precious photos

4. Future Plans & Services

Since upgrading to more powerful hardware, I've been able to add several new services that weren't practical on the Raspberry Pi. I won't go into depth about each one here (that would make this post way too long!), but I'll be writing detailed articles about the most interesting ones in future posts.

I've been particularly excited about exploring things like Paperless-ngx for document management, N8n for automating workflows, and diving into security testing with the Kali Linux VM.

As my homelab journey continues, I'm already thinking about next steps:

1. Setting up proper backups: Right now it's a bit manual

2. Network segregation: Maybe some VLANs to separate things?

3. Home automation: Home Assistant is tempting me...

This homelab adventure continues to be both educational and fun - there's always something new to learn and try out. As I explore more services and configurations, I'll be sharing my experiences in future articles.

Have you made a similar upgrade in your homelab? Or still thinking about taking the plunge beyond Raspberry Pi? Let me know in the comments!

When I first started building custom libraries and generators, I wasn't just trying to speed up my workflow—I was unknowingly embarking on a journey that dramatically leveled up my skills. Creating tools forces you to think about reusability, design patterns, and maintainability in ways that day-to-day project work often doesn't require.

After working on numerous collaborative projects throughout my career, I felt compelled to share the invaluable lessons I've learned. My latest collaboration involves a ReactJS library that perfectly exemplifies why I'm so passionate about the power of working together. These experiences building developer tools inspired me to write this article and share these insights with both beginners and professionals alike.

In this article, I'll share insights from my experience developing two tools that have reshaped my development workflow: JERYO (a ReactJS component library built in collaboration with @Jérémy) and IyaGenerator (a Laravel & InertiaJS package). Both started as solutions to specific problems but evolved into comprehensive toolkits. They not only saved time but also became vehicles for learning and collaboration.

Whether you're a seasoned developer looking to optimize your workflow or a student eager to deepen your understanding of software design, I hope my experiences will inspire you to consider building tools—not just as a means to an end, but as an invaluable learning opportunity.

Accelerating Your Learning Through Tool Creation

Building your own developer tools isn’t just about solving immediate problems—it’s one of the most effective ways to deepen your technical knowledge and programming skills. Tools like Jeryo and IyaGenerator provided learning opportunities that regular project work couldn’t match.

Mastering Reusability

One of the first challenges you’ll face when building a tool is deciding what should be configurable versus hardcoded. For Jeryo, we had to identify common dashboard patterns that could be reused across different projects. This forced us to think beyond the immediate use case and consider:

• Which components need to be customizable?

• What default behaviors make sense for most scenarios?

• How can we make our API intuitive while maintaining flexibility?

This process of abstraction is a fundamental skill. You start seeing patterns where before you only saw one-off solutions. That shift in thinking has improved the quality and consistency of my code across all projects.

Design Patterns in Practice

Building libraries pushes you to implement design patterns you might have only read about. When developing Jeryo's form composers, we naturally gravitated toward the Composite Pattern, which allowed us to treat individual form fields and groups of fields uniformly. This made handling complex nested forms much easier.

For IyaGenerator, I implemented a Template Method Pattern. It let me define the overall structure of code generation while allowing for customization of specific sections. This ensured that each generated component followed a consistent structure, yet remained flexible for different use cases.

These weren’t academic exercises—they were practical, hands-on solutions to real problems. Implementing design patterns in tools you’ll actually use makes abstract concepts concrete and unforgettable.

Thinking About Developer Experience

Perhaps most importantly, building tools shifts your perspective from user experience to developer experience. You start asking:

• Is this API intuitive for other developers?

• How comprehensive should the documentation be?

• What are the common pitfalls users might encounter?

This empathy for fellow developers pushes you to write clearer, more maintainable code in all contexts—not just when building libraries.

Two Minds Are Better Than One

One of the most valuable lessons I've learned in my development journey is that collaboration brings perspectives you simply can't see with your own eyes. When working with others, you gain access to different approaches, techniques, and solutions that might never have occurred to you working alone.

This became especially apparent when collaborating on our ReactJS/TypeScript library designed to facilitate dashboard building. What began as a straightforward project evolved when we discovered we had different visions for its direction. Rather than seeing this as an obstacle, we recognized it as an opportunity. These divergent perspectives ultimately led us to a much bigger idea that we're now excited to pursue together.

The benefits of this collaborative approach extended far beyond the technical aspects. Working with another developer pushed me to:

• Articulate my design choices more clearly

• Consider edge cases I hadn't encountered individually

• Question assumptions I might have otherwise missed

• Find elegant compromises that satisfied multiple needs

These different viewpoints created a natural system of checks and balances that improved the final product in ways that would have been impossible working solo. The library became more robust, flexible, and ultimately more useful because it incorporated multiple perspectives from the start.

Tools That Solve Real Problems

While learning is a valuable byproduct, it’s usually the practical benefits that spark the initial development of custom tools. They shine in scenarios where off-the-shelf solutions fall short or require too much customization.

Standardizing Best Practices

When working in teams, maintaining consistent coding standards and architectural patterns can be challenging. Custom tools can bake these best practices directly into generated code or reusable components.

With Jeryo, we embedded our team’s preferred approaches to:

• Form validation

• Error handling

• State management

• Component composition

Similarly, IyaGenerator produces code that follows our established architectural patterns. This ensures consistency, even as team members come and go.

Addressing Domain-Specific Requirements

Generic tools often struggle with industry- or domain-specific needs. Custom tools, on the other hand, can directly incorporate specialized knowledge.

For example, IyaGenerator includes templates for common business entities like users, products, and orders, complete with relationships and validation rules. This domain expertise makes it particularly valuable for certain types of applications.

Quick Iteration and Deployment

The most immediate benefit of custom tools? Speed.

What used to take days can now take hours—or even minutes. This acceleration enables:

• Faster prototyping

• More time for testing and refinement

• Quicker response to changing requirements

• Lower development costs

With IyaGenerator, I can deploy a complete admin interface with full CRUD capabilities for a new entity in under five minutes—including database migrations, backend logic, and frontend components. This level of efficiency has transformed my development workflow.

Growing Through Collaboration

Building tools isn't just a technical endeavor—it's a social one. Collaborating on developer tools revealed the unique benefits of working together on these projects.

Real-World Benefits for Every Developer

For junior developers, collaboration offers a window into the real world of professional development. It challenges you to:

• Explain and defend your code choices

• Understand different coding styles

• Learn industry best practices

• Develop crucial communication skills

• Build a professional network

For seasoned professionals, collaboration continues to provide value through:

• Cross-pollination of ideas

• Accountability and motivation

• Shared workload during complex projects

• Continuous learning through knowledge exchange

Diverse Perspectives Lead to Better Design

When multiple developers bring different experiences and preferences to the table, these diverse perspectives push the project forward:

• Architectural decisions become more thoroughly vetted

• UX considerations become more comprehensive

• Documentation improves as different learning styles are considered

• Edge cases are identified earlier in the development process

Momentum and Accountability

Solo projects often stall when life gets busy. Collaboration creates a natural accountability system:

• Regular check-ins keep things moving forward

• Shared ownership increases commitment

• Different strengths help overcome obstacles

• One person's enthusiasm can reignite motivation in the other

Community Building

Even small tools can build communities. My libraries started as tools just for my teams, but once shared with colleagues, they sparked valuable conversations and contributions.

That small community provided:

• Helpful feedback

• Feature suggestions we hadn't considered

• Edge case identification

• A sense of shared purpose

When developed collaboratively, even simple tools can become focal points for ongoing learning and professional connection.

Building Your Path Forward

The journey of creating custom tools like Jeryo and IyaGenerator has been transformative. Yes, they save time—but the deeper benefits of learning, collaboration, and standardization have proven even more valuable.

Key Takeaways

Building your own developer tools offers multiple layers of value:

• Learning acceleration: You’ll master reusability, design patterns, and advanced language features in a practical context.

• Workflow optimization: Custom tools tailored to your workflow eliminate repetitive work and standardize best practices.

• Collaborative growth: Working with others creates opportunities for knowledge sharing and builds stronger professional relationships.

Start Small, Think Big

You don’t have to build a framework to get started. Begin with a small utility that solves a specific pain point in your workflow. As you gain confidence and see the benefits, you’ll naturally expand its capabilities—or create complementary tools.

The Jeryo library started as a simple collection of form components before evolving into a complete dashboard solution. IyaGenerator began with basic CRUD generation and grew to handle complex relationships and custom deployments.

Your Next Tool Might Be the One You Build Yourself

If you’ve ever found yourself thinking “there has to be a better way,” that’s the perfect place to start. Your next favorite tool might be the one you build—so why not get started today?

After setting up my Raspberry Pi with various services and getting everything to run smoothly, another need popped into my mind—creating a reliable photo backup solution at home.

Sure, we all rely on cloud services to store our photos and files, but let’s be honest—those costs climb as your storage needs grow. I’m not quite ready to ditch the cloud entirely (yet 😄), but having an additional local backup sounded like a smart move.

For this experiment, I repurposed an old external HDD that I wasn’t using anymore, thanks to a shiny new SSD. Then, I discovered Immich, a self-hosted photo and video management solution. Spoiler alert: it’s pretty awesome! You can check it out here: Immich.

Let me walk you through how I set everything up, from prepping the hardware to deploying Immich.

Preparing the External HDD

To start, I connected my external HDD to the Raspberry Pi via the blue USB port. Typically, these drives won’t mount automatically, so let’s confirm its status. I ran the command:

df -h

As expected, the drive wasn’t listed. So, I checked all block devices with:

lsblk

Here’s where the HDD showed up as /dev/sda. Now, before proceeding, I decided to format the drive. (Quick tip: Make sure you’ve backed up any important data on the disk first!)

Formatting the Drive

Using fdisk, I created a new partition table and formatted the drive:

1. Opened the disk utility:

     fdisk /dev/sda
   

2. Used the following commands within fdisk:

   • o to create a new DOS (MBR) disk label.

   • n for a new partition, choosing p for primary, and leaving the other options as default.

   • w to write the changes.

3. Formatted the new partition to the ext4 filesystem:

    sudo mkfs -t ext4 /dev/sda1
   

   

Mounting the Drive on the Raspberry Pi

With the external HDD formatted and ready, the next step was mounting it to the Raspberry Pi.

Step 1: Create a Mount Point

First, I created a folder where the drive would be mounted:

sudo mkdir -p /mnt/home-data

Then, I assigned the folder permissions to my user:

sudo chown -R ayub:ayub /mnt/home-data

(Ps: Replace ayub with your actual username.)

Step 2: Automatically Mount the Drive

To ensure the drive mounts automatically every time the Raspberry Pi boots up, I gathered the necessary details using:

sudo blkid /dev/sda1

This command returned something like this:

/dev/sda1: UUID="xxxxx-xxxx-xxxx-xxxx" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="b12bb460-01"

I noted the UUID and TYPE values because we’d need them for the next step.

Step 3: Modify the fstab File

The fstab file controls how drives are mounted in Linux. I edited it with the following command:

sudo nano /etc/fstab

At the bottom of the file, I added this line:

UUID=xxxxx-xxxx-xxxx-xxxx /mnt/home-data ext4 defaults,auto,users,rw,nofail,noatime 0 0

(Replace xxxxx-xxxx-xxxx-xxxx with your UUID and ext4 with your filesystem type.)

After saving the file (CTRL + X, then Y, and ENTER), I unmounted the drive to apply the changes:

sudo umount /dev/sda1

Finally, I re-mounted it with:

sudo mount -a

The drive was now ready to use, automatically mounting on every boot.

Installing Immich

With the hard drive set up, I moved on to installing Immich using Portainer. Immich is a fantastic self-hosted photo and video management solution with a sleek interface and powerful features.

Here’s how I set it up:

Step 1: Deploy Immich via Portainer

1. Opened Portainer and navigated to "Stacks" in the sidebar.

2. Clicked on "Add Stack" and gave it the name immich.

3. Selected "Web Editor" as the build method.

4. Copied the content of the docker-compose.yml file from the official Immich GitHub repository and pasted it into the editor.

5. Updated the environment variables:

   • Switched .env references to stack.env.

   • Pasted the contents of example.env from the same GitHub repository into the Environment Variables editor.

Step 2: Configure Environment Variables

In Simple Mode, I made the following changes:

• Set a secure DB_PASSWORD.

• Updated DB_DATA_LOCATION and UPLOAD_LOCATION (in our case is /mnt/home-data) paths to point to folders on the external HDD.

Step 3: Deploy the Stack

Finally, I clicked on "Deploy the Stack."

(Note: If you encounter an error like can't set healthcheck.start_interval as feature requires Docker Engine v25 or later, you can fix it by commenting out the start_interval: 30s line in the docker-compose.yml file.)

Creating a Proxy Host for Immich

Once Immich was up and running, it was time to make it accessible through a neat, custom domain name. For this, I used Nginx Proxy Manager.

Step 1: Connect Immich to the Nginx Proxy in Portainer

Since Immich was running inside Docker via Portainer, I needed to link it to my Nginx Proxy container. Here’s how I did it:

1. In Portainer, I made sure Immich was part of the same Docker network as the Nginx Proxy Manager. To do this:

   • I opened Portainer and went to the Immich container settings.

   • Under the Networks section, I added the Nginx Proxy network (the same network Nginx Proxy Manager was using).

2. Next, I created a Proxy Host in Nginx Proxy Manager, assigning a clean, easy-to-remember domain name (e.g., photos.domaine.com).

3. I pointed the domain to Immich’s internal container IP and port, and added SSL for extra security.

Now, Immich was accessible through the domain!

Immich in Action

After everything was set up, I visited the domain URL and was welcomed by the Immich interface. I created my user account and started exploring. One of the coolest features is the mobile app, which allows you to automatically back up your photos. Simply download the Immich app on your phone, enter the URL of your Immich server, and your photos will be backed up automatically, keeping everything synced across your devices. The app works seamlessly and makes it so much easier to manage your photo library on the go!

This project was a great way to enhance my home lab with a local photo backup solution. While I’m not ditching the cloud just yet, having a backup I control feels pretty awesome.

Stay tuned for more updates as my homelab journey continues!

Portainer: Simplifying Docker Management

I love how Docker makes managing containers easy, but typing commands every time can get tedious. That’s where Portainer comes in! It’s a web-based tool that lets me manage Docker with just a few clicks.

Setting Up Portainer

First, let’s create a volume to store Portainer’s database:

docker volume create portainer_data

Next, download and install the Portainer Server container:

docker run -d \
  -p 8000:8000 \
  -p 9443:9443 \
  -p 9000:9000 \
  --name portainer \
  --restart=always \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v portainer_data:/data \
  portainer/portainer-ce:2.21.4

Once done, open your browser and navigate to:

https://<your-pi-address-or-hostname>:9443

In my case, I used https://pifour.local:9000.

Setting Up Nginx Proxy Manager for SSL Certificates

After getting Portainer set up, I turned my attention to Nginx Proxy Manager (NPM). Why? Because I wanted to access my services with nice, clean URLs (like app.localdomain.com) and secure them with SSL certificates.

Why a Domain Name?

I bought a domain name specifically for local use. The domain is mapped to the Raspberry Pi’s local IP address. This setup allows me to generate SSL certificates and bypass potential DNS rebinding issues.

Why NPM?

Here’s why I’m loving NPM:

• Custom Domains: No more memorizing IPs and ports.

• SSL Made Easy: Let’s Encrypt certificates with a few clicks.

• Simple UI: Setting up reverse proxies is super straightforward.

Installing Nginx Proxy Manager

We’ll create a stack from the Portainer dashboard:

1. Go to Portainer Dashboard.

2. Click "Add Stack."

3. 

   Add the docker-compose.yml content from Nginx Proxy Manager’s setup page. Here’s the content for reference:

services:
  app:
    image: 'jc21/nginx-proxy-manager:latest'
    restart: unless-stopped
    ports:
      - '80:80'    # HTTP
      - '443:443'  # HTTPS
      - '81:81'    # Admin UI
    environment:
      DB_MYSQL_HOST: "db"
      DB_MYSQL_PORT: 3306
      DB_MYSQL_USER: "npm"
      DB_MYSQL_PASSWORD: "npm"
      DB_MYSQL_NAME: "npm"
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt
    depends_on:
      - db

  db:
    image: 'yobasystems/alpine-mariadb:latest'
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: 'npm'
      MYSQL_DATABASE: 'npm'
      MYSQL_USER: 'npm'
      MYSQL_PASSWORD: 'npm'
    volumes:
      - ./mysql:/var/lib/mysql

Note: The yobasystems/alpine-mariadb image is used here because it supports ARM devices like the Raspberry Pi.

After deploying the stack, visit: http://<your-pi-address-or-hostname>:81

Default Credentials:

• Email: admin@example.com

• Password: changeme

Update your details and password after logging in.

Configuring SSL and Fixing DNS Rebinding

One challenge I faced was DNS rebinding. This happens when trying to access local domains, and some routers block them for security reasons. To fix this and improve my network’s DNS, I installed AdGuard Home.

Setting Up AdGuard Home

AdGuard Home is fantastic for blocking ads and resolving DNS issues like rebinding protection.

Here’s how I set it up:

1. Create a New Stack in Portainer
   Add a new stack with the following docker-compose.yml configuration:

services:
  adguardhome:
    image: adguard/adguardhome
    container_name: adguardhome
    restart: unless-stopped
    ports:
      - "8080:80/tcp"  # HTTP interface (use alternative ports to avoid conflicts)
      - "8443:443/tcp" # HTTPS interface (use alternative ports to avoid conflicts)
    volumes:
      - /data/adguard-home/work:/opt/adguardhome/work
      - /data/adguard-home/confdir:/opt/adguardhome/conf

Since Nginx Proxy Manager is already using ports 80 and 443, I mapped AdGuard Home to 8080 and 8443.

2. Visit AdGuard’s Setup Page
   After deploying the stack, visit http://<your-pi-address-or-hostname>:8080 to complete the initial setup.

3. Set AdGuard as Your Router’s DNS:
   Update your router’s DHCP settings to use AdGuard for DNS. For instance, with Freebox OS, you can easily configure the DNS settings in the router's admin panel. The process will be similar for most routers.

   

   Fixing DNS Rebinding

   To resolve DNS rebinding issues and ensure smooth access to your local services, follow these steps:

   1. Configure DNS Rewrites in AdGuard
      In AdGuard Home, go to Filters → DNS Rewrites, and add your domain along with the Pi’s local IP address. This will ensure local access to your services without DNS rebinding errors.

      

      

   2. SSL Setup for Local Domains
      To securely use your local domains, I used Cloudflare to manage SSL certificates.you can follow this topic that explain well this step sHere’s a summary of the steps:

      • Buy a domain from a registrar (I used Namecheap).

      • Set up DNS in Cloudflare to point to the Raspberry Pi’s local IP address.

Adding SSL Certificates and Proxy Hosts in NPM

Step 1: Connect AdGuard to NPM

Before setting up SSL for AdGuard (or any other service), ensure it’s connected to NPM:

1. Go to Portainer → Containers and find the nginx_proxy_manager-app-1 container (or your NPM container name).

2. Scroll down to the Connected Networks section.

3. Join the AdGuard network so NPM can communicate with it.

Step 2: Add an SSL Certificate

1. Open Nginx Proxy Manager (NPM).

2. Go to SSL Certificates and click Add SSL Certificate.

3. Use Let's Encrypt with Cloudflare DNS to validate the certificate.

   • Make sure your domain & subdomain is already set up in Cloudflare and points to your local IP.

Step 3: Create a Proxy Host

1. In NPM, navigate to Hosts → Proxy Hosts and click Add Proxy Host.

2. Fill in the details:

   • Domain Name: Enter the domain or subdomain (e.g., adguard.localdomain.com).

   • Forward Hostname/IP: Enter the local IP of the service (e.g., your Raspberry Pi’s IP).

   • Forward Port: Enter the port where the service is running.

     

3. Go to the SSL Tab and select the SSL certificate you created earlier.

4. Enable the following options for better security and performance:

   • Force SSL (redirects all traffic to HTTPS).

   • HTTP/2 Support (makes things faster and smoother).

5. Save your settings.

Step 4: Test Your Setup

Open your browser and visit the domain or subdomain you just set up. You should see the service running securely over HTTPS.

Step 5: Repeat for Other Services

For each additional service, follow the same process:

• Make sure the service is connected to NPM’s network in Portainer.

• Add a proxy host in NPM with the correct domain, IP, port, and SSL certificate.

That’s it! Your services are now secured and easily accessible with clean, HTTPS-enabled URLs. 🎉

Trying Out an App: Wallos

With everything set up, it’s time to have some fun and test an app! I decided to try Wallos, a handy tool for managing subscriptions. Here’s how I got it up and running:

Step 1: Add Wallos in Portainer

In Portainer, create a new stack and use the following configuration:

yamlCopier le codeservices:
  wallos:
    container_name: wallos
    image: bellamy/wallos:latest
    ports:
      - "8282:80"
    volumes:
      - './db:/var/www/html/db'
      - './logos:/var/www/html/images/uploads/logos'
    restart: unless-stopped

Step 2: Connect Wallos to NPM

Once the stack is deployed, connect Wallos to the Nginx Proxy Manager network:

1. Go to Portainer → Containers and locate the wallos container.

2. Scroll to the Connected Networks section and join the network used by Nginx Proxy Manager.

Step 3: Create a Proxy Host for Wallos

In NPM, set up a new proxy host:

• Enter your domain name (e.g., wallos.localdomain.com).

• Set the local IP and port (8282) for the Wallos container.

• Select your SSL certificate, enable Force SSL, and save.

Step 4: Test Wallos

Now, open your browser and visit the domain you set up. You should see Wallos ready to manage your subscriptions securely and efficiently! 🎉

Wrapping Up

This journey has been an incredible learning experience. From fixing tricky DNS rebinding issues to configuring SSL for local domains, every step was a mix of challenges and triumphs. Each error pushed me to explore new concepts, and the solutions taught me skills I never thought I’d need.

But this is just the beginning! There’s so much more to discover in the world of homelabs, and I can’t wait to see where this adventure takes me next. 🚀

I decided to take baby steps into this world with my Raspberry Pi 4 (8GB). At first, it was just for testing out things like Docker, Portainer, and AdGuard (to block ads and solve a DNS issue I’ll explain later). I also set up Nginx Proxy Manager for managing SSL and reverse proxies. I won’t lie—the learning curve was tough. But I ended up learning so much about networking, system configs, and other cool stuff that I didn’t expect to get into.

Now, I’m upgrading my setup with a larger microSD card and thought, why not document the process and share it? Hopefully, this helps someone else get started too!

Step 1: Getting Started with Raspberry Pi

First things first—you need a Raspberry Pi. Whether it’s a Pi 3, Pi 4, Pi 5, or even a Pi Zero 2W, any of them will work depending on what you’re planning to do. I went with the Raspberry Pi 4 (8GB) for its power and versatility.

For the operating system, I used Raspberry Pi Imager, which makes the setup super easy. It even lets you configure things like the root user, Wi-Fi, and hostname right out of the box.

Here’s what I did:

1. Download Raspberry Pi Imager
   You can grab it from Raspberry Pi Software.

2. Set Up the OS

   • Choose your Raspberry Pi model.

   • Select the operating system—I went with Raspberry Pi OS Lite (64-bit) because I didn’t need the desktop version.

   • Insert your microSD card and select it as the storage.

   • 

3. Configure Advanced Options
   Before flashing, you can click the gear icon (Advanced Options) to set:

   • Hostname: I named mine pifour.local for easier access on the network.

   • User credentials: Set your username and password.

   • Wi-Fi credentials: I added these for initial setup, but later switched to Ethernet for better performance.

   • 

4. Flash the Card
   Once everything is configured, click “Write” and let it do its thing.

   

When the process is done, pop the microSD card into your Pi, connect the power, and you’re ready to roll!

Step 2: Connecting to the Raspberry Pi

Once your Raspberry Pi is powered up and running, it’s time to connect to it. I used SSH from my laptop to access it remotely. If you’re unsure of the IP address, you can check your router’s admin page or connect the Pi to a monitor and use the hostname -I command to find it.

I used PuTTY on Windows, but you can also use the terminal on macOS or Linux.

Here’s how I connected:

1. Launch PuTTY (or your terminal).

   1. 

2. Enter the Pi’s IP address as the Host Name and click Open.

3. Log in with the username and password you set up during the Raspberry Pi Imager configuration.

Once logged in, the first thing I did was update the system. Keeping your Pi updated is crucial for security and performance:

sudo apt update && sudo apt upgrade -y

Step 3: Setting a Static IP Address

One of the first tweaks I made was setting a static IP address for the Pi. This prevents its IP from changing every time the router restarts, which is super helpful when you’re running services like Docker or AdGuard.

You can do this through your router’s DHCP settings (easier) or directly on the Pi. I went with the latter using nmcli.

Steps to Set a Static IP:

1. Find the Network Interface Name:
   Run this command to see the connection name (usually Wired connection 1 for Ethernet):

   sudo nmcli -p connection show

2. Assign a Static IP:
   Replace 192.168.1.6 with your desired IP, and 192.168.1.254 with your gateway/DNS address:

   sudo nmcli c mod "Wired connection 1" ipv4.addresses 192.168.1.6/24 ipv4.method manual sudo nmcli c mod "Wired connection 1" ipv4.gateway 192.168.1.254 sudo nmcli c mod "Wired connection 1" ipv4.dns 192.168.1.254

3. Restart the Connection:

   sudo nmcli c down "Wired connection 1" && sudo nmcli c up "Wired connection 1"

Now your Raspberry Pi will always have the same IP address, making it much easier to access and manage!

Step 4: Securing the Raspberry Pi with SSH Keys

I wanted to make my Raspberry Pi more secure and simplify the login process, so I set up SSH key-based authentication. This way, I could log in without entering my password, and it’s much harder for someone else to gain unauthorized access.

If you're new to SSH keys and want a detailed guide, I recommend this excellent tutorial from Pi My Life Up. It breaks down the process step-by-step and is perfect for beginners.

In case you prefer a quick overview, here’s what I did:

Steps to Set Up SSH Keys:

1. Generate an SSH Key Pair on Your Laptop:
   On Linux or macOS, run the following command in your terminal:

   ssh-keygen -t rsa -b 4096

   This generates a public and private key pair. You’ll find them in ~/.ssh/id_rsa (private) and ~/.ssh/id_rsa.pub (public).

   If you’re on Windows, you can use PuTTYgen to create the keys.

2. Set Up the SSH Directory on the Pi:
   After connecting to your Pi via SSH, create the .ssh directory and set the right permissions:

   mkdir -p ~/.ssh chmod 700 ~/.ssh

3. Copy the Public Key to the Pi:
   From your laptop, run:

   ssh-copy-id pi@192.168.1.6

   Replace pi with your username and 192.168.1.6 with your Pi’s IP address.

   If ssh-copy-id isn’t available, you can manually copy the key:

   cat ~/.ssh/id_rsa.pub | ssh pi@192.168.1.6 "cat >> ~/.ssh/authorized_keys" chmod 600 ~/.ssh/authorized_keys

4. Disable Password Login:
   To improve security, I disabled password-based SSH logins:

   sudo nano /etc/ssh/sshd_config

   Find and change the line:

   #PasswordAuthentication yes

   To:

   PasswordAuthentication no

   Save the file (Ctrl + O, then Ctrl + X) and restart SSH:

   sudo systemctl restart ssh

Now I could log in securely without a password, making my Raspberry Pi much safer and easier to access.

Step 5: Setting Up a Firewall with UFW

To add an extra layer of security, I installed UFW (Uncomplicated Firewall). It’s a simple tool to manage firewall rules and block unwanted access.

Installing and Configuring UFW:

1. Install UFW:

   sudo apt install ufw -y

2. Allow SSH Connections:
   Before enabling the firewall, make sure SSH is allowed so you don’t lock yourself out:

   sudo ufw allow 22

3. Allow Additional Ports (Optional):
   If you plan to use HTTP or HTTPS for web services, allow those ports as well:

   sudo ufw allow 80 sudo ufw allow 443

4. Enable Rate Limiting for SSH:
   To prevent brute force attacks, limit SSH connection attempts:

   sudo ufw limit 22

5. Enable the Firewall:

   sudo ufw enable

6. Check the Firewall Status:

   sudo ufw status verbose

That’s it! My Raspberry Pi was now more secure, with SSH keys and a firewall protecting it.

Step 6: Installing Docker on the Raspberry Pi

With my Raspberry Pi secured and ready, I moved on to installing Docker—a must-have tool for running and managing containerized applications. Docker simplifies deploying apps by isolating them in containers, and it’s perfect for a homelab setup.

Step 1: Update the System

First, I made sure my Raspberry Pi was up-to-date:

sudo apt update && sudo apt upgrade -y

Step 2: Install Docker

Docker provides an official installation script that handles everything for you. I used the following command to install it:

curl -fsSL https://get.docker.com | sudo sh

This script downloads and installs Docker, making it a straightforward process.

Step 3: Verify the Installation

Once the installation was complete, I checked whether Docker was running:

sudo systemctl status docker

The output confirmed that Docker was active and running.

Step 4: Add My User to the Docker Group

To avoid typing sudo for every Docker command, I added my user to the docker group:

sudo usermod -aG docker pi

Replace pi with your username if it's different.

For the changes to take effect, I logged out and back in. I then confirmed my user was part of the docker group:

groups

Step 5: Test Docker

To ensure Docker was set up correctly, I ran:

docker version

The command displayed the installed Docker version and confirmed everything was working as expected.

Step 7 : Installing Docker Compose

While Docker is great for managing individual containers, Docker Compose simplifies managing multi-container applications, which is essential for more complex setups like running Portainer.

Step 1: Install Docker Compose

I installed Docker Compose with this simple command:

sudo apt install docker-compose -y

Step 2: Verify Docker Compose

To confirm it was installed, I checked the version:

docker-compose --version

Wrapping It Up

Congrats on getting your Raspberry Pi up and running! You’ve laid the foundation for a powerful homelab setup. In the next article, we’ll dive into installing Portainer, setting up AdGuard, configuring Nginx Proxy Manager, and running other exciting self-hosted apps. Stay tuned—your homelab journey is just getting started!

Understanding CORS

CORS is a security mechanism that restricts web pages from making requests to a different domain than the one serving the web page. While crucial for web security, it can become a hurdle during development, especially when working with third-party APIs or services.

The Challenge

Recently, while developing a portfolio with Next.js 14, I needed to fetch and display an RSS feed from a blog. However, I faced a CORS error because I was working solely on the frontend and didn't have control over the server hosting the RSS feed.

A Simple Solution in Next.js 14

Next.js 14 provides an elegant solution by allowing us to create an internal API route that acts as a proxy. Here's how to implement it:

1. Create an API Route

First, create a file named route.ts in the app/api/rss directory:

import { NextResponse } from "next/server";
import Parser from "rss-parser";

export async function GET(request: Request) {
  const parser = new Parser();
  const feed = await parser.parseURL('https://blog.example.com/rss.xml');
  const items = feed.items.slice(0, 3).map((item: any) => ({
    title: item.title || "",
    link: item.link || "",
    source: "Example Blog",
    contentSnippet: item.contentSnippet || "",
    content: item.content || "",
    image: feed.image?.url,
    publishedAt: item.pubDate
  }));

  return NextResponse.json(items);
}

This API route fetches the RSS feed, parses it, and returns the first three items as JSON. By doing this server-side, we avoid CORS issues entirely.

2. Implement the Frontend Component

Now, let's create a React component to display the fetched articles using the useSWR hook for data fetching and caching:

import React from "react";
import useSWR from 'swr';
import PostItem from "@/app/post-item";

const fetcher = (url: string) => fetch(url).then((res) => res.json());

interface Article {
  title: string;
  link: string;
  source: string;
  contentSnippet?: string;
  content?: string;
  image?: string;
  publishedAt?: string;
}

export default function Articles() {
  const { data, error } = useSWR("/api/rss", fetcher, {
    revalidateOnFocus: false,
    revalidateOnReconnect: false
  });

  if (error) return <div>Failed to load articles</div>;

  return (
    <section>
      <h2 className="text-xl font-semibold mb-4">Latest Articles</h2>
      <div className="space-y-4">
        {data ? (
          data.map((item: Article, index: number) => (
            <PostItem key={index} {...item} />
          ))
        ) : (
          <p className="text-sm text-gray-600">
            Loading articles...
          </p>
        )}
      </div>
    </section>
  );
}

Explanation of useSWR and the Fetch Function

The useSWR hook is a powerful tool for data fetching in React applications:

1. SWR (Stale-While-Revalidate): SWR is a React Hooks library for data fetching, created by the Vercel team. It's named after the HTTP Cache-Control extension "stale-while-revalidate". You can find more information Here

2. The fetcher function is a wrapper around the native fetch API, making a GET request and parsing the response as JSON.

3. useSWR takes the API route ("/api/rss") as its key and the fetcher function as its second argument.

4. It returns an object with data and error properties, handling loading and error states automatically.

Benefits of this Approach

1. CORS Bypass: The Next.js API route acts as a proxy, fetching data server-side where CORS restrictions don't apply.

2. Efficient Data Fetching: SWR provides automatic revalidation, caching, and error handling.

3. Clean Implementation: This solution requires minimal setup and integrates smoothly with Next.js projects.

Conclusion

This method offers a practical solution for bypassing CORS issues in Next.js 14 applications. It's particularly useful for scenarios where you need to fetch data from external sources without modifying the backend.

While effective for many use cases, always consider the implications of proxying requests through your server, especially for high-traffic applications. In some scenarios, implementing proper CORS headers on your API might be more appropriate.

By leveraging Next.js API routes and SWR, you can create robust, CORS-free data fetching solutions in your Next.js applications.

This interview explores Khalid's remarkable journey, offering insights into the challenges of content creation, the evolution of .NET, and the personal growth that comes with pursuing one's passion on a global stage.

Career Journey:

• Q: What was the pivotal moment that led you to create Arabic-language .NET tutorials on YouTube?

  • Khalid: My journey into creating YouTube tutorials began after I published my first book on C# in 2010. Initially, I aimed to diversify the educational resources available to the Arabic-speaking audience, understanding that some learners prefer reading while others prefer visual learning through videos. However, the true turning point came when I was scammed by an educational institution that didn't pay me for a series of courses I had recorded. Instead of letting the content go to waste, I decided to share it on my YouTube channel, which opened up a new path for me in content creation.

• Q: How has being a non-native English speaker influenced your approach to teaching global programming concepts?

  • Khalid: Being a non-native English speaker hasn't been a barrier for me. My strength lies in my command of Arabic and my ability to articulate complex programming concepts in the language. While English is undeniably important in the programming world, I've successfully adapted and localized content to make it accessible to Arabic speakers. My approach involves simplifying, localizing, and gradually explaining concepts, which has resonated well with my audience.

• Q: Can you share a specific challenge you faced when writing your books that was different from creating video content?

  • Khalid: Writing books presents a unique set of challenges, particularly when it comes to explaining practical concepts. In videos, it's straightforward to demonstrate ideas by recording the screen, but in a book, you have to be creative with words to paint a clear picture in the reader's mind. This task of translating visual concepts into written form has been one of the most difficult yet rewarding challenges for me.

• Q: What was the most unexpected lesson you learned transitioning from freelancing in Morocco to a full-time role in Belgium?

  • Khalid: Transitioning to a full-time role in Belgium taught me the importance of preparation. I knew that adapting to a new environment would be challenging, so I invested time in learning new tools and techniques that would ease the transition. This foresight helped me adjust smoothly to the new work culture.

• Q: How has the Microsoft MVP award changed your perspective on community involvement in tech?

  • Khalid: The MVP Award significantly shifted my approach to creating technical content. After receiving the award, I became more focused on delivering high-quality, rare, and valuable content. The responsibility that comes with the title makes you more cautious in answering questions because people look to you as an expert, and any mistake can have serious implications for them.

Technical Expertise:

• Q: What emerging .NET technology are you most excited about, and why?

  • Khalid: Recently, I have been focused on Xamarin.Forms, but with Microsoft's decision to phase it out, I've redirected my attention to ASP.NET Core. My choice is pragmatic—ASP.NET Core aligns with our projects, and I'm not entirely convinced by .NET MAUI. My interest here is guided by both my personal preferences and the needs of the company I work for.

• Q: How do you stay current with the rapid changes in .NET development while managing your content creation schedule?

  • Khalid: In recent years, my content production has slowed due to time constraints and other commitments. However, I’ve maintained my habit of exploring new developments in coding and keeping up with emerging techniques and tools, ensuring that I stay informed even when I'm not actively creating content.

• Q: Can you describe a complex .NET concept you've found particularly challenging to teach, and how you overcame that challenge?

  • Khalid: One of the most challenging topics I've tackled is the SOLID principles, especially when writing about them in Arabic. The complexity and the number of concepts involved made it difficult to ensure coherence. To overcome this, I focused on developing a single example that clearly illustrated each principle in detail. By making the writing process enjoyable, I was able to overcome these challenges and produce a successful book.

Content Creation:

• Q: How do you decide what topics to cover in your videos and books?

  • Khalid: The topics I cover are largely driven by the requests I receive from learners. When a particular topic is frequently requested, I make it a priority to explain it, either through video or in writing.

• Q: What strategies have you found most effective for growing your YouTube audience?

  • Khalid: The key to growing a YouTube audience in technical fields is mastery of the subject matter. People can quickly recognize expertise, and when they see that you are specialized and proficient, they spread the word. This word-of-mouth promotion helps your audience grow organically, often without requiring any direct effort on your part.

• Q: How do you balance creating content for beginners versus more advanced developers?

  • Khalid: I strive to maintain a balance between content for beginners and more advanced developers. My mission is to help as many people as possible, rather than focusing solely on expanding my audience. This approach ensures that I cater to a wide range of learners, from novices to professionals.

Personal Growth:

• Q: How has your journey as a content creator changed your approach to your own learning and development?

  • Khalid: Teaching has been one of the most effective ways to deepen my own understanding of programming concepts. When I'm asked to explain something I don't fully understand, it motivates me to learn it thoroughly. Creating technical content has therefore been instrumental in my personal growth as a developer.

• Q: What's been the most rewarding feedback you've received from a viewer or reader?

  • Khalid: The most rewarding feedback comes from those who have secured jobs thanks to my lessons. When I receive messages filled with gratitude from people whose lives have been positively impacted by my content, I feel a deep sense of pride and accomplishment.

• Q: If you could go back in time and give advice to yourself when you were just starting out, what would you say?

  • Khalid: If I could go back, I would advise myself to start with a strong foundation in data structures, algorithms, and mathematics. While math isn't a strict requirement for programming, it opens up many avenues and opportunities for a programmer.

Future Aspirations:

• Q: Are there any new content formats or platforms you're considering exploring?

  • Khalid: Absolutely. I'm currently working on a significant educational project that is still in its early stages. I hope this project will bring about substantial changes in coding education across the Arab world.

• Q: How do you envision the role of multilingual content creators in shaping the future of global tech education?

  • Khalid: I believe content creators will have an even greater impact if they contribute to the development of technology itself, rather than just creating content about it. When we move from explaining to innovating, our influence on the tech industry will be far more profound.

• Q: What's one ambitious goal you have for your impact on the .NET community in the next five years?

  • Khalid: My ambition is to be more involved in the development of technology itself, beyond just content creation. I believe this will allow me to have a more significant and lasting impact on the .NET community.

Khalid's journey from a local developer to a global .NET influencer is a testament to the power of passion, perseverance, and knowledge sharing. His story not only inspires aspiring developers but also highlights the growing importance of diverse voices in shaping the future of technology education worldwide.

Stepping Out of the Comfort Zone

At first, the idea of learning 3D modeling seemed completely unrelated to my day job. I mean, what does creating virtual objects have to do with writing efficient algorithms? But curiosity got the better of me, and I dove in headfirst.

The learning curve was steep. I fumbled through the interface, struggling with concepts like extrusion, chamfering, and Boolean operations. It was frustrating, but also exhilarating. For the first time in a while, I felt like a complete novice again.

A New Way of Thinking

As I progressed, something interesting happened. I started to notice parallels between 3D modeling and software engineering. Both require breaking down complex problems into smaller, manageable parts. Both involve thinking about how different components interact with each other.

But 3D modeling also introduced me to new ways of thinking. I had to visualize objects from multiple angles, considering not just functionality but also aesthetics and physical constraints. This spatial reasoning was a muscle I rarely flexed in my coding work.

Expanding Vocabulary and Concepts

Learning 3D modeling also exposed me to a whole new lexicon. Terms like "filleting," "lofting," and "parametric modeling" entered my vocabulary. While these words might not come up in a coding meeting, the concepts behind them – smoothing transitions, creating complex shapes from simple profiles, and building flexible, adjustable models – have surprising applications in software design.

Cross-Pollination of Ideas

The most unexpected benefit came when I returned to my regular coding tasks. I found myself approaching problems with a fresh perspective. The visualization skills I developed helped me better understand and design complex software architectures. The emphasis on user experience in 3D modeling made me more attuned to creating intuitive interfaces in my applications.

Embracing the Unknown

So, to my fellow software engineers, I say this: don't be afraid to venture outside your comfort zone. Pick up a paintbrush, try your hand at woodworking, learn a musical instrument, or yes, give 3D modeling a shot. The skills and perspectives you gain might not be directly applicable to your day-to-day coding, but they'll enrich your problem-solving toolkit in ways you never expected.

Remember, some of the most innovative solutions come from connecting seemingly unrelated ideas. By broadening your horizons, you're not just becoming a more well-rounded individual – you're potentially unlocking new ways to approach the challenges in your primary field.

So go ahead, close your code editor for a bit, and explore something new. Your future self (and your code) will thank you for it.

1. Leveraging Conditional Types for Performance

Conditional types in TypeScript can be used not just for type safety, but also for performance optimization. By using conditional types, we can create more specific and efficient code paths:

type IsArray<T> = T extends any[] ? true : false;

function processData<T>(data: T): IsArray<T> extends true ? number[] : number {
    if (Array.isArray(data)) {
        return data.map(item => item * 2) as any;
    } else {
        return (data as number) * 2;
    }
}

const result1 = processData([1, 2, 3]); // Type: number[]
const result2 = processData(4); // Type: number

This approach allows the compiler to optimize the code based on the input type, potentially leading to better performance. However, it's crucial to balance this with readability, as complex conditional types can be challenging to understand and maintain.

2. Using TypeScript Decorators for Memoization

Decorators can be a powerful tool for adding memoization to methods without cluttering the main code:

function Memoize() {
    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
        const originalMethod = descriptor.value;
        const cache = new Map();

        descriptor.value = function (...args: any[]) {
            const key = JSON.stringify(args);
            if (cache.has(key)) {
                return cache.get(key);
            }
            const result = originalMethod.apply(this, args);
            cache.set(key, result);
            return result;
        };

        return descriptor;
    };
}

class ExpensiveCalculations {
    @Memoize()
    fibonacci(n: number): number {
        if (n <= 1) return n;
        return this.fibonacci(n - 1) + this.fibonacci(n - 2);
    }
}

This approach separates the memoization logic from the business logic, improving both performance and maintainability.

3. Optimizing Object Creation with TypeScript's Utility Types

TypeScript's utility types can be leveraged to create optimized object structures:

type User = {
    id: number;
    name: string;
    email: string;
    preferences: {
        theme: 'light' | 'dark';
        notifications: boolean;
    };
};

type UserUpdateParams = Partial<Omit<User, 'id'>>;

function updateUser(id: number, params: UserUpdateParams) {
    // Implementation here
}

updateUser(1, { name: 'John Doe', preferences: { theme: 'dark' } });

This pattern allows for flexible and type-safe object updates while preventing unnecessary property assignments, potentially improving performance in large-scale applications.

4. Using TypeScript Generics for Compile-Time Optimizations

Generics can be used to create highly optimized functions that the TypeScript compiler can inline:

function swap<T, U>(tuple: [T, U]): [U, T] {
    return [tuple[1], tuple[0]];
}

const result = swap([1, 'two']); // Type: [string, number]

While this might seem simple, for complex operations, such compile-time optimizations can lead to significant performance improvements, especially when used extensively throughout a large codebase.

5. Optimizing Asynchronous Operations with Custom Promises

Creating custom Promise implementations can lead to more efficient asynchronous operations:

class FastPromise<T> implements PromiseLike<T> {
    private result?: T;
    private error?: any;
    private resolve?: (value: T | PromiseLike<T>) => void;
    private reject?: (reason?: any) => void;

    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void) {
        try {
            executor(
                value => {
                    if (this.resolve) this.resolve(value);
                    else this.result = value;
                },
                reason => {
                    if (this.reject) this.reject(reason);
                    else this.error = reason;
                }
            );
        } catch (e) {
            if (this.reject) this.reject(e);
            else this.error = e;
        }
    }

    then<TResult1 = T, TResult2 = never>(
        onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null,
        onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null
    ): PromiseLike<TResult1 | TResult2> {
        return new FastPromise((resolve, reject) => {
            const wrappedResolve = (value: T | PromiseLike<T>) => {
                try {
                    resolve(onfulfilled ? onfulfilled(value as T) : value as any);
                } catch (e) {
                    reject(e);
                }
            };

            const wrappedReject = (reason: any) => {
                if (onrejected) {
                    try {
                        resolve(onrejected(reason));
                    } catch (e) {
                        reject(e);
                    }
                } else {
                    reject(reason);
                }
            };

            if (this.result !== undefined) wrappedResolve(this.result);
            else if (this.error !== undefined) wrappedReject(this.error);
            else {
                this.resolve = wrappedResolve;
                this.reject = wrappedReject;
            }
        });
    }
}

This custom Promise implementation can be more efficient for certain use cases, particularly when dealing with a high volume of rapidly resolving promises. However, it's important to note that such optimizations should be used judiciously, as they can increase code complexity and potentially introduce bugs if not implemented correctly.

Conclusion

While these advanced optimization techniques can significantly boost performance, they often come at the cost of increased complexity. It's crucial to apply them judiciously, always considering the trade-offs between performance gains and code maintainability.

Remember these key points when applying advanced optimizations:

1. Profile First: Always measure performance before and after optimization to ensure the complexity is justified.

2. Document Thoroughly: Complex optimizations should be well-documented, explaining both the how and the why.

3. Encapsulate Complexity: Where possible, encapsulate complex optimizations within well-named functions or classes to preserve the overall readability of your codebase.

4. Consider the Team: Think about how these optimizations will affect your team's ability to understand and maintain the code.

5. Stay Updated: TypeScript and JavaScript are evolving languages. Keep an eye out for new features that might offer simpler ways to achieve the same performance gains.

By carefully balancing these advanced optimization techniques with code maintainability, you can create TypeScript applications that are both high-performing and sustainable in the long term.

In this article, we'll explore various code optimization techniques for TypeScript, discussing how to improve performance without sacrificing readability. We'll cover a range of topics, from basic optimizations to more advanced techniques, always keeping in mind the importance of maintaining clear and understandable code.

Understanding the Balance

Before diving into specific techniques, it's crucial to understand the balance between readability and performance. Readable code is easier to maintain, debug, and extend, which can save time and reduce errors in the long run. On the other hand, performant code ensures that your application runs efficiently, providing a better user experience and potentially reducing resource usage.

The key is to find the sweet spot where your code is both readable and performant. In many cases, you can achieve both goals simultaneously, but sometimes you may need to make trade-offs. When you do, it's important to document your decisions and explain the reasoning behind any optimizations that might make the code less immediately understandable.

Basic Optimization Techniques

Let's start with some basic optimization techniques that can improve performance without significantly impacting readability.

1. Use Appropriate Data Structures

Choosing the right data structure for your task can have a significant impact on performance. For example, using a Set instead of an Array for checking the existence of elements can be much faster for large collections:

// Less efficient for large collections
const array: number[] = [1, 2, 3, 4, 5];
const exists = array.includes(3); // O(n) time complexity

// More efficient for large collections
const set: Set<number> = new Set([1, 2, 3, 4, 5]);
const exists = set.has(3); // O(1) time complexity

2. Avoid Unnecessary Computations

Look for opportunities to avoid redundant calculations. For example, you can cache the length of an array if you're using it multiple times in a loop:

// Less efficient
for (let i = 0; i < array.length; i++) {
  // Do something
}

// More efficient
const length = array.length;
for (let i = 0; i < length; i++) {
  // Do something
}

3. Use TypeScript's Type System

Leverage TypeScript's type system to catch errors at compile-time and provide better editor support. This can lead to fewer runtime errors and more efficient code:

// Less safe and potentially less performant
function add(a: any, b: any) {
  return a + b;
}

// More safe and potentially more performant
function add(a: number, b: number): number {
  return a + b;
}

4. Use Lazy Evaluation

Lazy evaluation can improve performance by delaying the evaluation of an expression until its value is needed. This can be particularly useful for expensive computations:

// Eager evaluation
const expensiveValue = computeExpensiveValue();
if (condition) {
  use(expensiveValue);
}

// Lazy evaluation
let expensiveValue: number | undefined;
if (condition) {
  expensiveValue = computeExpensiveValue();
  use(expensiveValue);
}

5. Optimize Loops

When working with loops, there are several optimizations you can apply:

a. Use for...of for arrays and for...in for object properties:

// Less efficient for arrays
for (let i = 0; i < array.length; i++) {
  const item = array[i];
  // Do something with item
}

// More efficient for arrays
for (const item of array) {
  // Do something with item
}

b. Avoid modifying arrays while iterating over them. Instead, use filter or reduce:

// Less efficient and potentially error-prone
for (let i = 0; i < array.length; i++) {
  if (someCondition(array[i])) {
    array.splice(i, 1);
    i--;
  }
}

// More efficient and safer
array = array.filter(item => !someCondition(item));

6. Use Memoization for Expensive Functions

Memoization is a technique where you cache the results of expensive function calls and return the cached result when the same inputs occur again:

memoize<T extends (...args: any[]) => any>(fn: T): T {
  const cache = new Map();
  return ((...args: any[]) => {
    const key = JSON.stringify(args);
    if (cache.has(key)) {
      return cache.get(key);
    }
    const result = fn(...args);
    cache.set(key, result);
    return result;
  }) as T;
}

const expensiveFunction = memoize((a: number, b: number) => {
  // Expensive computation here
  return a + b;
});

7. Use TypeScript's Advanced Types

TypeScript's advanced types can help you write more performant code by catching errors at compile-time and providing better type inference:

// Using mapped types for efficient object transformation
type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]
};

interface Person {
  name: string;
  age: number;
}

type PersonGetters = Getters<Person>;
// Resulting type:
// {
//   getName: () => string;
//   getAge: () => number;
// }

8. Optimize Memory Usage

Be mindful of memory usage, especially when working with large data structures:

a. Use WeakMap and WeakSet for objects that should be garbage collected when no longer referenced:

const cache = new WeakMap();

function getExpensiveData(obj: object) {
  if (cache.has(obj)) {
    return cache.get(obj);
  }
  const expensiveData = computeExpensiveData(obj);
  cache.set(obj, expensiveData);
  return expensiveData;
}

b. Use generators for working with large sequences of data:

function* fibonacci(): Generator<number> {
  let [a, b] = [0, 1];
  while (true) {
    yield a;
    [a, b] = [b, a + b];
  }
}

const fib = fibonacci();
console.log(fib.next().value); // 0
console.log(fib.next().value); // 1
console.log(fib.next().value); // 1
console.log(fib.next().value); // 2

In this example:

• Generator Function: The fibonacci function is a generator that uses the function* syntax.

• Yield: The yield keyword allows the function to pause execution and return a value, resuming where it left off when next() is called again.

• Memory Efficiency: By generating Fibonacci numbers on-demand, we avoid storing the entire sequence in memory, which is particularly useful if we only need a few numbers at a time.

Benefits of Using Generators:

• Lazy Evaluation: Values are computed as needed, which saves memory and processing time.

• Infinite Sequences: Generators can produce potentially infinite sequences without running out of memory.

9. Use Web Workers for Intensive Computations

For computationally intensive tasks that might block the main thread, consider using Web Workers:

// main.ts
const worker = new Worker('worker.js');

worker.postMessage({ data: 'some data' });

worker.onmessage = (event) => {
  console.log('Received result:', event.data);
};

// worker.ts
self.onmessage = (event) => {
  const result = performExpensiveComputation(event.data);
  self.postMessage(result);
};

Balancing Optimization and Readability

While these optimization techniques can significantly improve your code's performance, it's crucial to maintain a balance with readability. Here are some tips to help you strike that balance:

1. Comment your optimizations: When you apply an optimization that might not be immediately obvious, add a comment explaining what you've done and why.

2. Use meaningful variable and function names: Even when optimizing, continue to use clear and descriptive names that explain the purpose of your code.

3. Extract complex optimizations into separate functions: If an optimization makes a piece of code harder to understand, consider extracting it into a well-named function.

4. Write tests: Comprehensive tests can help ensure that your optimizations don't introduce bugs and can serve as documentation for how the optimized code should behave.

5. Profile before optimizing: Use TypeScript's source maps with browser developer tools or Node.js profiling tools to identify actual bottlenecks before applying optimizations.

6. Consider the trade-offs: Always weigh the performance gain against the cost in terms of code complexity and maintainability.

Conclusion

Optimizing TypeScript code while maintaining readability is a balancing act that requires skill, experience, and careful consideration. By applying the techniques discussed in this article judiciously and always keeping code clarity in mind, you can write TypeScript code that is both performant and maintainable.

Remember that premature optimization can lead to unnecessary complexity, so always measure and profile your code to identify true bottlenecks. When you do optimize, strive to do so in a way that preserves or even enhances the readability of your code.

By following these principles and techniques, you'll be well on your way to writing TypeScript code that is not only fast and efficient but also clear, maintainable, and a joy to work with.

In this article, we'll explore two common questions from Stack Overflow related to TypeORM and provide detailed explanations and solutions to help you master these scenarios.

Question 1: How to Limit Children While Left Joining in TypeORM?

One common requirement in many applications is to fetch data from multiple related entities while limiting the number of child entities returned. This is especially useful when dealing with scenarios like displaying a limited number of comments for a blog post or showing a preview of recent activities.

Here's a solution to this problem using TypeORM:

// 1. Fetch all users
const users = await this.userRepository
  .createQueryBuilder("user")
  .getMany();

// 2. Loop through users and fetch photos with limit
for (const user of users) {
  user.photos = await this.photoRepository
    .createQueryBuilder("photo")
    .where("photo.userId = :userId", { userId: user.id })
    .limit(5) // Set the desired limit here
    .getMany();
}

// Return users with limited photos

In this example, we first fetch all users using the userRepository. Then, we loop through each user and fetch the associated photos using the photoRepository. The key step here is the .limit(5) clause, which limits the number of photos returned to 5 for each user.

This approach involves two separate queries: one to fetch all users, and another to fetch the limited photos for each user. While this solution works, it may not be the most efficient approach, especially if you have a large number of users or photos.

An alternative approach could be to use a single query with a subquery to fetch the limited photos for each user:

const users = await this.userRepository
  .createQueryBuilder("user")
  .leftJoinAndSelect(
    "user.photos",
    "photo",
    "photo.id IN (SELECT p.id FROM Photo p WHERE p.userId = user.id ORDER BY p.createdAt DESC LIMIT 5)"
  )
  .getMany();

In this example, we use the leftJoinAndSelect method to fetch the users and their associated photos in a single query. The subquery SELECT p.id FROM Photo p WHERE p.userId = user.id ORDER BY p.createdAt DESC LIMIT 5 selects the top 5 most recent photos for each user based on the createdAt column. The IN clause then filters the photos to only include those returned by the subquery.

This approach can be more efficient as it reduces the number of database queries, but it may be more complex to write and maintain, especially for more intricate scenarios.

Question 2: How to Use TypeORM's SUM Operator on a Relation's Field?

Another common requirement in applications is to perform aggregations, such as calculating the sum, average, or count of values from related entities. For example, you might want to calculate the total duration of all songs in a playlist.

Here's how you can achieve this using TypeORM:

const playlist = await this.playlistRepository
  .createQueryBuilder("playlist")
  .where("playlist.id = :playlistId", { playlistId })
  .leftJoinAndSelect("playlist.songs", "songs")
  .addSelect("SUM(songs.duration)", "totalDuration")
  .getRawOne();

console.log(playlist.totalDuration);

In this example, we use the createQueryBuilder to build a query for the playlistRepository. We start by filtering for a specific playlist using the where clause.

Next, we use the leftJoinAndSelect method to include the related songs entities in the query. This allows us to access the duration field of each song.

The key step here is the addSelect("SUM(songs.duration)", "totalDuration") clause. This tells TypeORM to calculate the sum of the duration field from all related songs and alias the result as totalDuration.

Finally, we use the getRawOne method to execute the query and retrieve the result as a raw object. The totalDuration property of this object will contain the calculated sum of all song durations for the specified playlist.

It's important to note that getRawOne and getRawMany are used when you need to perform aggregations or other advanced SQL operations that cannot be easily represented using TypeORM's entity model.

Conclusion

TypeORM is a powerful tool that simplifies database interactions in TypeScript and JavaScript applications. However, as your application's requirements grow more complex, you may encounter scenarios where you need to perform advanced queries or manipulations.

In this article, we explored two common questions from Stack Overflow related to TypeORM: limiting the number of child entities returned while left joining, and using the SUM operator on a relation's field. We provided detailed explanations and solutions to help you master these scenarios and unlock the full potential of TypeORM in your applications.

Remember, while TypeORM abstracts away much of the complexities of working with databases, it's still essential to have a solid understanding of SQL and query optimization techniques. By combining the power of TypeORM with your SQL knowledge, you can build robust and efficient applications that meet even the most demanding requirements.

The paradox of choice refers to the psychological phenomenon where too many choices can lead to decision paralysis, anxiety, and dissatisfaction. In the context of software development, constantly chasing the latest and greatest technologies can be a double-edged sword – it can fuel innovation, but it can also hinder productivity and progress.

The Allure of the New

It's easy to get caught up in the hype surrounding new technologies. Developers are naturally curious, and we tend to gravitate towards shiny new tools that promise to make our lives easier. However, this constant pursuit of novelty can come at a cost.

Firstly, learning and adopting new technologies takes time and effort. Every new library or framework you introduce into your project comes with its own learning curve, documentation, and potential compatibility issues. This overhead can quickly add up, slowing down your development process and increasing the cognitive load on your team.

Secondly, the rapidly evolving tech landscape can lead to a sense of FOMO (Fear of Missing Out). We may feel pressured to stay on top of every new trend, constantly questioning our existing tech stack and wondering if we're falling behind. This mindset can breed anxiety and uncertainty, ultimately undermining our confidence in the tools we're using.

The Value of Stability and Consistency

While staying up-to-date with emerging technologies is essential, it's equally important to recognize the value of stability and consistency in your tech stack. By limiting the number of libraries and frameworks you use, you can reap several benefits:

1. Increased Productivity: Familiarity with a well-defined set of tools allows your team to work more efficiently, reducing the time spent on learning and onboarding new technologies.

2. Improved Maintainability: A consistent tech stack makes it easier to maintain and refactor your codebase over time, as your team develops a deep understanding of the tools and their interdependencies.

3. Enhanced Collaboration: When everyone on your team is working with the same set of tools, communication and collaboration become more seamless, reducing the potential for misunderstandings and conflicting approaches.

4. Focused Learning and Expertise: By concentrating your efforts on a limited number of technologies, your team can develop deeper expertise and become true masters of those tools, rather than spreading themselves thin across a vast array of options.

Finding the Right Balance

Of course, this doesn't mean that you should completely ignore new technologies. Innovation is vital in the software development world, and staying too rigid can leave you behind. The key is to strike a balance between embracing innovation and maintaining stability.

One approach is to periodically set aside dedicated time for exploring and evaluating new technologies. This could be a regular "tech exploration day" or a dedicated team tasked with researching and experimenting with emerging tools and libraries. This controlled approach allows you to stay informed without disrupting your core development process.

Additionally, it's essential to establish clear criteria for evaluating and adopting new technologies. Consider factors such as:

• Maturity and Stability: Is the new technology well-established, with an active community and long-term support?

• Compatibility: How well does the new technology integrate with your existing tech stack and infrastructure?

• Learning Curve: How steep is the learning curve, and how much effort will be required to upskill your team?

• Maintenance and Support: Are there adequate resources and documentation available for ongoing maintenance and support?

By carefully weighing the pros and cons of new technologies against your established criteria, you can make informed decisions about when and what to adopt, minimizing the risk of disruption and maximizing the potential benefits.

Embracing Intentional Constraint

In the end, the key to navigating the paradox of choice is to embrace intentional constraint. By consciously limiting your tech stack and being selective about the technologies you adopt, you can avoid the pitfalls of constant churn and indecision.

This doesn't mean stifling innovation or ignoring new developments – it means being intentional and strategic about how you incorporate new tools and libraries into your workflow. By striking the right balance between stability and innovation, you can create a tech stack that is both flexible and maintainable, allowing your team to focus on delivering high-quality software without being constantly distracted by the latest shiny object.

Remember, the goal is not to simply accumulate technologies, but to build robust, scalable, and maintainable systems that meet the needs of your users and your business. By embracing intentional constraint and carefully curating your tech stack, you can achieve that goal while avoiding the paralysis of too many choices.

What is the Mediator Design Pattern?

The Mediator design pattern is a behavioral pattern that defines an object (the mediator) that encapsulates how a set of objects (colleagues) interact with each other. Instead of direct communication between colleagues, all communication is channeled through the mediator, which acts as a central hub for coordinating the interactions.

The pattern involves three main components:

1. Mediator: The central object that handles communication between colleagues.

2. Colleague: The objects that need to communicate with each other.

3. ConcreteMediator: The concrete implementation of the Mediator interface, which defines the communication logic between colleagues.

Here's how the Mediator pattern works:

1. Each colleague knows about the mediator object and communicates with it instead of directly communicating with other colleagues.

2. When a colleague needs to interact with another colleague, it sends a request to the mediator.

3. The mediator receives the request and decides how to handle it, potentially involving other colleagues as needed.

4. The mediator then coordinates the appropriate actions or responses among the relevant colleagues.

By centralizing the communication logic in the mediator, this pattern promotes loose coupling between colleagues, making the system more maintainable, extensible, and testable.

Real-World Use Cases

The Mediator design pattern is commonly used in various scenarios where objects need to communicate with each other in a decoupled and organized manner. Here are some real-world examples:

1. User Interface (UI) Components: In GUI applications, mediators can coordinate the communication between different UI components, such as buttons, text fields, and menus.

2. Chat Applications: Chat applications often use a mediator to handle the communication between multiple participants and manage the message routing and delivery.

3. Middleware Systems: Mediators are commonly used in middleware systems to facilitate the communication between different components or services in a distributed environment.

4. Workflow Management Systems: In workflow management systems, a mediator can coordinate the execution of tasks and manage the flow of data between different processes or activities.

Example

Here's a TypeScript example that demonstrates the implementation of the Mediator pattern in a simplified chat application:

// Mediator interface
interface Mediator {
  sendMessage(message: string, sender: Colleague): void;
}

// Colleague interface
interface Colleague {
  name: string;
  mediator: Mediator;
  receiveMessage(message: string, sender: string): void;
}

// Concrete Mediator
class ChatRoomMediator implements Mediator {
  private colleagues: Colleague[] = [];

  addColleague(colleague: Colleague): void {
    this.colleagues.push(colleague);
    colleague.mediator = this;
  }

  sendMessage(message: string, sender: Colleague): void {
    for (const colleague of this.colleagues) {
      if (colleague !== sender) {
        colleague.receiveMessage(message, sender.name);
      }
    }
  }
}

// Concrete Colleague
class User implements Colleague {
  constructor(public name: string, private mediator: Mediator) {
    this.mediator = mediator;
  }

  sendMessage(message: string): void {
    this.mediator.sendMessage(message, this);
  }

  receiveMessage(message: string, sender: string): void {
    console.log(`${sender} to ${this.name}: ${message}`);
  }
}

// Usage
const mediator = new ChatRoomMediator();

const ayoub = new User('Ayoub', mediator);
const jeremy = new User('Jérémy', mediator);
const bob = new User('Bob', mediator);

mediator.addColleague(ayoub);
mediator.addColleague(jeremy);
mediator.addColleague(bob);

ayoub.sendMessage('Hello, everyone!');
jeremy.sendMessage('Hi, Ayoub! How are you?');

In this example, we have a Mediator interface that defines the sendMessage method for sending messages to colleagues. The Colleague interface defines the receiveMessage method for receiving messages from other colleagues.

The ChatRoomMediator class is a concrete implementation of the Mediator interface, responsible for managing the list of colleagues and forwarding messages to the appropriate recipients.

The User class is a concrete implementation of the Colleague interface, representing a user in the chat application. Users can send messages through the mediator and receive messages from other users.

In the usage example, we create a ChatRoomMediator instance, three User instances (John, Jane, and Bob), and add them as colleagues to the mediator. John sends a message, which is broadcasted to Jane and Bob through the mediator. Jane then sends a message back to John, also via the mediator.

Benefits of the Mediator Pattern

Using the Mediator design pattern offers several benefits:

1. Loose Coupling: By introducing a mediator, the colleagues become loosely coupled, as they no longer need to know about each other's implementation details or communicate directly.

2. Centralized Communication Logic: The communication logic is centralized in the mediator, making it easier to maintain and modify the communication logic without affecting the colleague objects.

3. Extensibility: New colleagues can be added or removed without affecting the existing colleagues, as long as they follow the established communication protocol with the mediator.

4. Reusability: The mediator and colleague objects can be reused in different contexts or applications, as they are decoupled from each other.

5. Simplified Communication: Complex communication workflows between multiple colleagues can be simplified by using a mediator to coordinate the interactions.

However, it's important to remember that introducing a mediator can also add complexity to the system, especially if the mediator becomes too complex or takes on too many responsibilities. As with any design pattern, it's crucial to evaluate the trade-offs and apply the Mediator pattern judiciously based on the specific requirements of your project.

The Mediator design pattern is a powerful tool for facilitating communication between objects while promoting loose coupling and maintainability. By centralizing the communication logic in a mediator object, this pattern helps to create more modular and extensible software systems.

What are the SOLID Principles?

SOLID is an acronym that stands for five fundamental principles of object-oriented programming and design:

1. Single Responsibility Principle

2. Open/Closed Principle

3. Liskov Substitution Principle

4. Interface Segregation Principle

5. Dependency Inversion Principle

Let's dive into each of these principles and see how they can help you write better code!

Single Responsibility Principle

The Single Responsibility Principle (SRP) states that a class should have only one reason to change. In other words, a class should have a single, well-defined responsibility or job. This principle helps to create classes that are focused, easy to understand, and easier to maintain.

Example:

// Violates SRP
class Employee {
  calculatePayroll() { /* ... */ }
  generateReport() { /* ... */ }
  sendEmail() { /* ... */ }
}

// Follows SRP
class PayrollCalculator {
  calculatePayroll() { /* ... */ }
}

class ReportGenerator {
  generateReport() { /* ... */ }
}

class EmailSender {
  sendEmail() { /* ... */ }
}

In the first example, the Employee class has multiple responsibilities, which violates the Single Responsibility Principle. In the second example, each class has a single responsibility, making the code more focused, easier to understand, and easier to maintain.

Open/Closed Principle

The Open/Closed Principle (OCP) states that software entities (classes, modules, functions, etc.) should be open for extension but closed for modification. This means that you should be able to add new features or behaviors without modifying the existing code. This principle promotes code reusability and makes it easier to add new functionality without breaking existing features.

Example:

// Violates OCP
class ShapeCalculator {
  calculateArea(shape: Shape) {
    if (shape instanceof Rectangle) {
      // Calculate area for Rectangle
    } else if (shape instanceof Circle) {
      // Calculate area for Circle
    }
    // ... and so on for other shapes
  }
}

// Follows OCP
interface Shape {
  calculateArea(): number;
}

class Rectangle implements Shape {
  calculateArea() {
    // Calculate area for Rectangle
  }
}

class Circle implements Shape {
  calculateArea() {
    // Calculate area for Circle
  }
}

// You can now add new shapes without modifying the ShapeCalculator
class Triangle implements Shape {
  calculateArea() {
    // Calculate area for Triangle
  }
}

In the first example, the ShapeCalculator class violates the Open/Closed Principle because you need to modify it every time you want to add support for a new shape. In the second example, by introducing an interface and concrete classes for each shape, you can extend the functionality by adding new shape classes without modifying the existing code.

Liskov Substitution Principle

The Liskov Substitution Principle (LSP) states that objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program. In other words, the subclass should not violate the behavior expected from its superclass.

Example:

// Violates LSP
class Rectangle {
  constructor(protected width: number, protected height: number) {}

  setWidth(width: number) {
    this.width = width;
  }

  setHeight(height: number) {
    this.height = height;
  }

  area() {
    return this.width * this.height;
  }
}

class Square extends Rectangle {
  setWidth(width: number) {
    this.width = width;
    this.height = width; // Violates the behavior of a Rectangle
  }

  setHeight(height: number) {
    this.width = height;
    this.height = height; // Violates the behavior of a Rectangle
  }
}

// Follows LSP
interface Shape {
  area(): number;
}

class Rectangle implements Shape {
  constructor(protected width: number, protected height: number) {}

  area() {
    return this.width * this.height;
  }
}

class Square implements Shape {
  constructor(private side: number) {}

  area() {
    return this.side * this.side;
  }
}

In the first example, the Square class violates the Liskov Substitution Principle because it inherits from Rectangle but doesn't adhere to the expected behavior of a rectangle (where the width and height can be set independently). In the second example, by using an interface and separate classes for Rectangle and Square, we ensure that the behavior of each shape is respected and follows the Liskov Substitution Principle.

Interface Segregation Principle

The Interface Segregation Principle (ISP) states that clients should not be forced to depend on interfaces they do not use. In other words, it's better to have many small, specific interfaces than one large, monolithic interface.

Example:

// Violates ISP
interface Worker {
  work(): void;
  eat(): void;
  sleep(): void;
}

class OfficeWorker implements Worker {
  work() { /* ... */ }
  eat() { /* ... */ }
  sleep() { /* ... */ }
}

class Robot implements Worker {
  work() { /* ... */ }
  eat() { /* Not applicable for a Robot */ }
  sleep() { /* Not applicable for a Robot */ }
}

// Follows ISP
interface Worker {
  work(): void;
}

interface FeedableWorker extends Worker {
  eat(): void;
}

interface SleepingWorker extends Worker {
  sleep(): void;
}

class OfficeWorker implements FeedableWorker, SleepingWorker {
  work() { /* ... */ }
  eat() { /* ... */ }
  sleep() { /* ... */ }
}

class Robot implements Worker {
  work() { /* ... */ }
}

In the first example, the Worker interface violates the Interface Segregation Principle because it forces clients like the Robot class to implement methods they don't need (eat and sleep). In the second example, by segregating the interfaces into smaller, more specific ones, we ensure that clients only depend on the interfaces they actually need, following the Interface Segregation Principle.

Dependency Inversion Principle

The Dependency Inversion Principle (DIP) states that high-level modules should not depend on low-level modules; both should depend on abstractions. Additionally, abstractions should not depend on details, but details should depend on abstractions.

Example:

// Violates DIP
class DatabaseRepository {
  constructor(private database: MySQLDatabase) {}

  // ...
}

class MySQLDatabase {
  // ...
}

// Follows DIP
interface Database {
  query(query: string): Result;
  // ...
}

class MySQLDatabase implements Database {
  query(query: string): Result {
    // MySQL-specific implementation
  }
}

class PostgreSQLDatabase implements Database {
  query(query: string): Result {
    // PostgreSQL-specific implementation
  }
}

class DatabaseRepository {
  constructor(private database: Database) {}

  // ...
}

In the first example, the DatabaseRepository class directly depends on the MySQLDatabase class, which is a low-level module. If we want to switch to a different database system, we would need to modify the DatabaseRepository class. In the second example, by introducing an abstraction (Database interface), both the DatabaseRepository and the database implementations depend on this abstraction. This way, we can easily swap out the database implementation without modifying the DatabaseRepository class, following the Dependency Inversion Principle.

Why Use the SOLID Principles?

Following the SOLID principles can bring numerous benefits to your codebase:

1. Maintainability: SOLID code is easier to understand, modify, and extend, making it more maintainable in the long run.

2. Testability: Classes with single responsibilities and loose coupling are easier to unit test, leading to more reliable and robust code.

   Example:

    // Violates SRP and difficult to test
    class UserManager {
      private users: User[] = [];
   
      addUser(user: User) {
        // Validate user
        // Save user to database
        // Send welcome email
      }
   
      // ...
    }
   
    // Follows SRP and easier to test
    class UserValidator {
      validateUser(user: User): boolean {
        // Validate user
      }
    }
   
    class UserRepository {
      saveUser(user: User) {
        // Save user to database
      }
    }
   
    class EmailSender {
      sendWelcomeEmail(user: User) {
        // Send welcome email
      }
    }
   
    class UserManager {
      constructor(
        private validator: UserValidator,
        private repository: UserRepository,
        private emailSender: EmailSender
      ) {}
   
      addUser(user: User) {
        if (this.validator.validateUser(user)) {
          this.repository.saveUser(user);
          this.emailSender.sendWelcomeEmail(user);
        }
      }
    }
   

   In the first example, the UserManager class has multiple responsibilities, making it difficult to test each responsibility in isolation. In the second example, by separating the responsibilities into different classes, we can easily unit test each class independently, leading to more reliable and robust code.

3. Scalability: By adhering to the SOLID principles, your codebase becomes more flexible and scalable, allowing you to add new features or modify existing ones with minimal effort.

4. Reusability: SOLID code promotes the creation of modular and reusable components, reducing duplication and increasing efficiency.

   Example:

    // Violates OCP and DIP
    class EmailSender {
      sendEmail(message: string, recipient: string) {
        // Send email using a specific email service provider
      }
    }
   
    // Follows OCP and DIP
    interface EmailService {
      sendEmail(message: string, recipient: string): void;
    }
   
    class SMTPEmailService implements EmailService {
      sendEmail(message: string, recipient: string) {
        // Send email using SMTP
      }
    }
   
    class HTTPEmailService implements EmailService {
      sendEmail(message: string, recipient: string) {
        // Send email using HTTP API
      }
    }
   
    class EmailSender {
      constructor(private emailService: EmailService) {}
   
      sendEmail(message: string, recipient: string) {
        this.emailService.sendEmail(message, recipient);
      }
    }
   

   In the first example, the EmailSender class is tightly coupled to a specific email service provider, making it difficult to switch providers or reuse the email sending functionality elsewhere. In the second example, by introducing an abstraction (EmailService interface) and implementing different email service providers, we can easily swap out the email service implementation or reuse the EmailSender class with different email services, promoting code reusability and extensibility.

5. Collaboration: When working in a team, SOLID principles help ensure that the codebase is consistent, readable, and easier for multiple developers to work on simultaneously.

   Example:

    // Violates SRP and ISP
    class UserService {
      private users: User[] = [];
   
      addUser(user: User) {
        // Validate user
        // Save user to database
        // Send welcome email
      }
   
      updateUser(userId: string, updatedUser: User) {
        // Find user by ID
        // Update user in database
        // Send update notification email
      }
   
      deleteUser(userId: string) {
        // Find user by ID
        // Delete user from database
        // Send deletion confirmation email
      }
   
      // ...
    }
   
    // Follows SOLID principles
    interface UserRepository {
      addUser(user: User): void;
      updateUser(userId: string, updatedUser: User): void;
      deleteUser(userId: string): void;
      // ...
    }
   
    interface EmailService {
      sendWelcomeEmail(user: User): void;
      sendUpdateNotificationEmail(user: User): void;
      sendDeletionConfirmationEmail(userId: string): void;
    }
   
    class UserService {
      constructor(
        private userRepository: UserRepository,
        private emailService: EmailService
      ) {}
   
      addUser(user: User) {
        this.userRepository.addUser(user);
        this.emailService.sendWelcomeEmail(user);
      }
   
      updateUser(userId: string, updatedUser: User) {
        this.userRepository.updateUser(userId, updatedUser);
        this.emailService.sendUpdateNotificationEmail(updatedUser);
      }
   
      deleteUser(userId: string) {
        this.userRepository.deleteUser(userId);
        this.emailService.sendDeletionConfirmationEmail(userId);
      }
    }
   

   In the first example, the UserService class has multiple responsibilities and violates the Single Responsibility Principle and the Interface Segregation Principle, making it difficult for multiple developers to work on it simultaneously. In the second example, by separating responsibilities into different interfaces and classes, and adhering to the SOLID principles, the codebase becomes more consistent, readable, and easier for multiple developers to collaborate on.

   Conclusion

   Remember, the SOLID principles are not rigid rules but rather guidelines to help you write better code. As you gain more experience, you'll develop a deeper understanding of when and how to apply these principles effectively.

   So, the next time you're writing code, take a moment to think about the SOLID principles. Your future self (and your teammates) will thank you for it!

Enhanced Project Visibility and Control At its core, Scrum provides a lightweight process for managing iterative software delivery. It prescribes short development cycles called Sprints, timeboxed to 1-4 weeks, with specific roles, artifacts, and ceremonies to keep work on track. Even with just 2 developers, implementing these Scrum practices brings much-needed structure, focus, and transparency to what can otherwise quickly become a chaotic and ad-hoc process.

The Scrum Master role, often taken on by one of the developers for a small team, is tasked with facilitating key events like Daily Standups, Sprint Planning, and Sprint Retrospectives. These brief but critical checkpoints enable real-time communication of status, coordination of work, continuous improvement, and early mitigation of risks. Rather than developers working in a silo only to struggle to integrate later, Scrum ensures full visibility of what work is being tackled and what impediments exist.

Improved Management Expertise By adopting Scrum, even junior developers gain firsthand experience in core project management skills like setting specific and measurable goals (Sprint Goals), estimating and prioritizing work (Sprint Backlog), tracking progress incrementally, and constantly inspecting and adapting. These lean-agile management competencies are invaluable for any developer's long-term career growth.

Additionally, Scrum creates a natural incentive to learn specialized tools designed to support agile processes. Popular agile project management platforms like Jira, Azure DevOps, or VersionOne provide digital Scrum boards for visualizing Sprint Backlogs and Work in Progress. They offer seamless tracking of requirements, user stories, tasks, defects, and more across the development lifecycle. Being hands-on with these tools enhances modern tech skillsets.

Customer-Centric Mindset A key tenet of agile is delivering the highest value, and highest priority features first through ruthless prioritization of work. Scrum heavily emphasizes stakeholder involvement, frequent inspection of working software, and continuous re-planning to ensure alignment with evolving requirements. While this customer-centric focus is essential for any team, it is especially formative for small startups trying to build a minimum viable product and laser focus on what matters most to users.

Lasting Benefits Even if a development effort eventually transitions to Scrum at scale with multiple teams, having experienced core Scrum roles, artifacts, events, and principles firsthand provides a major head start and avoids a steep learning curve. More importantly, adopting lean techniques early inculcates practices for frequent delivery of working software, driving faster ROI and success.

In summary, while meant to be lightweight, implementing Scrum brings rigor, visibility, focus, and continuous improvement that can be game-changing even for the smallest development teams. It builds better products, and better developers, and lays the foundation for scaling agile practices as an organization grows.

What is the Memento Design Pattern?

The Memento pattern is like a time machine for objects. It allows you to capture the internal state of an object at a specific point in time, and then restore that state later if needed. This is particularly useful when you need to implement features like undo/redo operations, checkpointing, or transaction-based systems.

The pattern involves three main players:

1. Originator: The object whose state needs to be saved and restored. Think of it as the object you want to travel back in time for.

2. Memento: A snapshot or memento of the Originator's internal state at a particular point in time. This is like a time capsule containing all the information needed to restore the object to that state.

3. Caretaker: An object responsible for storing and retrieving Mementos. It's like a time-traveling storage facility that keeps all the time capsules safe.

Here's how it works:

1. The Originator creates a Memento, capturing its current internal state.

2. The Originator passes the Memento to the Caretaker for safekeeping.

3. When needed, the Originator can request the Caretaker to return the Memento, allowing it to restore its previous state.

By separating the responsibilities of state capture, storage, and restoration, the Memento pattern adheres to the principles of encapsulation and information hiding, keeping the internal workings of the objects hidden from the outside world.

Real-World Examples

The Memento pattern is used in various applications and domains, making our lives a little easier:

1. Video Games: Many video games implement checkpoints or save points using the Memento pattern, allowing players to save their progress and resume from that point later, without having to start from the beginning every time.

2. Undo/Redo Operations: Text editors, image editors, and other software applications often implement undo/redo functionality using the Memento pattern, allowing users to correct mistakes or explore different options easily.

3. Transaction-based Systems: In database systems, the Memento pattern can be used to implement transaction rollbacks or savepoints, ensuring data integrity and consistency.

4. Snapshots/Backups: Cloud platforms and virtualization tools frequently use the Memento pattern to capture and restore snapshots of virtual machine or container states, providing a safeguard against data loss or system failures.

5. Version Control Systems: Version control systems like Git use a similar approach to record and restore changes to source code files, allowing developers to travel back in time and see how their code evolved.

A Simple Example in TypeScript

To help you understand the Memento pattern better, let's look at a simple TypeScript example of a video game character:

// Originator
class GameCharacter {
  private health: number;
  private mana: number;
  private position: { x: number; y: number };

  constructor(health: number, mana: number, x: number, y: number) {
    this.health = health;
    this.mana = mana;
    this.position = { x, y };
  }

  public takeHit(damage: number): void {
    this.health -= damage;
  }

  public useMana(amount: number): void {
    this.mana -= amount;
  }

  public move(x: number, y: number): void {
    this.position.x = x;
    this.position.y = y;
  }

  public createMemento(): GameCharacterMemento {
    return new GameCharacterMemento(this.health, this.mana, this.position.x, this.position.y);
  }

  public restoreFromMemento(memento: GameCharacterMemento): void {
    this.health = memento.getHealth();
    this.mana = memento.getMana();
    this.position.x = memento.getX();
    this.position.y = memento.getY();
  }
}

// Memento
class GameCharacterMemento {
  private health: number;
  private mana: number;
  private x: number;
  private y: number;

  constructor(health: number, mana: number, x: number, y: number) {
    this.health = health;
    this.mana = mana;
    this.x = x;
    this.y = y;
  }

  public getHealth(): number {
    return this.health;
  }

  public getMana(): number {
    return this.mana;
  }

  public getX(): number {
    return this.x;
  }

  public getY(): number {
    return this.y;
  }
}

// Caretaker
class GameCharacterCaretaker {
  private mementos: GameCharacterMemento[] = [];

  public addMemento(memento: GameCharacterMemento): void {
    this.mementos.push(memento);
  }

  public getMemento(index: number): GameCharacterMemento {
    return this.mementos[index];
  }
}

// Usage
const character = new GameCharacter(100, 50, 0, 0);
const caretaker = new GameCharacterCaretaker();

caretaker.addMemento(character.createMemento());

character.takeHit(20);
character.useMana(10);
character.move(5, 5);

// Encounter a difficult enemy, restore to previous state
character.restoreFromMemento(caretaker.getMemento(0));
console.log(`Health: ${character.getHealth()}, Mana: ${character.getMana()}, Position: (${character.getX()}, ${character.getY()})`);
// Output: Health: 100, Mana: 50, Position: (0, 0)

In this example, the GameCharacter class is the Originator, responsible for creating and restoring Mementos. The GameCharacterMemento class represents the Memento, capturing the state (health, mana, and position) of the Originator. The GameCharacterCaretaker class acts as the Caretaker, storing and retrieving Mementos.

We start with an initial state for the game character, create a Memento, and store it in the Caretaker. Then, we simulate some gameplay actions, such as taking damage, using mana, and moving the character. When we encounter a difficult enemy, we use the Caretaker to retrieve the initial Memento and restore the character to its previous state, effectively undoing the actions taken since the last checkpoint.

Why Use the Memento Pattern?

The Memento pattern offers several benefits:

1. Encapsulation: The pattern ensures that the internal state of an object is not exposed, maintaining encapsulation and information hiding principles.

2. Separation of Concerns: The responsibilities of state capture, storage, and restoration are separated into different components, promoting loose coupling and code organization.

3. Undo/Redo Support: The pattern facilitates implementing undo/redo functionality in applications, providing a familiar and expected user experience.

4. State Rollback: In transaction-based systems or long-running processes, the Memento pattern enables rollbacks or checkpointing, ensuring data integrity and consistency.

5. Versioning and Backups: The pattern can be used to capture and restore snapshots or versions of objects, enabling features like version control or system backups.

However, it's important to consider potential drawbacks, such as increased memory usage for storing Mementos and the need for additional code complexity to implement the pattern effectively.

The Memento design pattern is a powerful tool for capturing and restoring object states, enabling features like undo/redo operations, checkpointing, and transaction rollbacks. By adhering to encapsulation principles and separating concerns, it provides a flexible and maintainable solution for managing object states in various applications, making our lives a little easier, one time capsule at a time!

Design Thinking: Understanding the User

Design thinking is an iterative user-centered approach to problem-solving. It emphasizes empathy, understanding user needs, and brainstorming creative solutions. Here's the basic framework:

1. Empathize: Research your target users, their pain points, and desired outcomes.

2. Define: Clearly define the core problem you're trying to solve for the user.

3. Ideate: Generate a wide range of potential solutions through brainstorming and prototyping.

4. Prototype: Develop low-fidelity, quick prototypes to test your ideas with real users.

5. Test: Gather feedback from users and iterate on your prototypes based on their responses.

Design thinking ensures the final product is not just technically sound but also addresses the user's needs effectively.

TDD: Building with Confidence

TDD, on the other hand, focuses on the technical implementation. It's a development approach where you write failing tests before writing any code. Here's the core cycle:

1. Red: Write a unit test that currently fails because the code you'll be writing doesn't exist yet.

2. Green: Write the minimal amount of code necessary to make the failing test pass.

3. Refactor: Refactor your code to improve readability, maintainability, and overall design without breaking the existing tests.

This cycle ensures your code is constantly validated and working as intended. TDD promotes clean code design, early bug detection, and a strong safety net for refactoring.

The Magic Intersection: User-Centric Design Meets Reliable Code

So how can we combine these seemingly disparate approaches? Here's the beauty:

• TDD Informs Design Thinking: By writing failing tests first in TDD, you're essentially defining the desired behavior of your code. This aligns perfectly with the "Define" stage of design thinking. For example, imagine you're designing a feature for a music streaming app. A failing TDD test might specify that "pressing the play button should initiate playback of the selected song." This directly translates to a core user need: "users want to easily play music." By identifying these functionalities upfront, TDD ensures your solution addresses the core user needs identified earlier.

• Design Thinking Guides TDD: Design thinking helps break down complex features into smaller, user-focused functionalities. This translates perfectly to writing focused and well-defined TDD tests that target specific user interactions. Let's revisit the music streaming app example. Design thinking might reveal that users want to quickly access their liked songs. This translates to a focused TDD test ensuring the "liked songs playlist loads correctly when selected."

• Rapid Prototyping with Confidence: The low-fidelity prototypes used in design thinking can be quickly transformed into functional prototypes using code written with TDD. The existing tests ensure the core functionality works as expected (playing music, loading playlists), allowing you to focus on the user interface and experience in the prototype. Imagine a basic prototype with buttons and a song list. Since the TDD tests guarantee the underlying functionality, you can concentrate on refining the user interface without worrying about breaking the core playback functionality.

• Iterative Refinement: Both design thinking and TDD are inherently iterative. Design thinking emphasizes testing prototypes with users and iterating based on feedback. TDD's "Red-Green-Refactor" cycle encourages continuous improvement of the code through refactoring. This combined approach fosters a development process that is constantly adapting to user needs (through design thinking iterations) and technical realities (through TDD's focus on clean, tested code).

The Takeaway: A More Powerful Approach

By combining design thinking's user focus with TDD's code-centric approach, you create a development process that's both creative and reliable. You can confidently explore solutions that address user needs while ensuring the underlying code is well-structured, tested, and easy to maintain. This empowers developers to experiment more freely, leading to more innovative and user-centric software solutions.

Additional Considerations

While this approach offers numerous benefits, it's important to acknowledge potential challenges:

• Learning Curve: Both design thinking and TDD require investment in learning and practice.

• Team Dynamics: Successful implementation might require adjustments in team collaboration between designers and developers.

However, the potential rewards in terms of user satisfaction, development efficiency, and code quality make this a worthwhile pursuit for development teams.

The Players:

• Proxy: This is the middleman, providing an interface similar to the real object but potentially with additional logic or restrictions.

• Real Subject: This is the actual object that the client ultimately wants to interact with.

• Client: This is any part of your code that needs to access the real object. The client interacts with the proxy instead of the real subject directly.

Why Use the Proxy Pattern?

The Proxy pattern offers several advantages:

• Controlled Access: You can restrict access to the real object, ensuring only authorized clients can interact with it. This is useful for protecting sensitive data or functionalities.

• Enhanced Functionality: The proxy can intercept requests to the real object and add additional functionalities before or after delegating the call. This might involve logging, security checks, or performance optimizations.

• Lazy Loading: The proxy can delay the creation of the real object until it's actually needed. This can improve performance, especially for expensive objects or those that are not always required.

• Hiding Complexity: The proxy can shield the client from the complexities of the real object's interface. This simplifies the client code and makes it more maintainable.

Real-World Use Cases:

The Proxy pattern has various applications across software development:

• Security: A proxy can be used to authenticate users before granting access to protected resources.

• Caching: A proxy can cache frequently accessed data from the real object, improving performance.

• Remote Objects: When dealing with remote objects located on different servers, a local proxy can handle communication details, hiding network complexities from the client.

• Virtual Proxies: In image processing, a virtual proxy can represent a large image without loading it into memory until it's displayed, saving resources.

Here's an example:

// Subject Interface (What the proxy stands in for)

interface ExpensiveObject {
  loadData(): string;
}

// Real Subject (The actual object with potentially expensive operations)

class RealExpensiveObject implements ExpensiveObject {
  private data: string | null = null;

  loadData(): string {
    if (!this.data) {
      console.log('Loading data from external source...');
      this.data = 'This is some expensive data!';
    }
    return this.data;
  }
}

// Proxy Class (The intermediary)

class ExpensiveObjectProxy implements ExpensiveObject {
  private realObject: ExpensiveObject;

  constructor() {
    this.realObject = new RealExpensiveObject();
  }

  loadData(): string {
    if (this.shouldLoad()) {
      return this.realObject.loadData();
    } else {
      console.log('Using cached data');
      return 'Cached data'; // Simulate cached data
    }
  }

  private shouldLoad(): boolean {
    // Implement logic to determine if data needs to be loaded again
    // Here, we simulate a simple check based on a flag
    return !localStorage.getItem('expensiveDataLoaded');
  }
}

// Usage Example

const expensiveProxy = new ExpensiveObjectProxy();

console.log(expensiveProxy.loadData()); // Output: Loading data from external source..., This is some expensive data!
localStorage.setItem('expensiveDataLoaded', 'true');

console.log(expensiveProxy.loadData()); // Output: Using cached data

In this example, the ExpensiveObjectProxy acts as an intermediary for the RealExpensiveObject. The proxy implements the same interface (ExpensiveObject) but controls access to the real object's loadData method. Here, the proxy introduces caching behavior. It checks if the data has already been loaded (simulated with localStorage) and avoids calling the potentially expensive loadData method on the real object if unnecessary.

This demonstrates the core idea of the Proxy pattern: providing a controlled interface to another object, potentially adding functionalities like access control, caching, or lazy loading.

Conclusion:

The Proxy design pattern provides a flexible way to manage access and enhance functionalities when working with objects in your code. By introducing a middleman (the proxy), you gain more control over object interactions and improve the overall maintainability and security of your software.