<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Ahmed Faruk Monkwo on Medium]]></title>
        <description><![CDATA[Stories by Ahmed Faruk Monkwo on Medium]]></description>
        <link>https://medium.com/@ahmedfaruk888?source=rss-1d481d6f493f------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*reF31kCDYQCXtKHZTYGaWA.jpeg</url>
            <title>Stories by Ahmed Faruk Monkwo on Medium</title>
            <link>https://medium.com/@ahmedfaruk888?source=rss-1d481d6f493f------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 18:22:08 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ahmedfaruk888/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Nest Js — Zero to Hero]]></title>
            <link>https://medium.com/@ahmedfaruk888/nest-js-zero-to-hero-306082e6b63e?source=rss-1d481d6f493f------2</link>
            <guid isPermaLink="false">https://medium.com/p/306082e6b63e</guid>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[nestjs-tutorial]]></category>
            <category><![CDATA[nestjs]]></category>
            <category><![CDATA[nodejs]]></category>
            <dc:creator><![CDATA[Ahmed Faruk Monkwo]]></dc:creator>
            <pubDate>Mon, 30 Jun 2025 01:10:27 GMT</pubDate>
            <atom:updated>2025-09-17T16:26:55.236Z</atom:updated>
            <content:encoded><![CDATA[<h3>Microservice With Nest Js — Zero to Hero</h3><blockquote>Nest (NestJS) is a framework for building efficient, scalable <a href="https://nodejs.org/">Node.js</a> server-side applications. It uses progressive JavaScript and of-course it is built with and fully supports <a href="http://www.typescriptlang.org/">TypeScript</a> (yet still enables developers to code in pure JavaScript) and combines elements of OOP (Object Oriented Programming), FP (Functional Programming), and FRP (Functional Reactive Programming).</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/622/1*qovCvWJP49v0MOZIDmiK1A.png" /></figure><p>NestJS uses <a href="https://expressjs.com/">express.js</a> under the hood by default. if you are more interested in using NestJs with <a href="https://fastify.dev/">fastify webserver</a>, feel free to check out my upcoming series on that, you will love it 🤣, and in-case you don’t, challenge me to write on any technical series, and I will write about it.</p><h4>Table of Content</h4><ul><li><a href="https://medium.com/p/67ac41cd85ce/edit">Building REST APIs: Controllers, Routes, and Module Architecture</a></li><li>Database Integration: PostgreSQL Setup with TypeORM Configuration</li><li>User Authentication: Implementing bcrypt, Passport, JWT, and Cookie-based Auth</li><li>Input Validation and Exception Handling Best Practices</li><li>Response Transformation Using Custom Interceptors</li><li>Understanding Dependency Injection and Modular Architecture</li><li>Database Relationships: Postgres and TypeORM Integration</li><li>Unit Testing Fundamentals and Implementation</li><li>Integration Testing for Services and Controllers</li><li>File Upload Management with Amazon S3 Public Storage</li><li>Secure File Handling with Amazon S3 Private Buckets</li><li>Search Implementation with Elasticsearch Integration</li><li>Token Refresh Strategy Using JWT Authentication</li><li>Database Performance Optimization with PostgreSQL Indexes</li><li>Transaction Management in PostgreSQL and TypeORM</li><li>Working with PostgreSQL Array Data Types</li><li>Pagination Strategies: Offset and Cursor-based Approaches</li><li>Microservices Architecture Fundamentals</li><li>Inter-service Communication with RabbitMQ Message Queues</li><li>Microservice Integration Using gRPC Protocol</li><li>Command Query Responsibility Segregation (CQRS) Patterns</li><li>JSON Data Storage with PostgreSQL and TypeORM</li><li>Performance Enhancement with In-Memory Caching</li><li>Redis Caching and Node.js Cluster Deployment</li><li>Automated Email Scheduling with Cron Jobs and Nodemailer</li><li>Real-time Messaging with WebSocket Implementation</li><li>GraphQL Fundamentals: Queries, Mutations, and Security</li><li>Solving GraphQL N+1 Query Problems</li><li>Live Data Updates with GraphQL Subscriptions</li><li>Custom GraphQL Scalar Type Implementation</li><li>Enhanced Security with Two-Factor Authentication</li><li>Background Task Processing with Queue Systems</li><li>Session-based Authentication vs JWT Tokens</li><li>Payment Integration: Stripe and React Frontend</li><li>Payment Method Storage with Stripe for Recurring Use</li><li>Subscription Management and Recurring Billing with Stripe</li><li>Webhook Implementation for Stripe Event Handling</li><li>Email Verification and Confirmation Workflows</li><li>SMS Integration and Phone Verification with Twilio</li><li>OAuth Implementation with Google Authentication</li><li>NoSQL Database Integration with MongoDB</li><li>MongoDB Relationship Patterns and Implementation</li><li>Virtual Properties in MongoDB with Mongoose</li><li>MongoDB Transaction Handling and Management</li><li>Pagination Implementation with MongoDB and Mongoose</li><li>Index Optimization for MongoDB and Mongoose</li><li>HTTP Method Implementation: PUT vs PATCH with MongoDB</li><li>Application Logging with Built-in Logger and TypeORM</li><li>Health Monitoring with Terminus and Datadog Integration</li><li>API Documentation Generation using Compodoc and JSDoc</li><li>Soft Delete Implementation in PostgreSQL with TypeORM</li><li>Binary Data Storage within PostgreSQL Databases</li><li>Server-side File Upload Handling and Processing</li><li>Role-based Access Control and Permission Management</li><li>HTTP Caching with ETag Implementation for Bandwidth Optimization</li><li>Monorepo Management</li><li>API Documentation with OpenAPI and Swagger Integration</li><li>Resolving and Preventing Circular Dependencies</li><li>Interactive Development with REPL Integration</li><li>Database Schema Evolution with TypeORM Migrations</li><li>Dynamic Module Creation and Configuration</li><li>Feature Flag Implementation and Management</li><li>Raw SQL Query Execution with PostgreSQL</li><li>One-to-One Relationship Modeling with Raw SQL</li><li>Many-to-One Relationship Design using Raw SQL</li><li>Many-to-Many Relationship Implementation with Raw SQL</li><li>Transaction Management using Raw SQL Queries</li><li>Advanced Pagination with Raw SQL Implementation</li><li>Statistical Analysis using SQL Aggregate Functions</li><li>Search Functionality with Pattern Matching in Raw SQL</li><li>Data Modification: PUT and PATCH with Raw SQL</li><li>Soft Delete Implementation using Raw SQL</li><li>Database Index Creation with Raw SQL</li><li>Full-text Search with PostgreSQL tsvector and Raw SQL</li><li>Advanced Filtering with SQL Subqueries</li><li>Database Constraint Definition with Raw SQL</li><li>Logging Integration when using Raw SQL Queries</li><li>Unit Testing Strategies for Raw SQL Projects</li><li>Integration Testing for Raw SQL Applications</li><li>Performance Boost: Replacing Express with Fastify</li><li>Advanced SQL Join Operations and Use Cases</li><li>Containerization with Docker and Docker Compose</li><li>Development Environment Enhancement with Docker Compose</li><li>Cloud Deployment with Amazon ECS and RDS</li><li>Scalable Deployment with AWS Load Balancer</li><li>Continuous Integration/Deployment with ECS and GitHub Actions</li><li>Automated Testing in CI/CD with GitHub Actions</li><li>Log Management and Monitoring with Amazon CloudWatch</li><li>Health Check Implementation with Terminus and ECS</li><li>Auto-scaling Application Instances with Amazon ECS</li><li>HTTPS Configuration with Route 53 and AWS Certificate Manager</li><li>Secure Configuration Management with AWS Secrets Manager</li><li>API Versioning Strategies and Implementation</li><li>Cross-Origin Resource Sharing (CORS) Configuration</li><li>Video Upload and Streaming Implementation</li><li>Type-safe Database Queries with Kysely and PostgreSQL</li><li>One-to-One Relationships with Kysely Query Builder</li><li>Many-to-One Relationships using PostgreSQL and Kysely</li><li>Many-to-Many Relationships with Kysely and PostgreSQL</li><li>Transaction Management with Kysely SQL Builder</li><li>SQL Constraint Handling with Kysely</li><li>Pagination Implementation with Kysely Query Builder</li><li>Database Performance Enhancement with Kysely Indexes</li><li>Array Data Handling with PostgreSQL and Kysely</li><li>JSON Data Management with PostgreSQL and Kysely</li><li>Soft Delete Implementation with Kysely SQL Builder</li><li>Secure Logging: Preventing Sensitive Data Exposure</li><li>Unit Testing with PostgreSQL and Kysely</li><li>Date and Time Management in PostgreSQL with Kysely</li><li>Foreign Key Relationships and Referential Actions in PostgreSQL</li><li>Command Line Interface Development with Nest Commander</li><li>Application Security Enhancement with Helmet Middleware</li><li>Dependency Injection Scope Management</li><li>Express 5: New Features and Improvements</li><li>Request Rate Limiting with Throttler Implementation</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=306082e6b63e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Linux for Rookies: A Comprehensive Guide for Software Engineers and DevOps]]></title>
            <link>https://medium.com/@ahmedfaruk888/linux-for-rookies-a-comprehensive-guide-for-software-engineers-and-devops-35075c97f883?source=rss-1d481d6f493f------2</link>
            <guid isPermaLink="false">https://medium.com/p/35075c97f883</guid>
            <category><![CDATA[linux-commands]]></category>
            <category><![CDATA[process-management]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[centos]]></category>
            <category><![CDATA[ubuntu]]></category>
            <dc:creator><![CDATA[Ahmed Faruk Monkwo]]></dc:creator>
            <pubDate>Mon, 10 Feb 2025 17:16:53 GMT</pubDate>
            <atom:updated>2025-02-10T17:16:53.997Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*oNcfBK2-gfFtaJpd" /><figcaption>Photo by <a href="https://unsplash.com/@6heinz3r?utm_source=medium&amp;utm_medium=referral">Gabriel Heinzer</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><blockquote>Below is a comprehensive guide that explains Linux from the ground up — covering its benefits for software engineers and DevOps professionals, an introductory overview for beginners, and a detailed look at essential Linux commands with their descriptions and usage examples<em>.</em></blockquote><p>Linux has evolved from a hobbyist project into one of the most important operating systems powering servers, embedded devices, cloud infrastructure, and even desktops. For software engineers and DevOps professionals, Linux isn’t just another OS — it’s the backbone of modern development, automation, and deployment practices. In this guide, we’ll explore what Linux is, why it matters for technical professionals, and provide a beginner-friendly overview alongside practical command-line examples.</p><h3>1. Introduction to Linux</h3><h3>What Is Linux?</h3><p>Linux is an open-source operating system kernel first released by Linus Torvalds in 1991. Unlike proprietary operating systems, Linux’s source code is freely available, allowing developers to modify and distribute their own versions. The term “Linux” often refers to the combination of the Linux kernel with a collection of open-source software (libraries, utilities, and applications) to form a complete operating system — commonly known as a Linux distribution (distro).</p><h3>Linux Distributions</h3><p>Different distributions target varied needs. Popular examples include:</p><ul><li><strong>Ubuntu:</strong> User-friendly and widely adopted in both development and production.</li><li><strong>Fedora:</strong> Known for its cutting-edge features and focus on innovation.</li><li><strong>CentOS/RHEL:</strong> Preferred for enterprise environments due to their stability and long-term support.</li><li><strong>Debian:</strong> Valued for its robustness and community-driven development.</li><li><strong>Arch Linux:</strong> Favored by enthusiasts for its simplicity and customization options.</li></ul><p>Each distro packages software in a slightly different way, often using tools like APT (Debian/Ubuntu) or YUM/DNF (Fedora/CentOS).</p><h3>2. Benefits of Linux for Software Engineers and DevOps</h3><h4>Open Source and Customizability</h4><ul><li><strong>Transparency:</strong> Open-source code means you can inspect, modify, and optimize the OS to meet your specific needs.</li><li><strong>Community-Driven:</strong> A vast community supports Linux with documentation, tutorials, and troubleshooting advice.</li></ul><h4>Stability and Security</h4><ul><li><strong>Rock-Solid Performance:</strong> Linux is known for its stability, making it ideal for long-running servers and critical applications.</li><li><strong>Security:</strong> With regular updates and a proactive security community, Linux systems are well-equipped to handle modern threats. Tools like SELinux or AppArmor enhance security at the OS level.</li></ul><h4>Scripting and Automation</h4><ul><li><strong>Command-Line Proficiency:</strong> Mastering the Linux shell opens the door to powerful scripting capabilities (e.g., using Bash, Python, or Perl) for automating repetitive tasks.</li><li><strong>DevOps Integration:</strong> Automation is at the heart of DevOps. Linux’s extensive toolchain — ranging from Docker and Kubernetes to Ansible, Jenkins, and Git — streamlines continuous integration, deployment, and infrastructure management.</li></ul><h4>Environment Consistency</h4><ul><li><strong>Uniformity Across Environments:</strong> Many cloud servers and containers run Linux, ensuring consistency from development to production. This reduces the “it works on my machine” problem.</li><li><strong>Ecosystem Support:</strong> Most modern development tools, monitoring systems, and container orchestration platforms are built with Linux as the foundation.</li></ul><h3>3. A Beginner’s Introduction to the Linux Operating System</h3><h4>Getting Started with Linux</h4><p>For newcomers, Linux might seem daunting due to its command-line focus. However, modern distributions come with graphical interfaces and user-friendly installers. Here’s how to begin:</p><ul><li><strong>Installation:</strong> Choose a beginner-friendly distro like Ubuntu or Linux Mint. These come with comprehensive installers and community support.</li><li><strong>Desktop Environments:</strong> Popular desktop environments include GNOME, KDE Plasma, and XFCE, offering different balances of performance and aesthetics.</li><li><strong>File System Layout:</strong> Familiarize yourself with the Linux file system hierarchy:</li><li>/: The root directory.</li><li>/home: User home directories.</li><li>/etc: Configuration files.</li><li>/var: Variable files like logs.</li><li>/usr: User-installed applications and libraries.</li></ul><h4>Learning the Shell</h4><p>The Linux shell (commonly Bash) is a powerful interface for interacting with the system. Understanding basic shell commands is a cornerstone for further exploration and automation.</p><h3>4. Essential Linux Commands: Descriptions and Usage</h3><p>Below is a curated list of important Linux commands, complete with descriptions and usage examples:</p><h4>File and Directory Management</h4><ul><li><strong>ls</strong><br><strong>Description:</strong> Lists directory contents.<br><strong>Usage:</strong></li></ul><pre>ls             # Lists files in the current directory.<br>ls -l          # Long format listing (detailed information).<br>ls -a          # Includes hidden files.</pre><p><strong>cd</strong><br><strong>Description:</strong> Changes the current working directory.<br><strong>Usage:</strong></p><pre>cd /path/to/directory   # Navigates to the specified directory.<br>cd ~                    # Goes to the home directory.<br>cd -                    # Switches to the previous directory.</pre><p><strong>pwd</strong><br><strong>Description:</strong> Prints the current working directory.<br><strong>Usage:</strong></p><pre>pwd   # Displays the full path of the current directory.</pre><p><strong>mkdir and </strong><strong>rmdir</strong><br><strong>Description:</strong> mkdir creates directories; rmdir removes empty directories.<br><strong>Usage:</strong></p><pre>mkdir myfolder          # Creates a directory named &#39;myfolder&#39;.<br>rmdir myfolder          # Removes the directory if it’s empty.</pre><p><strong>touch</strong><br><strong>Description:</strong> Creates an empty file or updates the timestamp of an existing file.<br><strong>Usage:</strong></p><pre>touch filename.txt      # Creates a new file or updates an existing file&#39;s timestamp.</pre><p><strong>cp, </strong><strong>mv, and </strong><strong>rm</strong><br><strong>Description:</strong> cp copies files/directories; mv moves or renames them; rm deletes them.<br><strong>Usage:</strong></p><pre>cp source.txt destination.txt     # Copies a file.<br>mv oldname.txt newname.txt          # Renames or moves a file.<br>rm filename.txt                     # Deletes a file.<br>rm -r foldername                    # Recursively deletes a directory and its contents.</pre><h4>Viewing and Editing Files</h4><p><strong>cat</strong><br><strong>Description:</strong> Concatenates and displays file content.<br><strong>Usage:</strong></p><pre>cat file.txt         # Displays the content of &#39;file.txt&#39;.</pre><p><strong>less and </strong><strong>more</strong><br><strong>Description:</strong> Paginate through text files one page at a time.<br><strong>Usage:</strong></p><pre>less file.txt        # Opens &#39;file.txt&#39; for paginated viewing.<br>more file.txt        # Similar to &#39;less&#39;, but with fewer navigation features.</pre><p><strong>nano, </strong><strong>vi, and </strong><strong>vim</strong><br><strong>Description:</strong> Text editors for creating and modifying files.<br><strong>Usage:</strong></p><pre>nano file.txt        # Opens &#39;file.txt&#39; in Nano (user-friendly).<br>vi file.txt          # Opens &#39;file.txt&#39; in Vi.<br>vim file.txt         # Opens &#39;file.txt&#39; in Vim (enhanced version of Vi).</pre><h4>Searching and Processing</h4><p><strong>grep</strong><br><strong>Description:</strong> Searches for patterns in files using regular expressions.<br><strong>Usage:</strong></p><pre>grep &quot;search_term&quot; file.txt     # Searches for &#39;search_term&#39; in &#39;file.txt&#39;.<br>grep -r &quot;search_term&quot; /path      # Recursively searches in a directory.</pre><p><strong>find</strong><br><strong>Description:</strong> Searches for files and directories matching specified criteria.<br><strong>Usage:</strong></p><pre>find /path -name &quot;filename.txt&quot;   # Searches for a file by name.</pre><p><strong>awk and </strong><strong>sed</strong><br><strong>Description:</strong> Powerful text processing tools for pattern scanning and processing.<br><strong>Usage:</strong></p><pre>awk &#39;{print $1}&#39; file.txt         # Prints the first column of a file.<br>sed &#39;s/old/new/g&#39; file.txt         # Replaces all occurrences of &#39;old&#39; with &#39;new&#39; in a file.</pre><h4>System Monitoring and Management</h4><p><strong>ps</strong><br><strong>Description:</strong> Displays information about active processes.<br><strong>Usage:</strong></p><pre>ps aux             # Lists all running processes with detailed information.</pre><p><strong>top and </strong><strong>htop</strong><br><strong>Description:</strong> Real-time system monitoring tools.<br><strong>Usage:</strong></p><pre>top                # Displays real-time process usage.<br>htop               # Enhanced version of &#39;top&#39; with interactive features (if installed).</pre><p><strong>kill</strong><br><strong>Description:</strong> Sends signals to processes, often used to terminate them.<br><strong>Usage:</strong></p><pre>kill &lt;pid&gt;         # Terminates the process with the specified process ID.<br>kill -9 &lt;pid&gt;      # Forcefully terminates a process.</pre><h4>Network and Remote Connections</h4><p><strong>ssh</strong><br><strong>Description:</strong> Secure Shell for connecting to remote systems securely.<br><strong>Usage:</strong></p><pre>ssh user@hostname   # Connects to the remote host as the specified user.</pre><p><strong>scp</strong><br><strong>Description:</strong> Securely copies files between hosts using SSH.<br><strong>Usage:</strong></p><pre>scp localfile.txt user@hostname:/path/to/destination   # Copies a file to a remote server.</pre><h4>Package Management</h4><p>Different distributions have their own package managers:</p><p><strong>APT (Debian/Ubuntu):</strong><br><strong>Usage:</strong></p><pre>sudo apt update                # Updates package lists.<br>sudo apt upgrade               # Upgrades installed packages.<br>sudo apt install package-name  # Installs a package.</pre><p><strong>YUM/DNF (Fedora/CentOS):</strong><br><strong>Usage:</strong></p><pre>sudo dnf update                # Updates package lists.<br>sudo dnf install package-name  # Installs a package.</pre><h3>Miscellaneous</h3><p><strong>echo</strong><br><strong>Description:</strong> Outputs the given string or variable value.<br><strong>Usage:</strong></p><pre>echo &quot;Hello, Linux!&quot;   # Prints the string to the terminal.</pre><p><strong>chmod and </strong><strong>chown</strong><br><strong>Description:</strong> Change file permissions and ownership.<br><strong>Usage:</strong></p><pre>chmod 755 script.sh       # Sets the file permissions of &#39;script.sh&#39;.<br>chown user:group file.txt # Changes the owner and group of &#39;file.txt&#39;.</pre><p><strong>man</strong><br><strong>Description:</strong> Displays the manual (documentation) for commands.<br><strong>Usage:</strong></p><pre>man ls                 # Shows the manual page for the &#39;ls&#39; command.</pre><h3>5. Putting It All Together: Tips for Beginners</h3><ul><li><strong>Practice in a Virtual Environment:</strong> Set up a virtual machine or use a cloud instance to experiment without affecting your primary system.</li><li><strong>Learn by Doing:</strong> Start with simple tasks — navigating directories, creating files, and editing text — then move on to scripting and process management.</li><li><strong>Consult the Man Pages:</strong> The man command is your best friend; it provides in-depth information about nearly every command.</li><li><strong>Join the Community:</strong> Forums, online courses, and communities like Stack Overflow or Linux subreddits are great places to ask questions and share knowledge.</li></ul><h3>Conclusion</h3><p>Linux is not just an operating system; it’s a powerful ecosystem that underpins modern development and DevOps practices. Its open-source nature, flexibility, and robustness make it an invaluable tool for software engineers and system administrators alike. By mastering the basics — from installation and navigating the file system to leveraging essential commands — you’re well on your way to becoming proficient in an environment that powers everything from personal projects to global-scale cloud infrastructures.</p><p>Embrace the learning journey, practice regularly, and soon you’ll discover that the Linux command line is a gateway to unparalleled productivity and control.</p><blockquote>This guide provides a solid foundation for understanding Linux and its relevance to software engineering and DevOps. As you continue exploring, you’ll find that each command, tool, and concept opens up new possibilities for automation, performance optimization, and efficient system management. Happy learning!</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=35075c97f883" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Critical Skills Needed to Grow from Junior Engineer to Engineering Manager]]></title>
            <link>https://medium.com/@ahmedfaruk888/the-critical-skills-needed-to-grow-from-junior-engineer-to-engineering-manager-8de95238cee8?source=rss-1d481d6f493f------2</link>
            <guid isPermaLink="false">https://medium.com/p/8de95238cee8</guid>
            <category><![CDATA[engineer-skills]]></category>
            <category><![CDATA[coaching]]></category>
            <category><![CDATA[growth]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[communication-skills]]></category>
            <dc:creator><![CDATA[Ahmed Faruk Monkwo]]></dc:creator>
            <pubDate>Sat, 08 Feb 2025 19:44:20 GMT</pubDate>
            <atom:updated>2025-02-09T07:53:05.695Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gJ9hZYnzDpw4Y0Em" /><figcaption>Photo by <a href="https://unsplash.com/@quinoal?utm_source=medium&amp;utm_medium=referral">Quino Al</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Career growth in software engineering follows a structured path, from Junior Engineer to Mid-Level Engineer, then to Senior Engineer, and eventually to Engineering Manager. Each transition requires a mix of technical expertise, problem-solving ability, leadership, and communication skills.</p><p>This guide outlines the key skills required at each level to ensure a smooth and strategic career progression.</p><h3><strong>1. From Junior Engineer to Mid-Level Engineer</strong></h3><h4>Technical Skills</h4><p><strong>Proficiency in Core Technologies</strong> – A junior engineer should deepen their knowledge of programming languages (e.g., Python, Java, JavaScript, C#) and frameworks (React, Angular, Django, etc.).<br><strong>Code Quality and Best Practices </strong>– Learn and apply SOLID principles, DRY (Don&#39;t Repeat Yourself), and other software design patterns.<br><strong>Debugging and Troubleshooting</strong> – Be able to analyze and fix code defects efficiently.<br><strong>Version Control &amp; Collaboration</strong> – Master Git (branching, merging, pull requests) and collaborate effectively with teams.<br><strong>Testing and Automation</strong> – Write unit tests, integration tests, and automated tests using frameworks like Jest, PyTest, or JUnit.<br><strong>Basic Database Management</strong> – Gain proficiency in SQL (PostgreSQL, MySQL) and NoSQL databases (MongoDB, Firebase).<br><strong>Understanding of APIs &amp; Web Services</strong> – Learn RESTful APIs, GraphQL, and microservices architecture.</p><h4>Soft Skills</h4><p><strong>✅ Communication Skills</strong> – Clearly express technical ideas and updates in team meetings and code reviews.<br><strong>✅ Collaboration &amp; Teamwork</strong> – Work effectively in an agile development environment.<br><strong>✅ Adaptability</strong> – Learn new tools and technologies as required by the team.</p><h4>Project &amp; Professional Growth Skills</h4><p><strong>Understanding Requirements </strong>– Develop the ability to break down user stories and requirements.<br><strong>Time Management</strong> – Manage time effectively between coding, debugging, and learning new skills.<br><strong>Receiving &amp; Implementing Feedback</strong> – Be open to constructive criticism and improve accordingly.</p><h4><strong>🚀 Key Milestone to Achieve Mid-Level Engineer:</strong></h4><p>Independently complete well-scoped tasks without frequent guidance.</p><p>Write clean, maintainable, and well-documented code.</p><p>Participate actively in code reviews and discussions.</p><h3>2. From Mid-Level Engineer to Senior Engineer</h3><h4>Advanced Technical Skills</h4><p><strong>System Design &amp; Architecture</strong> – Learn how to design scalable and efficient applications, covering topics like microservices, event-driven architecture, and cloud-native design.<br><strong>Performance Optimization</strong> – Improve system performance through profiling, caching, indexing, and optimizing queries.<br><strong>Security Best Practices </strong>– Understand authentication, authorization, OWASP security principles, and application security risks.<br><strong>CI/CD &amp; DevOps Basics</strong> – Work with Jenkins, GitHub Actions, Kubernetes, and Terraform to automate deployments and infrastructure.<br><strong>Cloud Computing Knowledge</strong> – Gain proficiency in AWS, Azure, or Google Cloud, including cloud services like Lambda, EC2, S3, and Kubernetes.<br><strong>Advanced Debugging &amp; Troubleshooting</strong> – Handle complex debugging and root cause analysis of production issues.</p><h4>Soft Skills &amp; Leadership</h4><p><strong>✅ Technical Mentorship</strong> – Guide junior engineers, conduct code reviews, and help others debug their issues.<br><strong>✅ Decision Making</strong> – Make informed trade-offs in design, performance, and security.<br><strong>✅ Stakeholder Communication</strong> – Effectively communicate with product managers, designers, and business teams.<br><strong>✅ Ownership &amp; Accountability</strong> – Take full responsibility for projects, ensuring timely delivery and quality standards.</p><h4>Project &amp; Career Growth Skills</h4><p><strong>Project Management</strong> – Manage timelines, expectations, and potential roadblocks in projects.<br><strong>Proactive Learning</strong> – Stay updated on emerging technologies, new frameworks, and software trends.<br><strong>Process Improvement</strong> – Contribute to workflow optimizations, development processes, and efficiency improvements.</p><h4>🚀 Key Milestone to Achieve Senior Engineer:</h4><p>Lead technical discussions and make architectural decisions.</p><p>Mentor junior and mid-level engineers effectively.</p><p>Design and implement large-scale features or systems with minimal supervision.</p><h4>3. From Senior Engineer to Engineering Manager</h4><h4>People &amp; Leadership Skills</h4><p><strong>Team Management</strong> – Lead, mentor, and manage a team of engineers effectively.<br><strong>Career Development for Team Members</strong> – Help engineers grow professionally by setting goals, providing feedback, and supporting learning opportunities.<br><strong>Conflict Resolution</strong> – Handle workplace conflicts, team disagreements, and project-related tensions constructively.<br><strong>Emotional Intelligence</strong> – Foster a positive work environment by understanding team dynamics and individual needs.</p><h4>Strategic &amp; Business-Oriented Skills</h4><p><strong>Product &amp; Business Acumen</strong> – Understand company goals, market trends, and how engineering contributes to business success.<br><strong>Project &amp; Resource Management</strong> – Allocate team resources efficiently and manage development timelines effectively.<br><strong>Cross-Team Collaboration</strong> – Work closely with Product Managers, UX Designers, and other engineering leaders.<br><strong>Decision-Making Under Uncertainty</strong> – Make strategic technical and managerial decisions even with incomplete data.</p><h4>Technical Oversight &amp; Vision</h4><p><strong>✅ Technical Leadership</strong> – Set long-term technical strategies and advocate for best practices.<br><strong>✅ Scaling Engineering Teams</strong> – Participate in hiring, onboarding, and setting a strong engineering culture.<br><strong>✅ Process &amp; Workflow Optimization</strong> – Improve engineering workflows, team communication, and documentation practices.</p><h4>🚀 Key Milestone to Achieve Engineering Manager:</h4><p>Successfully manage an engineering team and deliver projects on time.</p><p>Influence technical and strategic decisions beyond personal code contributions.</p><p>Foster a culture of continuous learning and improvement.</p><p>Conclusion: A Continuous Learning Journey</p><p>Growing from Junior Engineer to Engineering Manager is not just about mastering technology—it&#39;s about developing leadership, communication, and strategic thinking skills.</p><h4>At each level:</h4><p>Junior Engineers must focus on technical fundamentals and collaboration.</p><p>Mid-Level Engineers must refine problem-solving, ownership, and mentorship.</p><p>Senior Engineers should focus on architectural decisions, team influence, and strategic thinking.</p><p>Engineering Managers must lead teams, align technical direction with business goals, and optimize processes.</p><p>By consistently learning, adapting, and leading, engineers can build a successful and impactful career.</p><p><em>Would you like me to tailor this article with a specific tone or industry focus (e.g., cybersecurity, AI, fintech)? — if yes, please drop a comment</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8de95238cee8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Microservices vs. Monolithic Architecture: A Comprehensive Guide for NestJS TypeScript Developers]]></title>
            <link>https://medium.com/@ahmedfaruk888/microservices-vs-monolithic-architecture-a-comprehensive-guide-for-nestjs-typescript-developers-cec26bc2536d?source=rss-1d481d6f493f------2</link>
            <guid isPermaLink="false">https://medium.com/p/cec26bc2536d</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[nestjs]]></category>
            <category><![CDATA[kafka]]></category>
            <category><![CDATA[monolith]]></category>
            <category><![CDATA[grpc]]></category>
            <dc:creator><![CDATA[Ahmed Faruk Monkwo]]></dc:creator>
            <pubDate>Sat, 08 Feb 2025 12:32:13 GMT</pubDate>
            <atom:updated>2025-02-08T12:32:13.273Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/767/1*raqzlq7aozKJUju7jYk2Tw.png" /></figure><p><em>When building scalable, maintainable applications with NestJS, one of the first decisions you’ll face is choosing the right architectural style. Should you develop your application as a single, unified monolith, or break it into multiple, independently deployable microservices? In this guide, we’ll break down both architectures, discuss their benefits and challenges, and offer insights tailored for NestJS developers preparing for technical interviews.</em></p><h3>1. Introduction: Why Architecture Matters in NestJS</h3><p>NestJS leverages modern TypeScript features and design patterns to provide a powerful framework for Node.js applications. Whether you’re building REST APIs, real-time services, or event-driven systems, your architectural choice has long-term implications on performance, scalability, and development agility. In interviews, you might be asked to compare these approaches or justify your architectural decisions. Understanding the nuances between monolithic and microservices architectures is key to demonstrating your expertise.</p><h3>2. Monolithic Architecture in NestJS</h3><h3>What Is a Monolith?</h3><p>A monolithic application is built as a single, unified unit where all components — controllers, services, modules, and data access layers — are tightly integrated and deployed together. In the context of NestJS, a monolithic design means your entire application runs as one process.</p><h3>Key Characteristics</h3><ul><li><strong>Unified Codebase:</strong> All business logic is maintained in one repository, simplifying development and testing.</li><li><strong>Simpler Deployment:</strong> With one deployable unit, deployment pipelines and versioning are straightforward.</li><li><strong>Tight Coupling:</strong> While sharing the same runtime, modules often have tight interdependencies, which can simplify inter-module communication but may lead to challenges as the codebase grows.</li><li><strong>Easier Debugging:</strong> Local debugging and logging tend to be simpler when all parts of the system reside in a single process.</li></ul><h3>When to Use a Monolith in NestJS</h3><ul><li><strong>Small to Medium-Sized Projects:</strong> If your application is relatively small or the team size is limited, a monolith can speed up development.</li><li><strong>Rapid Prototyping:</strong> A monolithic structure is ideal for early-stage development when you need to iterate quickly without managing distributed system complexities.</li><li><strong>Simpler Operational Overhead:</strong> With fewer moving parts, monitoring, logging, and troubleshooting are more straightforward.</li></ul><h3>3. Microservices Architecture in NestJS</h3><h3>What Are Microservices?</h3><p>Microservices architecture divides an application into a collection of loosely coupled, independently deployable services. Each microservice encapsulates a specific business capability and communicates with other services using lightweight protocols such as HTTP, gRPC, or message brokers.</p><h3>NestJS and Microservices</h3><p>NestJS has built-in support for microservices, providing abstractions to handle inter-service communication, fault tolerance, and scalability. Whether you use TCP, Redis, NATS, or MQTT as your transport layer, NestJS makes it easier to create distributed systems with a unified programming model.</p><h3>Key Characteristics</h3><ul><li><strong>Decoupled Services:</strong> Each service is developed, deployed, and scaled independently, allowing teams to work autonomously.</li><li><strong>Improved Scalability:</strong> Services can be scaled out selectively based on load, optimizing resource usage.</li><li><strong>Resilience and Fault Isolation:</strong> A failure in one service is less likely to bring down the entire system.</li><li><strong>Complex Communication Patterns:</strong> Microservices require well-defined APIs and communication protocols, which can increase development complexity.</li></ul><h3>When to Use Microservices in NestJS</h3><ul><li><strong>Large-Scale Applications:</strong> For systems with complex domains and high transaction volumes, microservices offer flexibility and scalability.</li><li><strong>Distributed Teams:</strong> When different teams are responsible for separate business domains, microservices enable parallel development and deployment.</li><li><strong>Performance Optimization:</strong> Services that have distinct performance requirements can be optimized and scaled independently.</li></ul><h3>4. Key Differences and Trade-Offs</h3><h3>Comparison at a Glance</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/745/1*kPBzBzN4UJsiKEFIv8Mqsg.png" /></figure><h3>Trade-Off Considerations</h3><ul><li><strong>Complexity vs. Control:</strong> Monolithic systems are simpler but may become unwieldy as the codebase grows. Microservices offer better control and scalability at the expense of increased complexity in deployment and inter-service communication.</li><li><strong>Team Organization:</strong> Smaller teams might find a monolithic approach easier to manage, whereas larger teams can benefit from the decoupled nature of microservices.</li><li><strong>Technology Stack:</strong> In a microservices architecture, you can mix and match technologies for different services. In a NestJS ecosystem, while consistency is key, microservices might still let you experiment with different protocols or storage mechanisms.</li></ul><h3>5. Best Practices for NestJS Architectures</h3><h3>For Monolithic Applications</h3><ul><li><strong>Modular Design:</strong> Even within a monolith, break your code into feature-based modules to promote separation of concerns.</li><li><strong>Clean Architecture:</strong> Apply principles like dependency inversion to keep business logic decoupled from infrastructure code.</li><li><strong>Effective Caching:</strong> Use caching strategies (e.g., in-memory caches or Redis) to optimize performance for frequently accessed data.</li><li><strong>Robust Testing:</strong> Leverage NestJS’s testing utilities to write unit, integration, and end-to-end tests, ensuring the integrity of your monolithic system.</li></ul><h3>For Microservices Applications</h3><ul><li><strong>Clear Service Boundaries:</strong> Define the responsibilities of each microservice clearly to avoid overlapping functionalities.</li><li><strong>API Gateway:</strong> Consider using an API gateway to manage requests, authentication, and routing to the appropriate microservices.</li><li><strong>Inter-Service Communication:</strong> Choose the right communication protocols — synchronous (HTTP, gRPC) or asynchronous (message queues, event streams) — based on your use case.</li><li><strong>Observability:</strong> Implement distributed tracing, logging, and monitoring to quickly identify issues in a multi-service environment.</li><li><strong>Resilient Design:</strong> Employ patterns like circuit breakers and retries to handle failures gracefully.</li></ul><h3>6. Interview Questions for NestJS Developers</h3><p>When interviewing for roles that involve architectural decisions, you might be asked questions such as:</p><ol><li><strong>What are the advantages and disadvantages of using a monolithic architecture in a NestJS application?</strong><br><em>Discuss simplicity, ease of deployment, and rapid prototyping versus challenges in scaling and maintenance as the application grows.</em></li><li><strong>How does NestJS support building microservices, and what transport layers have you used?</strong><br><em>Talk about the NestJS microservices package, built-in support for TCP, Redis, NATS, MQTT, and how you’ve implemented inter-service communication.</em></li><li><strong>What strategies would you use to ensure resilience and observability in a microservices-based NestJS application?</strong><br><em>Mention the use of API gateways, distributed tracing, centralized logging, and fault tolerance mechanisms like circuit breakers.</em></li><li><strong>Can you describe a scenario where you might choose a monolith over microservices in a NestJS project, and why?</strong><br><em>Focus on factors like team size, project complexity, and the initial need for rapid development.</em></li><li><strong>How would you handle shared data across multiple microservices in NestJS?</strong><br><em>Discuss patterns such as event sourcing, eventual consistency, and the use of shared databases or caches with careful attention to data integrity.</em></li></ol><h3>7. Conclusion</h3><p><em>Choosing between a monolithic or microservices architecture is a pivotal decision that impacts your application’s scalability, maintainability, and development workflow. For NestJS developers, the framework’s flexibility allows you to build robust applications in either style. While a monolith can offer rapid development and simpler deployments in the early stages, a microservices approach may be necessary as your application scales and business requirements evolve.</em></p><p><em>By understanding the trade-offs, best practices, and interview-relevant questions surrounding these architectures, you’ll be well-equipped to make informed decisions and effectively communicate your architectural choices in technical interviews. As you advance in your NestJS journey, remember that the right architecture depends on your specific context — there’s no one-size-fits-all solution.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cec26bc2536d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Demystifying Database Types: A Comprehensive Guide to Modern Data Storage]]></title>
            <link>https://medium.com/@ahmedfaruk888/demystifying-database-types-a-comprehensive-guide-to-modern-data-storage-52b3f7b6d49f?source=rss-1d481d6f493f------2</link>
            <guid isPermaLink="false">https://medium.com/p/52b3f7b6d49f</guid>
            <category><![CDATA[oracle]]></category>
            <category><![CDATA[nosql]]></category>
            <category><![CDATA[mysql]]></category>
            <category><![CDATA[time-series-analysis]]></category>
            <category><![CDATA[database]]></category>
            <dc:creator><![CDATA[Ahmed Faruk Monkwo]]></dc:creator>
            <pubDate>Sat, 08 Feb 2025 12:10:07 GMT</pubDate>
            <atom:updated>2025-02-08T12:10:07.873Z</atom:updated>
            <content:encoded><![CDATA[<p><em>In today’s data-driven world, choosing the right database isn’t simply about picking a storage engine — it’s about matching your application’s data model, performance requirements, scalability needs, and reliability expectations. This guide explores the major types of databases, their inner workings, use cases, and future trends. Whether you’re a developer, architect, or business leader, understanding these systems can help you make better technology choices.</em></p><figure><img alt="Faruk Ahmed Monkwo" src="https://cdn-images-1.medium.com/max/1024/0*bzFb2baEnZO43ZPV" /><figcaption>Photo by <a href="https://unsplash.com/@rosssneddon?utm_source=medium&amp;utm_medium=referral">Ross Sneddon</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Table of Contents</h3><ol><li><a href="#introduction">Introduction: The Evolving World of Data</a></li><li><a href="#relational-databases">Relational Databases (RDBMS)</a></li><li><a href="#nosql-databases">NoSQL Databases</a></li></ol><ul><li><a href="#document-stores">Document Stores</a></li><li><a href="#key-value-stores">Key-Value Stores</a></li><li><a href="#column-family-databases">Column-Family Databases</a></li><li><a href="#graph-databases">Graph Databases</a></li></ul><ol><li><a href="#time-series-and-specialized-databases">Time-Series and Specialized Databases</a></li><li><a href="#newsql-and-hybrid-approaches">NewSQL and Hybrid Approaches</a></li><li><a href="#choosing-the-right-database">Choosing the Right Database: Considerations and Trade-offs</a></li><li><a href="#emerging-trends">Emerging Trends and the Future of Data Storage</a></li><li><a href="#conclusion">Conclusion</a></li></ol><h3>Introduction: The Evolving World of Data</h3><p>Over the past several decades, data has grown in both volume and variety. Early systems were designed around structured data and predictable queries, but modern applications often require real-time analytics, flexible data models, and massive horizontal scaling. This evolution has led to a diverse ecosystem of database technologies, each with unique strengths and trade-offs.</p><p>Imagine a bustling city where different neighborhoods cater to distinct lifestyles — from the quiet, structured avenues of a planned community (relational databases) to the dynamic, ever-changing markets of a vibrant bazaar (NoSQL systems). Choosing the right “neighborhood” for your data is crucial for performance, scalability, and maintainability.</p><h3>Relational Databases (RDBMS)</h3><h3>Overview</h3><p>Relational databases have long been the backbone of enterprise applications. They use structured schemas, tables, and rows to represent data and rely on SQL (Structured Query Language) for managing and querying that data.</p><h3>Key Features</h3><ul><li><strong>Structured Schema:</strong> Tables with defined columns and data types.</li><li><strong>ACID Compliance:</strong> Ensuring atomicity, consistency, isolation, and durability in transactions.</li><li><strong>SQL:</strong> A powerful, declarative language for data manipulation and querying.</li><li><strong>Mature Ecosystem:</strong> A wide array of tools for reporting, analytics, backup, and security.</li></ul><h3>Use Cases</h3><ul><li>Financial systems</li><li>Enterprise Resource Planning (ERP)</li><li>Customer Relationship Management (CRM)</li><li>Applications requiring complex joins and transactional integrity</li></ul><h3>Examples</h3><ul><li>Oracle Database</li><li>MySQL/MariaDB</li><li>PostgreSQL</li><li>Microsoft SQL Server</li></ul><h3>NoSQL Databases</h3><p>NoSQL databases emerged to address limitations in scalability and schema flexibility inherent in traditional RDBMS. They come in several flavors, each tailored to particular data models and access patterns.</p><h3>Document Stores</h3><h4>Overview</h4><p>Document databases store data in semi-structured formats like JSON or BSON. They allow nested data and dynamic schemas, which are especially useful for applications with evolving data models.</p><h4>Key Features</h4><ul><li><strong>Schema Flexibility:</strong> Documents can have different structures.</li><li><strong>Natural Data Representation:</strong> Ideal for hierarchical data.</li><li><strong>Indexing and Querying:</strong> Support for complex queries on document fields.</li></ul><h4>Use Cases</h4><ul><li>Content management systems</li><li>E-commerce catalogs</li><li>User profile management</li></ul><h4>Examples</h4><ul><li><strong>MongoDB</strong></li><li><strong>CouchDB</strong></li></ul><h3>Key-Value Stores</h3><h4>Overview</h4><p>Key-value databases are the simplest type of NoSQL systems. They store data as a collection of key-value pairs, offering lightning-fast lookups when the key is known.</p><h4>Key Features</h4><ul><li><strong>Simplicity and Speed:</strong> Optimized for rapid read/write operations.</li><li><strong>Scalability:</strong> Often distributed to handle large loads.</li><li><strong>Limited Query Flexibility:</strong> Best used when data is retrieved by key.</li></ul><h4>Use Cases</h4><ul><li>Caching layers</li><li>Session storage</li><li>High-speed lookup systems</li></ul><h4>Examples</h4><ul><li><strong>Redis</strong></li><li><strong>Amazon DynamoDB (in its key-value capacity)</strong></li><li><strong>Riak KV</strong></li></ul><h3>Column-Family Databases</h3><h4>Overview</h4><p>Inspired by Google’s Bigtable, column-family stores organize data into columns grouped into families, making them excellent for handling large datasets with varying attributes.</p><h4>Key Features</h4><ul><li><strong>High Throughput:</strong> Efficient for write-heavy applications.</li><li><strong>Flexible Schema:</strong> Columns can be added without a fixed schema.</li><li><strong>Horizontal Scaling:</strong> Designed to scale across many servers.</li></ul><h4>Use Cases</h4><ul><li>Analytics on large datasets</li><li>Time-series data</li><li>Log aggregation</li></ul><h4>Examples</h4><ul><li><strong>Apache Cassandra</strong></li><li><strong>HBase</strong></li></ul><h3>Graph Databases</h3><h4>Overview</h4><p>Graph databases model data as nodes (entities) and edges (relationships), making them uniquely suited for applications that require rapid traversal of complex relationships.</p><h4>Key Features</h4><ul><li><strong>Relationship Focused:</strong> Efficient for querying interconnected data.</li><li><strong>Flexible Schema:</strong> Nodes and relationships can store diverse properties.</li><li><strong>Specialized Query Languages:</strong> Such as Cypher for Neo4j or Gremlin.</li></ul><h4>Use Cases</h4><ul><li>Social networks</li><li>Fraud detection</li><li>Recommendation engines</li></ul><h4>Examples</h4><ul><li><strong>Neo4j</strong></li><li><strong>Amazon Neptune</strong></li><li><strong>ArangoDB (multi-model with strong graph capabilities)</strong></li></ul><h3>Time-Series and Specialized Databases</h3><p>Beyond the traditional categories, specialized databases have been developed to handle specific workloads:</p><ul><li><strong>Time-Series Databases:</strong> Optimized for data indexed by time (e.g., InfluxDB, TimescaleDB). These systems are used for monitoring, IoT data, and analytics where the time dimension is central.</li><li><strong>Spatial and Geographic Databases:</strong> Tailored for geospatial queries and location-based services.</li><li><strong>Multimodal Databases:</strong> Combine multiple data models (e.g., document and graph) under one system, offering versatility for complex applications.</li></ul><h3>NewSQL and Hybrid Approaches</h3><p>As data needs continue to evolve, some systems aim to bridge the gap between the strong consistency and ACID guarantees of traditional SQL databases and the scalability of NoSQL systems. These “NewSQL” databases strive to offer:</p><ul><li><strong>Scalability:</strong> Horizontal scaling without sacrificing transactional integrity.</li><li><strong>SQL Interface:</strong> Familiar query language for developers.</li><li><strong>Modern Architectures:</strong> Often cloud-native, with built-in distributed capabilities.</li></ul><h3>Examples</h3><ul><li><strong>Google Spanner</strong></li><li><strong>CockroachDB</strong></li><li><strong>VoltDB</strong></li></ul><p>Hybrid databases that support multiple data models (for example, offering both relational and document interfaces) are also on the rise. They provide flexibility by letting developers choose the best model for each part of an application while using a single backend.</p><h3>Choosing the Right Database: Considerations and Trade-offs</h3><p>When deciding which database type to use, consider the following factors:</p><ul><li><strong>Data Structure:</strong> Is your data highly structured or does it vary? Document and key-value stores offer more flexibility compared to rigid relational schemas.</li><li><strong>Consistency vs. Availability:</strong> Relational databases typically provide strong consistency, while many NoSQL systems favor eventual consistency to achieve higher availability.</li><li><strong>Query Patterns:</strong> Complex joins and transactional queries may favor an RDBMS, whereas simple key lookups or hierarchical data retrieval might be better served by NoSQL alternatives.</li><li><strong>Scalability Needs:</strong> If you anticipate rapid growth or need global distribution, systems like Cassandra or NewSQL options might be more appropriate.</li><li><strong>Operational Complexity:</strong> Consider the expertise of your team and the operational overhead associated with managing distributed systems.</li></ul><h3>Emerging Trends and the Future of Data Storage</h3><p>The landscape of database technologies is constantly evolving. Some of the key trends include:</p><ul><li><strong>Cloud-Native Databases:</strong> Managed, scalable databases designed for cloud environments are becoming increasingly popular, offering automated scaling, backups, and high availability.</li><li><strong>Serverless Architectures:</strong> These services abstract away infrastructure concerns, enabling developers to focus on application logic.</li><li><strong>Polyglot Persistence:</strong> Instead of a one-size-fits-all approach, modern architectures often employ multiple database types, each selected for its specific strengths.</li><li><strong>Edge Computing and Distributed Data:</strong> As applications extend to the edge (for IoT, real-time analytics, etc.), databases that can operate efficiently in a distributed environment will become even more important.</li><li><strong>Advances in AI and ML:</strong> Databases are increasingly being designed to integrate with artificial intelligence workflows, providing native support for machine learning models and real-time analytics.</li></ul><p><em>This comprehensive guide is intended to serve as a standalone resource on database types. By exploring not just the technical underpinnings but also the practical considerations and emerging trends, we hope it equips you with the insights needed to navigate today’s complex data ecosystems.</em></p><h3>Conclusion</h3><p>No single database type is “the best” for every scenario. By understanding the trade-offs and strengths of relational, NoSQL, NewSQL, and specialized systems, you can design a data architecture that is both flexible and robust. As technology evolves, so too will the ways in which we store, manage, and derive insights from data — making it an exciting time to explore and innovate in the world of databases.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=52b3f7b6d49f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Upgrade Node JS Project Packages: A Developer’s Guide.]]></title>
            <link>https://medium.com/@ahmedfaruk888/how-to-upgrade-node-js-project-packages-a-developers-guide-6095773c432d?source=rss-1d481d6f493f------2</link>
            <guid isPermaLink="false">https://medium.com/p/6095773c432d</guid>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[node-package-manager]]></category>
            <category><![CDATA[nestjs]]></category>
            <category><![CDATA[updates]]></category>
            <dc:creator><![CDATA[Ahmed Faruk Monkwo]]></dc:creator>
            <pubDate>Sun, 10 Sep 2023 23:27:58 GMT</pubDate>
            <atom:updated>2024-08-06T13:28:24.259Z</atom:updated>
            <content:encoded><![CDATA[<p>In this simple guide, we will walk through the process of upgrading a simple NestJS application from version 9 to 10 or from version 8 to 9. This guide is intended for developers who have an existing NestJS or Node JS project and wish to update it to the latest version.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*yqMKm6iUEz7cGRJt8XoJlA.gif" /><figcaption>Dependency Pair Deep</figcaption></figure><h3>Task: Update All NestJs Packages in a Project</h3><p><em>(This can be applied to any node package as well)</em></p><p><strong>Step 1: Update the NestJS CLI</strong><br>First, update the NestJS CLI to the latest version by running the following command:</p><pre>npm install -g @nestjs/cli</pre><p>Verify the installed version with:</p><pre>nest --version</pre><p><strong>Step 2: Install npm-check-updates</strong><br> To update your dependencies, install the npm-check-updates package globally:</p><pre>npm i -g npm-check-updates</pre><p><strong>Step 3: Update package.json</strong><br> Use ncu -u to update your package.json file with the latest dependencies:</p><pre>To update all nestjs related packages<br><br>ncu -u -f /^@nestjs/</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/565/1*5kCDQ3zoEhKHyN62sSaStA.png" /></figure><p><strong>Step 4: Verify Changes</strong><br> Review the changes in your package.json file, ensuring that the NestJS dependencies are updated to the desired version (v10).</p><p><strong>Step 5: Remove package-lock.json and node_modules</strong><br> Delete the package-lock.json file and the node_modules folder with the following commands:</p><pre>rm package-lock.json<br>rm -rf node_modules</pre><p><strong>Step 6: Install Updated Dependencies</strong><br> Finally, install the updated dependencies:</p><pre>npm install</pre><p>After completing these steps, your Node JS project or Nest JS application packages should be updated to the latest version. This approach works for any node js based project, kindly ensure to test your application properly to ensure that there are no breaking changes caused by the upgrade.</p><p>Happy hacking!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6095773c432d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Service Bus and Message Broker — The difference]]></title>
            <link>https://medium.com/@ahmedfaruk888/service-bus-and-message-broker-the-difference-2cdc2162e1d6?source=rss-1d481d6f493f------2</link>
            <guid isPermaLink="false">https://medium.com/p/2cdc2162e1d6</guid>
            <category><![CDATA[rabbitmq]]></category>
            <category><![CDATA[kafka]]></category>
            <category><![CDATA[message-broker]]></category>
            <category><![CDATA[enterprise-service-bus]]></category>
            <dc:creator><![CDATA[Ahmed Faruk Monkwo]]></dc:creator>
            <pubDate>Mon, 07 Aug 2023 00:43:38 GMT</pubDate>
            <atom:updated>2023-08-07T00:47:52.405Z</atom:updated>
            <content:encoded><![CDATA[<h3>Service Bus and Message Broker — The difference</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/627/1*9VUYeJSSngNDaOxXBtI0_g.png" /><figcaption><a href="https://www.google.com/url?sa=i&amp;url=https%3A%2F%2Fazureservicebusman.com%2F&amp;psig=AOvVaw3WkJHjOwuZZ0aIJWpdVyHs&amp;ust=1691455435398000&amp;source=images&amp;cd=vfe&amp;opi=89978449&amp;ved=0CBMQjhxqFwoTCMC96dSoyYADFQAAAAAdAAAAABA1">https://www.azureservicebusman.com</a></figcaption></figure><p>Both a service bus and a message broker are middle-ware solutions used in distributed systems to facilitate communication between different components or services. While they share some similarities, they have distinct characteristics and use cases. Let’s explore the differences between a service bus and a message broker using detailed examples.</p><h3>Service Bus</h3><p>A service bus is a communication infrastructure that enables seamless interaction and coordination between different services or applications. It provides advanced features such as publish/subscribe, request/response, and message routing. A service bus often includes features like message transformation, protocol adaptation, and message enrichment.</p><h4>Example: Online Marketplace</h4><p>Imagine an online marketplace where sellers list products, and buyers can purchase them. The marketplace needs a way to manage notifications and orders between sellers and buyers. A service bus can be used to achieve this.</p><p>When a seller adds a new product, a message is published to the service bus indicating the availability of the product. Buyers interested in that category of products can subscribe to notifications. When a buyer places an order for a product, a request is sent to the service bus, and the appropriate seller is notified.</p><p>In this scenario, the service bus facilitates communication between sellers and buyers, allowing them to interact without knowing each other’s details directly. It handles the routing of messages and enables decoupling between the sender and receiver.</p><h3>Message Broker</h3><p>A message broker is a core component of messaging systems that handles the routing, mediation, and distribution of messages between different applications or services. It focuses on message delivery and ensuring that messages are reliably and efficiently sent from one point to another.</p><h4>Example: Stock Trading Platform</h4><p>Consider a stock trading platform that receives real-time stock prices from various stock exchanges and provides updates to traders’ terminals. A message broker can be employed to handle this communication.</p><p>When stock prices change on the exchanges, they send updates to the message broker. The broker then routes these updates to the relevant traders’ terminals based on their subscriptions. The message broker ensures that the updates are delivered reliably and efficiently to all interested parties.</p><p>In this scenario, the message broker acts as an intermediary responsible for managing the flow of stock price updates. It ensures that updates are delivered to traders while handling potential network fluctuations and ensuring that no updates are lost.</p><h3>Key Differences</h3><p><strong>1. Functionality</strong><br> Service Bus: Focuses on higher-level communication patterns like publish/subscribe, request/response, and message transformation.<br>Message Broker: Focuses on message routing, delivery, and ensuring reliable communication between applications.</p><p><strong>2. Abstraction Level</strong><br>Service Bus: Provides a higher-level abstraction, often including business-level features and logic.<br>Message Broker: Primarily deals with the mechanics of message delivery and routing.</p><p><strong>3. Use Cases</strong><br>Service Bus: Well-suited for scenarios involving complex interactions, workflow coordination, and business processes.<br>Message Broker: Ideal for scenarios where reliable message delivery and efficient communication are the primary concerns.</p><p><strong>4. Examples</strong><br>Service Bus Example: Online marketplace facilitating communication between sellers and buyers.<br>Message Broker Example: Stock trading platform distributing real-time stock price updates to traders.</p><p>In summary, while both service buses and message brokers are essential components in messaging systems, they serve different purposes. A service bus focuses on higher-level communication patterns and often includes business logic, while a message broker specializes in reliable message delivery and routing. The choice between them depends on the specific requirements of your distributed system.</p><p>If you like this article, do well to drop a like and follow. I promise, I’ll write another article tomorrow..</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2cdc2162e1d6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Trunk-based vs feature-based development dilemma — Part # 1]]></title>
            <link>https://medium.com/@ahmedfaruk888/trunk-based-vs-feature-based-development-dilemma-part-1-b89869186357?source=rss-1d481d6f493f------2</link>
            <guid isPermaLink="false">https://medium.com/p/b89869186357</guid>
            <category><![CDATA[trunk-based-development]]></category>
            <category><![CDATA[gitflow]]></category>
            <category><![CDATA[feature-based-development]]></category>
            <category><![CDATA[gi̇t]]></category>
            <dc:creator><![CDATA[Ahmed Faruk Monkwo]]></dc:creator>
            <pubDate>Mon, 07 Aug 2023 00:28:30 GMT</pubDate>
            <atom:updated>2023-08-07T00:30:35.952Z</atom:updated>
            <content:encoded><![CDATA[<h3>Trunk-based vs feature-based development dilemma — Part # 1</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*EoM3F4baNJ26kl8vDjYtvg.png" /><figcaption>Trunk based development vs feature based development in Git</figcaption></figure><p>Industry standard rules and organized work effort are crucial to the success of every team in a software development project. The concept of trunking or feature-based development (same as GitFlow) have been around since the early days of subversion control. Both trunk-based development and feature-based development are widely-used development workflows in the git ecosystem.</p><h3><strong>Understanding the concept?</strong></h3><h4><strong>Trunk-Based Development</strong></h4><p>Is a version control management practice where developers merge small, frequent updates to the “trunk”, sometimes referred to as the master branch or main branch. Since it streamlines merging and integration phases, it helps achieve the goal of CI/CD and increases software delivery and organizational performance.</p><p>In a trunk-based development, an engineer directly pushes code changes to the master branch, but in situations where the current task requires more time to complete, lets say two to three days. The developer can check out a feature branch from main or master branch, move the changes into it, then merge it back in when development is done.</p><p>Fellow developers must then perform a code review based on company set policy before merging the checked-out branch with the main or master branch. The one thing to note in trunk-based development is that, checked-out branches are short-lived, and should be deleted after merge, spanning two to three days at most.</p><p>In a trunk-based workflow, the main branch should always be production-ready. Faulty code can break the entire build and result in a complicated development history. That means that teams should thoroughly test each code change before pushing them to the main branch. Short development cycles and automated testing enable teams to identify defects and recover from failed builds quickly, reducing the risk. This workflow requires that the team harnesses the expertise of more experienced engineer on the team. Junior or inexperienced members need enough grooming and understanding of the workflow before they can contribute to the project.</p><h4><strong>Feature Based Development</strong></h4><p>A feature-based development workflow also referred to as <a href="https://www.atlassian.com/git/tutorials/comparing-workflows/gitflow-workflow">GitFlow</a> — is a classic approach to collaboration on a software development project. This development approach is most widely used among software development teams.</p><p>Feature-based workflow uses many long-lived branches for developing individual features. Before developing a feature, the developer branch out to a “feature” branch and makes all the code changes in this branch, once the code passed all set test, the developer creates a merge request from the feature branch into the main or master. The code changes will be allowed to be merged into the main or master if the changes passed in the code review session (this is obviously not always true, some code slipped into main branch without been reviewed 😍 — we will come back to this in a later series). The key <strong>take-away </strong>from this is that, developers never ever pushes code directly to the main or master branch in a feature-based workflow.</p><p>One of the the advantages of the feature-based workflows in git is developers can branch out and work on different unique features on a single project independently. Feature-based git workflow is ideal in a tea where there are less experience developers (The workflow allows junior devs to get their hands dirty and work on a features in other to learn without worrying about breaking production code).</p><p>Managing feature-based development can be tricky, though, especially when multiple pull requests are queued to merge into the main branch. The team lead or senior software engineer is responsible for reviewing these requests quickly and merging them with the main code. This situation can sometimes lead to conflicts that can dishearten newer developers, who may have to wait longer for merge approval. Slower integrations can also lead to less-frequent deployments and longer recovery times for failed builds, so product innovation can lag behind.</p><p>For example, sometimes if a team must maintain multiple versions of software application, take for example, the python programming language, version 2 is not compatible with version 3, both receives patches and bug fixes, that does not mean a new release of version 3 is based off of the last commit or latest commit of version 2. In such situation, a long-lived branch of different versions can be maintained, therefore a trunk-based workflow may be challenging to implement. The Linux kernel is another classic use case for feature-based development that uses long-lived release branches. The feature-based workflow is the most sensible solution in this situation because users may have to maintain each released version of the Linux kernel for years — possibly even decades.</p><h3>Choosing the best for your team?</h3><p>Both trunk-based and feature-based development workflows have their benefits and drawbacks. Choosing which is best to adopt in your team your team depends on the group’s collective preferences, available experience and the overall suitability approach for the team’s workflow.</p><p>For example — a teams that have adopted continuous integration best practices and which have experience developers can adopt a trunk-based branching workflow because it allows for fast iteration and feedback, reducing costly and time-consuming merge conflicts at the end of long feature development cycles.</p><p>Feature-based workflow is ideal for team with less experience developers, the workflow is also best adopted in when different versions of a software need to be maintained either by the same of different dev teams.</p><p>If you like this article, do well to drop a like and follow. I promise, I’ll write another article tomorrow..</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b89869186357" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Design Principle Explained — In Typescript]]></title>
            <link>https://medium.com/@ahmedfaruk888/design-principle-explained-in-typescript-3d15f4975e16?source=rss-1d481d6f493f------2</link>
            <guid isPermaLink="false">https://medium.com/p/3d15f4975e16</guid>
            <category><![CDATA[team-management]]></category>
            <category><![CDATA[bionomancy]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Ahmed Faruk Monkwo]]></dc:creator>
            <pubDate>Sun, 06 Aug 2023 00:30:16 GMT</pubDate>
            <atom:updated>2023-08-06T00:33:36.954Z</atom:updated>
            <content:encoded><![CDATA[<h3>SOLID Principle Explained — In Typescript</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/806/1*Px1XxFia2sgdHoh3x38avg.jpeg" /><figcaption>Leo Ganzalo Sidiq — “Jenga Game — A simple way to express design”</figcaption></figure><p>Design principles are fundamental guidelines that help developers create well-structured, maintainable, and efficient software solutions. They provide a set of best practices to follow when designing and implementing software systems. One widely recognized set of design principles is the SOLID principles, which are five principles that focus on achieving modular, flexible, and extensible code.</p><p>Let’s go through each SOLID principle and provide an explanation along with a TypeScript code sample:</p><ol><li>Single Responsibility Principle (SRP): This principle states that a class or module should have only one reason to change. It means that a class should have a single responsibility and should encapsulate it well. By adhering to SRP, we can ensure that our classes are focused and not overloaded with unrelated functionality.</li></ol><pre>// Example of SRP<br><br>class Customer {<br>  private name: string;<br>  private email: string;<br><br>  constructor(name: string, email: string) {<br>    this.name = name;<br>    this.email = email;<br>  }<br><br>  getName(): string {<br>    return this.name;<br>  }<br><br>  getEmail(): string {<br>    return this.email;<br>  }<br>}<br><br>// The Customer class has a single responsibility, which is to represent a customer and provide access to their name and email.</pre><p>2. Open/Closed Principle (OCP): This principle states that software entities (classes, modules, functions) should be open for extension but closed for modification. It means that we should design our code in a way that allows new functionality to be added without modifying existing code. This can be achieved through the use of abstractions, interfaces, and inheritance.</p><pre>// Example of OCP<br><br>interface Shape {<br>  calculateArea(): number;<br>}<br><br>class Rectangle implements Shape {<br>  private width: number;<br>  private height: number;<br><br>  constructor(width: number, height: number) {<br>    this.width = width;<br>    this.height = height;<br>  }<br><br>  calculateArea(): number {<br>    return this.width * this.height;<br>  }<br>}<br><br>class Circle implements Shape {<br>  private radius: number;<br><br>  constructor(radius: number) {<br>    this.radius = radius;<br>  }<br><br>  calculateArea(): number {<br>    return Math.PI * this.radius * this.radius;<br>  }<br>}<br><br>// The Shape interface represents a contract for calculating the area of a shape. The Rectangle and Circle classes implement the Shape interface and provide their own implementation of the calculateArea() method.</pre><p>3. Liskov Substitution Principle (LSP): This principle states that objects of a super-class should be replaceable with objects of its sub-classes without affecting the correctness of the program. In simpler terms, it means that sub-classes should be able to be used interchangeably with their base class without causing any issues or violating expected behavior.</p><pre>// Example of LSP<br><br>class Animal {<br>  makeSound(): void {<br>    // Default implementation<br>  }<br>}<br><br>class Dog extends Animal {<br>  makeSound(): void {<br>    console.log(&quot;Woof!&quot;);<br>  }<br>}<br><br>class Cat extends Animal {<br>  makeSound(): void {<br>    console.log(&quot;Meow!&quot;);<br>  }<br>}<br><br>function makeAnimalSound(animal: Animal): void {<br>  animal.makeSound();<br>}<br><br>// The makeAnimalSound function accepts any object of type Animal, including its subclasses (Dog and Cat), and calls the makeSound method. This allows us to treat all animals uniformly, regardless of their specific type.</pre><p>4. Interface Segregation Principle (ISP): This principle states that clients should not be forced to depend on interfaces they do not use. It suggests breaking down large interfaces into smaller and more specific ones, so that clients only need to depend on the interfaces that are relevant to them. This helps avoid unnecessary dependencies and provides better modularity.</p><pre>// Example of ISP<br><br>interface Printable {<br>  print(): void;<br>}<br><br>interface Scanable {<br>  scan(): void;<br>}<br><br>class Printer implements Printable {<br>  print(): void {<br>    console.log(&quot;Printing...&quot;);<br>  }<br>}<br><br>class Scanner implements Scanable {<br>  scan(): void {<br>    console.log(&quot;Scanning...&quot;);<br>  }<br>}<br><br>class AllInOnePrinter implements Printable, Scanable {<br>  print(): void {<br>    console.log(&quot;Printing...&quot;);<br>  }<br><br>  scan(): void {<br>    console.log(&quot;Scanning...&quot;);<br>  }<br>}<br><br>// The Printable and Scanable interfaces define separate responsibilities. Each class (Printer, Scanner, AllInOnePrinter) implements only the interface(s) that are relevant to it. This allows clients to depend on the specific interfaces they need.</pre><p>5. Dependency Inversion Principle (DIP): This principle states that high-level modules should not depend on low-level modules. Both should depend on abstractions. It encourages the use of abstractions and dependency injection to decouple modules and make them more flexible and testable.</p><pre>// Example of DIP<br><br>interface Logger {<br>  log(message: string): void;<br>}<br><br>class ConsoleLogger implements Logger {<br>  log(message: string): void {<br>    console.log(message);<br>  }<br>}<br><br>class FileLogger implements Logger {<br>  log(message: string): void {<br>    // Log the message to a file<br>  }<br>}<br><br>class UserManager {<br>  private logger: Logger;<br><br>  constructor(logger: Logger) {<br>    this.logger = logger;<br>  }<br><br>  addUser(username: string): void {<br>    // Add user logic<br><br>    this.logger.log(`User ${username} added.`);<br>  }<br>}<br><br>// The UserManager class depends on the Logger interface, not concrete implementations. This allows different types of loggers (ConsoleLogger, FileLogger) to be passed to the UserManager, making it easy to switch or extend logging functionality.</pre><p>Software design principles offer numerous advantages that contribute to the development of high-quality, maintainable, testable and scalable software systems. I have learnt from experience that, good understanding of software design principle give software developer better chance to developing good software.</p><p>If you like this article, do well to drop a like and follow. I promise, I’ll write another article tomorrow..</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3d15f4975e16" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>