#100DaysOfCodeChallenge

Day 50: Structuring a MERN Project for Scalability

The MERN stack (MongoDB, Express.js, React, Node.js) is great for building full-stack apps, but if your project is poorly structured, it will lead to bugs, messy code, and maintenance nightmares.

A well-structured backend makes your code more scalable, readable, and secure. This post will guide you through structuring your MERN backend properly using the MVC (Model-View-Controller) pattern.

Why Structure Your Backend Properly?
Separation of concerns → Business logic is separate from database & routes
Scalability → Adding features is easy
Better collaboration → Multiple developers can work efficiently
Recommended Folder Structure

/server
├── controllers/ → Handles logic
├── models/ → Defines data structure
├── routes/ → API endpoints
├── middleware/ → Security & validation
├── config/ → Database & environment variables
├── utils/ → Reusable helper functions
├── index.js → Main server file

Models: Defining Data Structure
Models define how data is stored in MongoDB.
Example: User Model (models/User.js)
Defines user schema
Encrypts passwords
Adds timestamps automatically

const mongoose = require(‘mongoose’);
const UserSchema = new mongoose.Schema({
name: { type: String, required: true },
email: { type: String, required: true, unique: true },
password: { type: String, required: true },
role: { type: String, enum: [“user”, “admin”], default: “user” }
}, { timestamps: true });
module.exports = mongoose.model(“User”, UserSchema);

Controllers: Handling Business Logic
Controllers process requests and interact with models.
Example: User Controller (controllers/userController.js)
Registers a user
Hashes passwords
Handles login authentication

const User = require(‘…/models/User’);
const bcrypt = require(‘bcrypt’);
const jwt = require(‘jsonwebtoken’);
exports.registerUser = async (req, res) => {
try {
//Code Logic Here
} catch (error) { res.status(500).json({ error: error.message }); }
};

Routes: Managing API Endpoints
Routes define API paths and call controllers.
Example: User Routes (routes/userRoutes.js)
Links API endpoints to controllers
Keeps routing separate from business logic

const express = require(‘express’);
const { registerUser, loginUser } = require(‘…/controllers/userController’);
const router = express.Router();
router.post(‘/register’, registerUser);
router.post(‘/login’, loginUser);
module.exports = router;

Bringing It All Together: The Main Server File (index.js)
Loads environment variables
Connects to MongoDB
Sets up routes

image22000×1500 41.5 KB

100daysofcode lebanon-mug

Day 51: Securing Your Node.js Application: Best Practices for Environment Variables, Authentication, and Middleware Security

In today’s digital landscape, security is non-negotiable. Whether you’re building a small side project or an enterprise-level application, securing your Node.js application should be a top priority. Exposing sensitive credentials, neglecting authentication protocols, or ignoring middleware security can lead to devastating consequences, including data breaches and unauthorized access.

In this guide, we’ll explore three crucial aspects of Node.js security:

Environment Variables: Keeping Credentials Safe

One of the most common security mistakes developers make is hardcoding sensitive credentials directly into their source code. Exposing database connection strings, API keys, or secret tokens in your codebase is a major security risk.

Use .env Files to Store Secrets

A better approach is to use environment variables. The dotenv package allows you to load environment variables from a .env file into process.env.

Install dotenv:

npm install dotenv

Configure dotenv in your application:

require(‘dotenv’).config(); const mongoURI = process.env.MONGO_URI;

This ensures that sensitive data is never exposed in your repository. Best practice: Add .env to .gitignore to prevent it from being committed.

Secure Authentication & Authorization with JWT

Authentication ensures that users are who they claim to be, while authorization determines what they can access. A widely used method for secure authentication in Node.js applications is JSON Web Tokens (JWT).

Install JWT:

npm install jsonwebtoken

Generate a JWT Token

When a user logs in, issue a signed token that can be used for subsequent requests. const jwt = require(“jsonwebtoken”); const token = jwt.sign({ userId }, process.env.JWT_SECRET, { expiresIn: “7d” });

Middleware to Verify JWT

To protect routes, use a middleware function to validate JWTs before processing requests. Check the picture for relavent code.

Protecting Routes

Use the authentication middleware to secure sensitive routes.

Middleware Security: Helmet & CORS

Middleware plays a crucial role in securing your Node.js application by protecting it from common web vulnerabilities.

Helmet: Secure HTTP Headers

Helmet helps protect your app by setting various HTTP headers that prevent cross-site scripting (XSS), clickjacking, and other attacks.

Install Helmet:

npm install helmet

Use Helmet in Your App:

const helmet = require(“helmet”); app.use(helmet());

CORS: Controlling Cross-Origin Requests

Cross-Origin Resource Sharing (CORS) determines how your web app handles requests from different domains. By default, browsers block cross-origin requests, but in some cases, you may need to allow them.

Install CORS:

npm install cors

Configure CORS:

const cors = require(“cors”); app.use(cors({ origin: “https://yourfrontend.com” }));

auth726×632 32.7 KB

100daysofcode lebanon-mug

Day 52: Microsoft’s TypeScript Gets a Go-Powered Upgrade!

Microsoft is rewriting the TypeScript compiler in Go (codenamed Corsa)—and the performance gains are massive:
10x faster builds
8x faster project load times
AI-powered developer tools

If you’ve ever felt frustrated by slow TypeScript builds, this could be a game-changer. But wait… why is Microsoft moving away from JavaScript?

Why Not Just Speed Up JavaScript?
JavaScript is fantastic for UI and web apps, but when it comes to compute-heavy workloads like compilers, it hits a major roadblock: single-threading.

JS runs on a single core and lacks true multi-threading support. While features like Shared Structs are in development, they’re not ready yet. On the other hand, Go and Rust have native multi-threading. They can fully utilize multiple CPU cores, massively improving performance. That’s why Microsoft had to look beyond JavaScript.

Why Go? Not Rust? Not C++?
Many expected Rust (like Deno, Turbo, and Rolldown), but Microsoft chose Go for three key reasons:
Ease of porting – Go allows a structured, line-by-line conversion from the existing TypeScript codebase.
Garbage collection – Unlike Rust, Go’s memory management is automatic, simplifying implementation.
Simplicity – Go is easy to write, read, and maintain.

What This Means for Developers
Blazing-fast TypeScript compilation – Say goodbye to long build times.
Lower memory usage – The Go-based compiler will use ~50% less memory than today’s JS version.
AI-powered coding assistance – Faster TypeScript means smarter dev tools.

The JS-based TypeScript (6.x) will continue, but TypeScript 7.0 (native Go) is the future. Expect a preview by mid-2025 and a full rollout by year-end.

v2-12a098a6b26a424672b55a3d756a06e4_720w720×405 155 KB

100daysofcode lebanon-mug typescript

Day 53: Axios vs. React Query, Which One Should You Use in Your React App?

When building a React app, fetching data is a must. But how do you do it efficiently? Two popular options are Axios and React Query. While both can get the job done, they serve different purposes. Let’s break it down for beginners.

Axios: The Classic Choice
Axios is a promise-based HTTP client that simplifies making requests to APIs. It’s widely used for sending GET, POST, PUT, DELETE requests and handling responses.

Why use Axios?
Simple API for making HTTP requests (like axios.get(url))
Supports request/response interception
Allows setting global headers (like authentication tokens)
Works with Node.js as well

What it lacks:
No built-in caching or data synchronization
You need to manually manage loading, error states, and retries
Doesn’t handle automatic background refetching
Example usage:
import axios from ‘axios’;

const fetchData = async () => {
try {
const response = await axios.get(‘url’);
console.log(response.data);
} catch (error) {
console.error(error);
}
};

React Query: The Smart Choice?
React Query is a data-fetching and state management library that abstracts away the complexity of handling API requests. It makes working with server-side data more powerful and efficient.
Why use React Query?
Built-in caching (reduces unnecessary API calls)
Auto-refetching when data becomes stale
Background updates (users always get fresh data)
Error handling & retries out of the box
Infinite scrolling & pagination support

What it lacks:
Slightly steeper learning curve for beginners
Adds extra dependencies (though lightweight)
Might be overkill for simple projects
Example usage:
import { useQuery } from ‘react-query’;
import axios from ‘axios’;

const fetchData = async () => {
const { data } = await axios.get(‘LinkedIn’);
return data;
};

const MyComponent = () => {
const { data, isLoading, error } = useQuery(‘myData’, fetchData);

if (isLoading) return

Loading…

Error: {error.message}

return

Which One Should You Use?
It depends on your needs! Here’s a quick comparison:
FeatureAxiosReact QuerySimple API Requests​:white_check_mark:Global Headers​:white_check_mark: (but can be set via Axios)Caching​:x:Auto-Refetching​:x:Error HandlingManual​:white_check_mark: Built-inBackground Sync​:x:Pagination Support​:x:

Use Axios if:
You just need to fetch data without advanced state management.
Your app is small, and you don’t need caching or auto-refetching.
You want full control over API requests and responses.

Use React Query if:
You want automatic caching, retries, and background refetching.
Your app relies on real-time or frequently updated data.
You need built-in pagination or infinite scrolling.

And as always, happy coding!

100daysofcode lebanon-mug

image501×185 5.59 KB

Day 56 | Mastering React Router: Navigating the Web Like a Pro

Building a seamless single-page application (SPA)? Then React Router should be your best friend. It’s the go-to library for managing navigation in React apps, ensuring users move between views effortlessly without full-page reloads.

But here’s the catch—many developers underutilize or misconfigure React Router, leading to sluggish performance, broken navigation, or confusing user experiences. Let’s break down some key insights:
React Router: The Core Features You Need to Know
Dynamic Routing: Unlike traditional static routing, React Router uses component-based routing, meaning routes are determined at runtime, adapting dynamically.
Nested Routes: Components can have child routes, keeping your UI structured and your code organized. Example:

jsx
<Route path=“/dashboard” element={}>
<Route path=“settings” element={} />

Protected Routes: Need authentication before accessing certain pages? Wrap your routes in a higher-order component (HOC) to check for user permissions.
URL Parameters & Query Strings: Fetch dynamic data based on URL parameters.
jsx
Copy code
<Route path=“/profile/:userId” element={} />
Then access userId using useParams().
Lazy Loading with Suspense: Speed matters. Load components only when needed using React.lazy().

jsx
const Dashboard = React.lazy(() => import(“./Dashboard”));

Common Mistakes That Slow You Down
Using Hash Routing When You Don’t Need It
Unless you’re building for legacy browsers, stick with BrowserRouter for clean URLs.
Forgetting Instead of in v6+
If you recently upgraded, remember Switch is deprecated—use Routes instead.
Not Handling 404s Properly
Always include a wildcard route for unmatched paths:

jsx
<Route path=“*” element={} />

The Bottom Line
React Router is more than just “links and paths”—it’s a powerful tool that can make or break user experience. Optimize routing logic, leverage performance boosters, and avoid common pitfalls to build apps that feel fluid and intuitive.

What are your biggest challenges with React Router? Drop your thoughts below!

100daysofcode lebanon-mug

Day 57 | The Problem with Vibe Coding: Why Students Should Still Learn to Code

There’s a growing narrative that students shouldn’t bother learning to code because AI can do it for them. This idea, often disguised as “vibe coding” (where people rely on AI-generated code without understanding how it works), is dangerous. The reasoning? Just as calculators perform math, kids don’t need to learn arithmetic, right? Wrong.

Learning to Code is Not About Typing Code

People misunderstand the purpose of coding education. It’s not about memorizing syntax—it’s about problem-solving, logic, and breaking down complex tasks. Great developers aren’t just code generators; they are problem solvers who understand system design, efficiency, and optimization.

Just because an AI can generate code snippets doesn’t mean it can build maintainable, scalable, and secure software on its own. If students rely on AI without understanding the underlying logic, they become copy-paste engineers, not actual software engineers.

The Future of Software Engineering is Changing—But Not in the Way You Think

Yes, AI is evolving. Yes, AI-assisted coding (GitHub Copilot, ChatGPT, etc.) is making development faster. But rather than replacing programmers, AI is augmenting them.

AI is great at: Generating boilerplate code Suggesting fixes for common errors Speeding up development workflows

But it’s terrible at: Understanding the business logic behind software Debugging complex, system-wide issues Writing code that is reliable and secure without human oversight

Andrew Ng, one of the most respected AI researchers and professors, shares this viewpoint: AI isn’t replacing programmers—it’s making them 10x more effective. But to take advantage of this, developers need strong fundamentals.

Telling Students “Don’t Learn to Code” is Bad Advice

Imagine telling an aspiring writer not to learn grammar because spellcheck exists. Or telling a surgeon they don’t need anatomy because robotic assistants exist. It’s the same logic when people argue students shouldn’t learn to code.

Yes, AI-generated code is impressive. But without foundational knowledge, how do you know if that code is efficient, secure, and actually works?

The best engineers of the future won’t just know how to code. They’ll know how to think in code—leveraging AI as a tool, not a crutch.

The bottom line? Students should absolutely keep learning to code. But they should also learn how to code with AI, not instead of AI.

What’s your take on AI-assisted coding? Is it making people better engineers or just making them dependent on AI? Let’s discuss!

100daysofcode lebanon-mug

Day 58: Mastering Backend Testing with Postman

One of the most powerful tools in a developer’s arsenal is Postman. It helps track down the source of issues by simulating API requests and verifying responses before integrating with the frontend. Let’s break down how Postman makes backend testing efficient and how to seamlessly transition from backend to frontend testing.

How Postman Simplifies Backend Testing
Postman is more than just an API testing tool—it’s a comprehensive platform that can be used to test endpoints, validate responses, and debug issues. Here’s how it helps identify the root cause of bugs:

1. Isolate Backend Issues Early
   By directly hitting backend APIs, you can determine whether an issue is rooted in the backend or arises from frontend integration. For instance, if an API call fails in Postman but works on the frontend, the issue likely lies in how the frontend handles the response.

2. Test with Precision and Efficiency
   Instead of blindly navigating the entire system, use Postman to make precise API calls with various inputs and observe how the backend responds. This saves time and gives clarity on where the problem originates.

3. End-to-End API Testing
   Postman supports testing complete user flows by chaining multiple API requests. This is particularly useful when simulating multi-step processes such as user registration and login.

Best Practices for Effective Testing
To make your testing organized and effective, here are some essential practices:

1. Organize Endpoints with Collections
   Group your endpoints into collections based on functionality:
   User Management Collection: Test all user-related endpoints like registration, login, and profile updates.

Product Management Collection: Group product CRUD operations.
Order Processing Collection: Include endpoints related to placing and tracking orders.

By structuring your collections this way, you’ll maintain clarity and make it easier to test related endpoints in bulk.

2. Follow the Happy Path First
   Start by testing the happy path—the optimal scenario where everything works as intended. Once validated, move on to edge cases and negative testing to see how the system handles unexpected inputs.

3. Use Environment Variables
   Instead of hardcoding URLs or credentials, use environment variables. This makes it simple to switch between development, staging, and production environments without manually editing every request.

4. Automate with Test Scripts
   Postman’s scripting feature allows you to run assertions after every request. For instance:
   javascript
   pm.test(“Status code is 200”, function () {
   pm.response.to.have.status(200);
   });

This simple script checks that the response status is 200 OK and alerts you if it’s not, making error tracking more manageable.

5. Document Your Tests
   Good documentation not only helps you but also your team. Add descriptions to your requests and collections to explain their purpose and how to use them.

100daysofcode lebanon-mug

postman762×926 55.4 KB

Day 59 | Understanding Different SWE Career Paths

Breaking into software engineering can be overwhelming, especially with roles like backend, frontend, full-stack, DevOps, mobile, and data engineering. Understanding the differences early on can set you up for success in interviews and unlock better opportunities.

Why Does It Matter? Imagine preparing for a backend engineering role by mastering frontend frameworks—sounds counterproductive, right? Knowing the differences helps you focus your learning and prep strategically. Each role demands unique skills and coding practices, and understanding them can save you time and effort.

Backend Engineers: Leetcode Kings Backend engineers handle logic and data management. They master algorithms and data structures (Leetcode is essential) and work with languages like Python, Java, or Go. System design and scalability are crucial skills. Focus on complex problem-solving and competitive programming.

Frontend Engineers: UX Artists Frontend engineers bring visual elements to life and ensure smooth user interaction. They excel in HTML, CSS, JavaScript frameworks (React, Angular), and UI/UX design. Interviews often test dynamic interfaces and DOM manipulation.

Full-Stack Engineers: Versatile Builders Full-stack engineers handle both frontend and backend tasks. They know frameworks like MERN or LAMP, API design, and integration. Interviews cover building full applications and bridging client-server logic.

DevOps Engineers: Deployment Experts DevOps engineers maintain smooth software deployment and CI/CD processes. They master tools like Docker, Jenkins, and cloud platforms (AWS, GCP). Be ready to discuss automated testing and server reliability.

Mobile Engineers: App Builders Mobile engineers develop apps for iOS and Android using Swift, Kotlin, or cross-platform frameworks (Flutter, React Native). Key topics include performance optimization and hybrid vs. native approaches.

Final Thoughts Understanding software engineering roles early on gives you a major edge. Target your learning, build relevant projects, and practice role-specific interview questions. Master the right skills to become the software engineer you aspire to be!

100daysofcode lebanon-mug

Day 60 | Boost Performance Without Breaking the Bank: Server Optimization Tips for SWE

When your application starts slowing down, the knee-jerk reaction is to pay for more server space. But why not first squeeze every bit of performance out of your existing setup? Here’s a technical deep dive into some crucial optimizations that can make a world of difference before you open your wallet.

1. Indexing Matters
   Poor indexing is one of the primary culprits behind sluggish database queries. Before investing in bigger servers, take a close look at your database schema:
   Create Indexes on Frequently Queried Fields: Identify columns that are frequently involved in WHERE, JOIN, and ORDER BY clauses.
   Composite Indexes: Combine multiple columns when they are commonly used together.
   Clustered vs. Non-Clustered: Choose wisely based on your data retrieval patterns.
   Regularly Update Statistics: Keep the query optimizer informed about data distribution.

2. Optimize Your Queries
   Even well-indexed databases can struggle if your queries are inefficient.
   Use Query Profiling Tools: PostgreSQL’s EXPLAIN, MySQL’s EXPLAIN ANALYZE, or SQL Server’s Query Analyzer are invaluable.
   Minimize Select Statements: Instead of SELECT *, specify only the columns you need.
   Avoid Subqueries When Possible: Use joins or common table expressions (CTEs) instead.
   Batch Your Updates: Instead of executing multiple small updates, combine them into one.
   Prepared Statements: Leverage them to improve performance and security.

3. Caching Is Your Best Friend
   If your application constantly retrieves the same data, you’re wasting server resources. Implement caching at multiple levels:
   In-Memory Caching: Use Redis or Memcached for rapid data retrieval.
   HTTP Caching: Leverage response caching and cache headers for static resources.
   Application-Level Caching: Cache expensive computations and frequently accessed data.
   Database Query Caching: Store the results of common queries.

4. Efficient Data Storage
   Bloated databases can drastically slow performance. Keep your data lean and mean:
   Archive Old Data: Move less frequently accessed data to cheaper storage solutions.
   Partitioning: Split large tables to reduce the scanning effort.
   Data Compression: Compress old logs and rarely accessed datasets.
   Garbage Collection: Periodically clean up temporary tables and expired data.

5. Load Balancing and Traffic Distribution
   If your application is highly trafficked, distributing the load can significantly improve performance:
   Reverse Proxying: Use NGINX or HAProxy to balance incoming requests.
   Horizontal Scaling: Add more instances rather than increasing individual server specs.
   Content Delivery Networks (CDN): Serve static assets from edge locations for quicker delivery.

Stay tuned for a part 2!

100daysofcode lebanon-mug

Day 62 | Kickstarting My SQL Series: The Foundation of Data Modeling with the ER Model!

Hey #LinkedInCommunity! Excited to launch my SQL series with a deep dive into one of the most fundamental concepts in database design—the Entity-Relationship (ER) Model!

Where It All Began

The ER model was introduced in 1976 by the brilliant Professor Peter Chen (Chen Pin-Shan) . His groundbreaking paper laid the foundation for how we visualize and structure data relationships today. Before ER, database design was more abstract—Chen gave us a clear, graphical way to map entities, attributes, and relationships.

Why Does the ER Model Matter?

Visual Clarity : It turns complex data structures into easy-to-understand diagrams.

Blueprint for Databases : Serves as the first step before writing SQL schemas.

Improves Efficiency : Helps spot design flaws early, saving time and headaches later.

Key Components

Entities → Real-world objects (e.g., Customer, Product)

Attributes → Properties of entities (e.g., CustomerID, ProductName)

Relationships → How entities interact (e.g., Customer buys Product)

Stay tuned for Part 2, where we’ll translate ER diagrams into SQL tables!

Discussion Time!

How has the ER model helped you in your projects?

Any database design challenges you’ve faced?

#sql 100daysofcode lebanon-mug

Day 63 |:mag: Mastering Weak Entity Sets, Cardinalities, Specialization & Generalization in Databases!

Data modeling is the backbone of efficient databases, and understanding key Entity-Relationship (ER) model concepts is crucial. Let’s break down four essential concepts:

Weak Entity Sets
Not all entities are independent! Some lack a primary key and must rely on a strong entity through a relationship set. These are called weak entity sets and must have:
A discriminator (partial key) to differentiate among instances.
A total participation constraint, meaning they must be linked to a strong entity.
A supporting relationship, called an identifying relationship, that connects them to a strong entity.
Example: Consider an Employee-Dependent relationship. A Dependent (child/spouse) doesn’t have a unique identifier but can be identified using Employee_ID + Dependent_Name. Without linking to an Employee, the Dependent entity has no existence in the database.

Cardinalities & Relationship Constraints
Cardinality defines how many instances of an entity can be related to another. Understanding this ensures data integrity and efficient queries.
Types of Cardinality:
One-to-One (1:1): Each entity in A maps to at most one entity in B.
Example: A person has one passport, and each passport belongs to one person.
One-to-Many (1:M): An entity in A maps to multiple entities in B.
Example: A manager supervises multiple employees, but each employee has only one manager.
Many-to-Many (M:N): Each entity in A relates to multiple entities in B, and vice versa.
Example: Students enroll in multiple courses, and each course has multiple students.

Specialization vs. Generalization
As databases grow, organizing data becomes vital. This is where specialization and generalization help refine entity structures.
Specialization (Top-Down Approach):
We start with a generic entity and divide it into sub-entities based on distinguishing characteristics.
Example: A Vehicle entity specializes into Car and Bike . Cars have a fuel type, while bikes may not.
Generalization (Bottom-Up Approach):
Here, we merge multiple similar entities into a higher-level super-entity to avoid redundancy.
Example: A Doctor and a Nurse share common attributes (e.g., Name, Salary), so they generalize into MedicalStaff.
Why Does This Matter?
Weak entity sets prevent orphaned data in relationships.
Cardinalities enforce integrity, ensuring logical data mapping.
Specialization adds precision, while generalization reduces redundancy.

Mastering these concepts leads to better data normalization, query performance, and scalability!

Which of these have you used in your projects? Drop your thoughts in the comments!

100daysofcode lebanon-mug

Picture13690×3046 273 KB

Day 64: Understanding the Relational Model and Ensuring Consistency

Databases are everywhere, powering applications that range from social media platforms to financial systems. But how do we make sure that the data inside them is reliable, consistent, and useful? Today, we’re diving into the relational model, one of the most robust ways to manage structured data. We’ll also explore how to maintain database consistency—a critical aspect that ensures your data remains trustworthy.

Relational Model Basics

The relational model, introduced by E. F. Codd in 1970, revolutionized data storage by structuring data into tables (relations). It offers a logical way to represent data independently from the physical storage. Let’s break down the essential terms in both informal and mathematical contexts:

The relational model is fundamentally about relations (or tables), where each relation consists of tuples (or rows), each described by a set of attributes (or columns). The domain of an attribute defines its possible values, like numbers or strings.

Consistent vs. Inconsistent Databases

Let’s say you manage a database of student records. A consistent database might have a student with ID 123 listed as “John Smith” in both the Enrollment and Grades tables. An inconsistent database could show the same ID linked to two different names across these tables. Such inconsistencies are more than just nuisances—they can undermine trust and break system functionality.

Maintaining Database Consistency

Maintaining consistency is crucial to ensure that data across tables and applications remains accurate and reliable. Here are some key techniques:

1. Normalization

Breaking data into smaller, non-redundant tables reduces the chances of inconsistency. Normalization ensures that one piece of information is stored only once.

2. Constraints

Apply integrity constraints like primary keys, foreign keys, and unique constraints to enforce data consistency. This means that records are uniquely identified and linked properly between tables.

3. ACID Properties

Database transactions should follow ACID (Atomicity, Consistency, Isolation, Durability) principles to ensure that operations either complete successfully or leave the database unchanged. This is especially important when performing multiple updates or batch operations.

4. Data Validation

Validate data both at the application level and database level. Use triggers or check constraints to automatically verify data before insertion or update.

5. Backup and Recovery

Maintaining consistency also involves periodic backups and implementing recovery mechanisms. This helps revert to a previous consistent state in case of system failures.

Common Pitfalls

1. Circular References: Linking tables in a circular way can result in inconsistencies and difficulties in maintaining data integrity.
2. Improper Use of NULL: Overuse or misuse of NULL values can lead to ambiguity in data interpretation.
3. Schema Drift: Unplanned changes to the database schema can introduce inconsistencies.

Key Takeaways

Maintaining a consistent database is not just about technical correctness but also about maintaining data integrity and trustworthiness. By understanding the relational model and implementing consistency practices, you can build reliable and scalable systems.

Got thoughts on relational models? Share your experiences or challenges in the comments below!

100daysofcode lebanon-mug

Day 65 | SQL Basics: Schema, Tables, Primary & Foreign Keys Explained!

In the world of SQL, structuring your data efficiently is the key to building scalable and organized databases. Whether you’re just starting out or brushing up on your skills, understanding schemas, tables, primary keys, and foreign keys is crucial! Let’s dive into the essentials!

Schema

A schema is like a container for your database objects - think of it as an organizational unit! It holds tables, views, and other objects, allowing for better structure and access control.

Imagine you’re managing a company database. You might have a schema named CompanyDB to hold all related tables, such as employees, departments, and projects.

Syntax:

sql

CREATE SCHEMA CompanyDB;

Tables

Tables are where your data lives! They consist of rows and columns, each column having a specific data type (like INTEGER, VARCHAR, or DATE).

For example, in our company database, we might have:

Employee table for personal details

Dependent table for employee dependents

Department table for different departments

Project table for ongoing projects

WorksOn table to track which employee works on which project

Syntax:

sql

CREATE TABLE Employee (

emp_id INT PRIMARY KEY,

first_name VARCHAR(50),

last_name VARCHAR(50),

dept_id INT

);

Primary Key

A primary key uniquely identifies each row in a table. No two rows can have the same primary key, ensuring data integrity.

In the Employee table, the emp_id column is the primary key, making each employee uniquely identifiable.

Syntax:

sql

PRIMARY KEY (emp_id)

Foreign Key

A foreign key creates a link between two tables. It enforces relationships and maintains referential integrity between data. For instance, the WorksOn table needs to link employees to projects.

Syntax:

sql

CREATE TABLE WorksOn (

emp_id INT,

proj_id INT,

hours_worked DECIMAL(5,2),

FOREIGN KEY (emp_id) REFERENCES Employee(emp_id),

FOREIGN KEY (proj_id) REFERENCES Project(proj_id)

);

Example: Database Design

Here’s how the design fits together:

Employee table holds employee data.

Dependent table stores employee-dependent details.

Department table keeps department info.

DepLocation table tracks where departments are located.

Project table holds project details.

WorksOn table records which employees are assigned to which projects.

These tables are linked through primary and foreign keys, creating a robust relational database that minimizes redundancy!

Why It Matters

Efficient database design helps maintain data consistency and integrity. By leveraging schemas and relational keys, you’re building a scalable structure that can grow with your data needs.

Whether you’re a beginner or a pro, mastering these SQL fundamentals will set you up for success. Happy coding!

100daysofcode lebanon-mug

sql2250×1345 166 KB

Day 66 |:rocket: Overcoming Imposter Syndrome as a Junior Software Engineer

Let’s talk about something many of us in tech rarely say out loud: Imposter Syndrome. That nagging feeling that you’re not good enough, that you don’t belong, or worse — that someone’s going to “find out” you’re faking it.

As a junior software engineer, I’ve felt it. You’ve probably felt it.

Why It’s So Common in Tech

Software engineering moves fast. Every day there’s a new framework, a new best practice, or a GitHub repo that makes you question your existence.

We work in environments that often reward output over learning, and it’s easy to feel like you’re falling behind — especially when:

You’re struggling to understand legacy code

You can’t fix a bug after 3 hours of trying

Everyone seems to “get it” except you

Spoiler: They don’t. They’re just googling faster.

Imposter Syndrome ≠ Incompetence

In fact, feeling like an imposter is often a sign of growth. You’re challenging yourself. You’re out of your comfort zone — and that’s where learning happens.

But it can be paralyzing if left unchecked.

What Actually Helps

Talk About It

Open up to teammates, mentors, or LinkedIn folks. You’ll be surprised how many people feel the same.

Join a CS Club or Tech Community

Seriously, don’t go through this journey alone. Whether it’s a university CS club, a local dev group, or an online community — surrounding yourself with others who are learning, building, and sharing is game-changing. You’ll learn faster, feel less isolated, and stay inspired.

Track Your Progress

Keep a “brag doc” — a list of bugs you fixed, features you shipped, or even concepts you understood better. Watch how far you’ve come!

Ask Questions — Fearlessly

Asking doesn’t make you look dumb. It shows you’re engaged and willing to grow.

Stay Curious & Excited

Let your passion lead you. Tinker with side projects, explore new tech, attend hackathons — curiosity is your superpower. The more excited you stay, the faster the fear fades.

Don’t Compare Your Chapter 1 to Someone Else’s Chapter 20

Your senior might seem like a wizard now, but they were once stuck on their first null pointer exception too.

Practice Self-Compassion

Tech is hard. You’re not supposed to know everything. You’re supposed to learn.

Final Thought

If you’re a junior SWE battling self-doubt, just remember:

You’re not an imposter. You’re a beginner. And beginners grow.

Stay curious. Stay excited. Keep learning. You’ve got this.

100daysofcode lebanon-mug

Day 67 | Why Mastering DSA Still Matters in 2025

Whether you’re building scalable systems, optimizing a product, or cracking the next coding interview — Data Structures & Algorithms (DSA) remain foundational to success in tech. Yet many overlook it, dismissing it as “just interview prep” or “academic theory.” That mindset is costing developers long-term growth.
Here’s why DSA still matters — and why I’m starting this new series:
Problem Solving Muscle
At its core, DSA trains your brain to approach challenges methodically. It’s like going to the gym for your logic — improving how you think, not just what you code.
Real-World Optimization
Understanding time and space complexity isn’t just for whiteboard interviews. It translates directly to efficient code in real-life applications:
• A faster search algorithm in an e-commerce backend
• Memory-optimized data handling for edge devices
• Reduced latency in real-time systems
Systems Design Foundation
Before you scale, you simplify. Before you scale, you structure. Knowing when to use a hash map over a tree or why a heap can outperform a queue — that’s DSA in action. It gives you the building blocks that enable high-level design.
Interview-Ready, Yes — But Career-Ready Too
Mastering DSA isn’t just about passing tech interviews. It’s about having confidence when faced with ambiguous problems and being able to engineer clean, efficient, maintainable solutions.

What’s Next?
In the coming weeks, I’ll be diving into practical DSA topics:
Hidden performance traps in common algorithms
Real-world DSA use cases from backend, frontend, and data
Simplifying complex topics like recursion, graphs, and dynamic programming

100daysofcode lebanon-mug

Day 68 | Real-World Use Cases of DSA You’re Already Relying On

If you’ve ever asked yourself “When am I really going to use Data Structures and Algorithms?” — you’re not alone. For many professionals outside of competitive programming or academia, DSA can seem abstract. But the truth is, behind nearly every system we interact with, there’s a carefully crafted blend of DSA at work.

Here are 5 practical, real-world cases where DSA isn’t just useful — it’s essential:

1. Navigation Apps: Graphs in Action

Whether it’s Google Maps calculating the fastest route or Uber matching you with the nearest driver, graphs and shortest path algorithms (like Dijkstra’s) are the stars here. Roads become nodes and distances become weights. Efficient route planning = happy users.

2. Autocorrect & Search Suggestions: Tries & Heuristics

Typing “algor…” and getting “algorithm” as a suggestion? That’s not magic — it’s a Trie (prefix tree) behind the scenes. Combined with frequency data and edit distance algorithms (like Levenshtein), it helps your phone guess what you meant — even with typos.

3. Databases & Indexing: Trees and Hashing

Ever wondered how SQL queries return results in milliseconds? Thank B-trees and hash maps. Indexing structures speed up search and retrieval, especially in large datasets. Without them, your queries would take ages.

4. Social Media Feeds: Heaps, Queues & Graphs

Your Instagram or LinkedIn feed? Not random. It’s sorted based on relevance, engagement, or recency using priority queues, heaps, and sometimes even graph-based algorithms to suggest content from your extended network.

5. Cybersecurity & Network Routing: Queues, Trees, Graphs

Firewalls and routing protocols often rely on tries and prefix trees for IP matching. Queues and graphs are essential in packet routing and network traffic optimization, ensuring data gets from point A to point B without chaos.

TL;DR: DSA isn’t just academic — it’s operational. From your morning scroll to your late-night food delivery, algorithms are quietly at work. Mastering them isn’t about passing a coding test — it’s about understanding the systems that run the digital world.

100daysofcode lebanon-mug

Day 69 | Understanding Recursion in DSA (Beginner Friendly)

When you’re just starting your journey into Data Structures and Algorithms (DSA), one of the first powerful tools you’ll encounter is recursion. At first, it might seem confusing — functions calling themselves? But once you understand it, recursion becomes an elegant way to solve many complex problems with concise code.

What is Recursion?

Recursion is a method where the solution to a problem depends on solving smaller instances of the same problem.

In simple terms, a recursive function is one that calls itself.

To prevent infinite loops, every recursive function must have:

Base Case: The condition that stops the recursion.

Recursive Case: The part where the function calls itself with a smaller input.

Example: Factorial

python

def factorial(n):

if n == 0:         # Base case

    return 1

return n * factorial(n - 1)  # Recursive call

Calling factorial(5) will result in:

5 * 4 * 3 * 2 * 1 = 120

How Recursion Works (Call Stack)

Each recursive call is pushed onto the call stack, and the function resumes after each inner call returns. This is why understanding stack memory is important — too many calls can lead to a stack overflow.

Visualization

ruby

CopyEdit

factorial(3)

=> 3 * factorial(2)

    => 2 * factorial(1)

            => 1 * factorial(0)

                    => 1

As the calls resolve, they “unwind” from the stack.

When to Use Recursion

Recursion is ideal when:

A problem can be broken down into similar subproblems.

The problem naturally fits a divide-and-conquer approach.

The problem involves tree/graph traversal, permutations, or backtracking.

But keep in mind: recursion isn’t always efficient. Sometimes an iterative solution is better due to space concerns.

Tips to Master Recursion

Write down the base case before the recursive logic.

Use print statements to trace recursive calls.

Practice dry-running your function on paper.

Learn to convert recursive logic to iterative, and vice versa.

Final Thoughts

Recursion is a pillar of problem-solving in computer science. It helps you think recursively, which is essential for topics like divide and conquer, trees, and backtracking. Start with easy problems and gradually build up to more complex challenges. And most importantly, don’t be afraid of recursion — embrace it!

100daysofcode lebanon-mug

koch_snowflake800×240 7.14 KB