DEV Community: Samana Mirza

Mastering SQL: Optimizing Queries with Smarter Techniques

Samana Mirza — Mon, 03 Mar 2025 10:20:04 +0000

SQL is powerful, but writing efficient and readable queries makes all the difference. While working on various databases, I’ve discovered some underrated SQL concepts that improve both performance and maintainability.

Let’s explore some key SQL best practices, with practical examples to help you optimize your queries!

1️⃣ COALESCE vs. ISNULL – Handling NULLs the Right Way

Both COALESCE and ISNULL handle NULL values, but COALESCE offers more flexibility.

`SELECT ISNULL(NULL, 'Fallback');   -- Returns: 'Fallback'
SELECT COALESCE(NULL, NULL, 'Fallback', 'Another Value');  -- Returns: 'Fallback'`

✔ Use COALESCE when checking multiple values, as it returns the first non-null value.
✔ ISNULL is limited to two arguments and may cause unexpected type conversions.

2️⃣ Avoid IN – Use JOIN for Better Performance

Using IN in subqueries is often slower than a JOIN.

-- Using IN (Slower)
SELECT name FROM Employees WHERE department_id IN (SELECT id FROM Departments WHERE location = 'NY');

-- Using JOIN (Faster)
SELECT e.name FROM Employees e JOIN Departments d ON e.department_id = d.id WHERE d.location = 'NY';

✔ JOIN is optimized by the SQL engine and executes faster on large datasets.

3️⃣ Aliases – A Good Practice Even for Simple Queries

Aliases (AS) improve readability and make queries more maintainable.

SELECT e.name AS EmployeeName, d.name AS DepartmentName 
FROM Employees e 
JOIN Departments d ON e.department_id = d.id;

✔ Even in small queries, aliasing enhances clarity and is extremely helpful in complex queries.

4️⃣ GROUP BY vs. PARTITION BY – Understanding the Difference

GROUP BY aggregates data into a single row per group, whereas PARTITION BY preserves all rows and applies window functions.

-- GROUP BY (Collapses rows)
SELECT department_id, COUNT(*) AS EmployeeCount FROM Employees GROUP BY department_id;

-- PARTITION BY (Keeps all rows)
SELECT name, department_id, COUNT(*) OVER (PARTITION BY department_id) AS EmployeeCount FROM Employees;

✔ Use GROUP BY for summary data.
✔ Use PARTITION BY when you need group-based calculations without losing row-level details.

5️⃣ LAG & LEAD – Accessing Previous & Next Row Data

When comparing current vs. previous/future records, LAG & LEAD eliminate the need for self-joins.

SELECT name, salary, 
       LAG(salary) OVER (ORDER BY id) AS PreviousSalary,
       LEAD(salary) OVER (ORDER BY id) AS NextSalary
FROM Employees;

✔ LAG() fetches the previous row’s value.
✔ LEAD() fetches the next row’s value.

Ideal for trend analysis, financial reports, and comparative analytics.

6️⃣ RANK() vs. DENSE_RANK() – Choosing the Right Ranking

Both assign ranks, but they handle duplicates differently.

SELECT name, department, salary,
       RANK() OVER (PARTITION BY department ORDER BY salary DESC) AS Rank,
       DENSE_RANK() OVER (PARTITION BY department ORDER BY salary DESC) AS DenseRank
FROM Employees;

✔ RANK() skips numbers after duplicates. (eg. Rank - 1, 2, 2, 4, 5)
✔ DENSE_RANK() assigns consecutive numbers. (eg. Rank - 1, 2, 2, 3, 4)

Use DENSE_RANK() when you don’t want ranking gaps.

7️⃣ JOIN vs. UNION – How They Differ

JOIN combines columns from multiple tables, while UNION stacks rows.

-- JOIN (Merging column data)
SELECT e.name, d.name FROM Employees e JOIN Departments d ON e.department_id = d.id;

-- UNION (Stacking results)
SELECT name FROM Employees UNION SELECT name FROM Contractors;

✔ Use JOIN when you need more details from related tables.
✔ Use UNION when you want to combine results from similar tables.

8️⃣ The Power of SUBSTRING() , STRING_AGG() , GROUP_CONCAT()

SUBSTRING() extracts parts of a string.

Both STRING_AGG and GROUP_CONCAT are used to concatenate multiple row values into a single string with a specified separator. However, there are some differences in syntax and capabilities.

SELECT SUBSTRING('Software Developer', 1, 8); -- Returns: 'Software'

SELECT 
    Class, 
    STRING_AGG(Name, ', ') WITHIN GROUP (ORDER BY Name ASC) AS StudentNames
FROM Students
GROUP BY Class;

SELECT 
    Class, 
    GROUP_CONCAT(Name ORDER BY Name ASC SEPARATOR ', ') AS StudentNames
FROM Students
GROUP BY Class;

✔ Great for data cleaning and reporting.

9️⃣ The Benefit of CTEs & Aliasing Subqueries

Common Table Expressions (CTEs) improve readability and avoid repeated subqueries.

WITH DepartmentCount AS (
    SELECT department_id, COUNT(*) AS EmployeeCount FROM Employees GROUP BY department_id
)
SELECT e.name, d.EmployeeCount FROM Employees e JOIN DepartmentCount d ON e.department_id = d.department_id;

✔ CTEs enhance query structure and avoid nested complexity.

🔟 Optimizing JOIN Conditions – AND vs. WHERE

Instead of filtering in WHERE, apply conditions in ON for better index usage.

-- Less efficient
SELECT e.name FROM Employees e JOIN Departments d ON e.department_id = d.id WHERE d.location = 'NY';

-- More efficient
SELECT e.name FROM Employees e JOIN Departments d ON e.department_id = d.id AND d.location = 'NY';

✔ ON filters before the join happens, improving performance.

1️⃣1️⃣ Avoid SELECT * – Specify Columns

Fetching only required columns improves query speed.

-- Avoid this
SELECT * FROM Employees;

-- Do this instead
SELECT name, salary FROM Employees;

✔ Reduces memory usage & speeds up query execution.

1️⃣2️⃣ SQL Execution Order –

Understanding execution order helps write optimized queries. The order is -

FROM → JOIN → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT

SELECT department_id, COUNT(*)
FROM Employees
WHERE salary > 50000
GROUP BY department_id
HAVING COUNT(*) > 5;

✔ Queries execute in a different order than written. Hence, they should be written keeping in mind the execution order to improve performance. A useful mnemonic to remember SQL execution is:

"Fresh Juices With Great Healthy Sweet Orange Lemon"
Fresh → FROM
Juices → JOIN
With → WHERE
Great → GROUP BY
Healthy → HAVING
Sweet → SELECT
Orange → ORDER BY
Lemon → LIMIT

1️⃣3️⃣ Using LEFT() & RIGHT() for String Manipulation

SELECT LEFT('Developer', 3); -- Returns 'Dev'
SELECT RIGHT('Database', 4); -- Returns 'base'

✔ Great for handling text-based transformations.

Final Thoughts

Mastering these SQL techniques can significantly optimize queries, improve performance, and make your code cleaner and more maintainable. However, it’s important to note that SQL functions and behaviors can vary across different database engines.

For example:

GROUP_CONCAT is available in MySQL but not in SQL Server or PostgreSQL. Instead, they use STRING_AGG.

ISNULL is specific to SQL Server, whereas COALESCE is ANSI SQL-compliant and works across PostgreSQL, MySQL, and others.

LAG and LEAD are widely supported in modern databases but may have different implementations.

When working with SQL, always check the documentation of the specific database engine you’re using to ensure compatibility and take advantage of engine-specific optimizations.

👉 Which of these techniques have you used before? What other underrated SQL tricks have helped you? Let’s discuss!

Happy DevLogging! <3

Creating My Own Portfolio Website

Samana Mirza — Thu, 20 Feb 2025 04:33:10 +0000

A year into the software industry, I felt it was time to build my own developer portfolio—a space that reflects my skills, experience, and personality. With a clear goal in mind, I started this journey, and here's how I navigated through the process.

Laying the Foundation

The approach was simple: minimalistic yet eye-catching. I scavenged through multiple developer portfolios, taking major inspiration from Brittany Chiang’s portfolio. Since a portfolio is more about UI than logic, my primary concern was CSS and design choices.

Before writing a single line of code, I spent time choosing the right color theme and font, deciding on relevant sections, and mentally creating a basic foundation. The most crucial part is getting the structure right:

Setting colors globally
Maintaining consistent margins
Dividing pages into structured sections

Once this was done, adding new sections became easy, thanks to React’s modular approach. With React and Tailwind CSS, implementing designs became seamless, and responsiveness was a priority. One key element was ensuring a smooth transition from a top navbar (for larger screens) to a toggle menu (for mobile screens) while adjusting the contact icons from fixed side placement to a bottom bar. These small details significantly improve user experience.

Keeping It Practical

One key learning: Your portfolio should reflect you. There is no need for fancy elements or heavy 3D animations if they negatively impact performance. Initially, I spent a lot of time looking for the perfect 3D animations, only to later scrap them off completely.

For beginners, I recommend keeping things simple and minimal. You can always revamp and add advanced elements later. Focus on building a strong foundation first:

Start with a basic structure
You don't need every single detail planned from the beginning
Work on one section at a time, optimize, and then move forward

For the contact section, I integrated EmailJS, making it easier for visitors to send me a direct message via email.

Essential Portfolio Sections

While portfolios are highly personal, I feel these key sections are must-haves:

About – A brief introduction
Skills – Highlighting core expertise
Experience – Work history & contributions
Projects – Showcasing past work
Contact – Easy ways to reach out

Additional sections that can enhance the portfolio:

Testimonials – Feedback from peers/clients
Blogs – Personal or technical write-ups
Certifications – Showcasing achievements
Publications – Any research or articles

Although my portfolio is complete, there’s always room for improvement. I am now working on Search Engine Optimization (SEO) and adding page/element animations using Framer Motion to enhance the user experience.

Share Your Portfolio Insights!

Check out my portfolio: samana-mirza.vercel.app
GitHub Repository: github.com/samana-bm20/portfolio

I hope this post helps anyone struggling with laying the initial foundation for their portfolio.

Since I have just one year of experience, I’d also love to hear from fellow developers who have been in this position before about their portfolio building experience.

Questions for you reading this post:

Is there anything important missing from my portfolio?
Is it easy to navigate?
What are your overall thoughts on the site?

I’ll be grateful to anyone sharing their inputs!

Conquering Node.js Hurdles

Samana Mirza — Fri, 13 Dec 2024 04:30:43 +0000

Hey Readers!

Out of frontend, database, and backend development, backend has always been the most challenging part for me. This article delves into my early journey in backend development with Node.js , sharing both struggles and insights. You'll learn about the common beginner pitfalls and practical ways to navigate through them, gaining clearer understanding of key backend concepts.

Backend Blues and Initial Challenges

The Initial Struggles

Backend development has been a crucial part of the web development journey. For someone who finds joy in the creativity of frontend designs and the structured logic of databases, backend seemed like an uncharted territory confusing and, honestly, not as exciting.

Yet, I chose to explore Node.js, a runtime environment for JavaScript. Why? Because it bridges the gap between frontend and backend using the same language, JavaScript. This promise of unification drove me to dive into the world of servers, APIs, and middleware.

Starting with Node.js was like entering a maze without a map. I had no clue how to run a program, what cors, express, or body-parser meant, or why they were even necessary. My initial approach to setting up a backend was heavily reliant on seniors. But one day, they refused to help, encouraging me to learn through research and experimentation. It was a tough-love moment, but it was also the turning point in my journey.

Understanding the Basics

That was when I began to slowly understand the "why" behind all the confusing pieces of backend development. With persistence, I learned about tools like Express, CORS, and body-parser. These tools form the foundation of backend development:

Express : It is a Node.js framework that simplifies server creation by providing powerful tools to define routes, manage middleware, and handle requests and responses effectively.
CORS(Cross-Origin Resource Sharing): It is a mechanism that allows resources to be requested from a different domain. It is crucial for enabling communication between the frontend and backend hosted on separate servers (e.g., a frontend application hosted on one server to a backend API hosted on another are allowed, overcoming the "same-origin" policy limitations).
Body-Parser : A middleware that parses incoming request bodies, converting them into usable data formats (e.g., JSON), which streamlines handling data sent from the frontend.

Each of these tools had its role in connecting the frontend to the database and facilitating seamless communication.

The Role of NPM

npm (Node Package Manager) was a revelation. It simplified installing and managing dependencies. Initially, I made the rookie mistake of including node_modules in my .rar files when sharing projects. A senior pointed out that I could use npm install to re-download dependencies and avoid bloating my project files. That day, I also learned about .gitignore for excluding unnecessary files from GitHub repositories.

Breaking Down the API Calls

Setting Up Your First Backend

Starting with npm init -y became my ritual. From there, I installed necessary packages like express and cors. Once the setup was ready, I ventured into API calls. This was a significant milestone as it involved connecting various components and making the application functional. I learned that app.listen starts the server, and .env variables help manage sensitive data like database credentials. Middleware, such as body-parser and custom logic for authentication, became essential for preprocessing incoming requests before they reached the server logic.

Making API Calls: GET, POST, PUT, DELETE

Understanding HTTP methods was a game-changer:

GET : Used to fetch data from the server. The parameters are typically passed via the URL, allowing the backend to retrieve and send the requested data.
POST : Designed for submitting data to the server, often sent in the request body for tasks like form submissions.
PUT : Helps update existing data on the server, ensuring that the data remains current.
DELETE : Removes specified data from the server.

Might sound funny but it took me months to fully grasp the difference between GET and POST requests and to correctly structure API calls. I often used to pass parameters in the API URL for POST requests, which is actually the correct method for GET requests. In a POST request, parameters should only be passed in the request body. Debugging these calls was another learning curve, involving tools like Postman for detailed testing.

Debugging APIs

Debugging backend code felt more challenging than frontend debugging because, in the frontend, you can easily add a debugger or use inspect tools. However, I gradually discovered that tools like VS Code's debugging features made it possible. I learned to start debugging from the server.js file, ensuring I could trace issues effectively.

Modularizing APIs

Just as I modularized React components to improve organization and reusability, I learned to apply the same principles to APIs by organizing them based on functionality. This process involved separating routes and controllers into distinct modules, which made the codebase much cleaner and more manageable. By categorizing APIs according to their specific functions, I was able to streamline the development process, making it easier to locate and modify code when needed.

Optimizing API Performance

By analyzing response times in the network tab, I optimized database queries to ensure they were as efficient as possible, reducing the time it took to retrieve and process data. Additionally, some API calls were redundant, which led to unnecessary delays. For instance, instead of separate calls for updating table data and specific attributes, I streamlined the process by refining the logic to handle all updates in one comprehensive call.

Advanced Learnings

Authentication and Security with JWT

Securing APIs became a priority. Using JWT (JSON Web Tokens), I implemented authentication systems that ensured only authorized users could access certain data. This was vital for preventing sensitive data exposure in browser developer tools. Later, I advanced by using JAuth to authenticate users in an application and using tokens to fetch API data. This method of securing data is essential because, without it, any API fetch or retrieval shows data in the inspect network tab, which is a significant vulnerability for a proper application.

File Handling with Multer and File-Saver

Using libraries like Multer , I handled file uploads, while File-Saver allowed dynamic file downloads. These tools made it easier to manage user data efficiently. Multer is middleware for handling multipart/form-data, which is commonly used for uploading files in Node.js applications. With Multer, you can easily manage receiving, storing, and validating files on the server. File-Saver is a JavaScript library that enables dynamic file downloads directly from the browser, allowing users to save files without leaving the application. Together, these tools efficiently manage both file uploads and downloads, providing a smooth experience for users interacting with files in your app.

Real-Time Notifications with Socket.IO

Implementing real-time features like notifications using Socket.IO was a challenging yet rewarding experience. I navigated concepts like socket.on, socket.emit, and room management. Deploying this on a live server was another hurdle, requiring specific configurations for seamless functionality. Using settings like:

Polling : It is a communication method where the client repeatedly sends HTTP requests at regular intervals to the server to check for updates, rather than keeping a persistent connection open. This is typically used when WebSockets are not available or suitable.
Reconnection : Enables automatic reconnection in case of network interruptions or connection loss, ensuring better reliability for real-time communication.

These settings were part of the frontend, enabling a smooth connection with the backend logic on a live server.

Reflections and Growth

Backend development was never my comfort zone, but the journey transformed it into a valuable skill set. From struggling with basic setups to implementing advanced features, every challenge taught me resilience and problem-solving. Today, I see backend as a critical part of creating seamless, full-stack applications. The road wasn't easy, but the results were worth every effort. To all the budding developers out there, when you finally see the results of your hard work, combining both frontend and backend, it is all worth it. To sail through and reach your destination, you need to experience the tides and storms.

Keep learning, keep growing, and remember: even the most confusing parts of coding eventually make sense with persistence and practice!

Happy DevLogging! <3

~s.b.m.

WomenWhoTech#Backend#Development#NodeJS#API#ExpressJS

Balancing the Art of CSS and UI Libraries

Samana Mirza — Thu, 12 Dec 2024 04:30:37 +0000

Hello Developers!

CSS and UI libraries often feel like a tangled web of complexity, but they hold the power to create stunning user interfaces. In this article, I share my journey of mastering CSS and balancing it with UI libraries like Tailwind CSS and Material-UI. Along the way, you'll discover practical lessons, insights, and tips to help you navigate this intricate world.

The Early Struggles with CSS

When I started with CSS, it felt like an unsolvable puzzle. Simple things like setting margins or understanding the difference between padding and margin confused me, despite being familiar with the box model. Id often find myself stuck on seemingly minor issues like_why a div wouldnt take up the full height of the screen?_only to realize I had written height: full instead of height: screen. Very dumb, right?

Positioning was another hurdle. Terms like absolute and relative felt abstract, and I struggled to relate parent and child components effectively. Debugging CSS issues often consumed hours. Id wonder why margin: 0 was necessary, thinking it should be the defaultuntil I faced layouts where those extra margins appeared out of nowhere. Even now, getting the perfect layout can be challenging, but flexbox remains my go-to solution for most alignment issues.

However, responsiveness was the biggest challenge. Early on, inspecting my designs in mobile view was a nightmare. The layout would break entirely, revealing a lack of foundational knowledge. Gradually, I learned the importance of relative units like rem, em, and vh over fixed units like px. Dividing elements into grids and leveraging media queries helped immensely, though I havent entirely mastered the latter.

Yes, I did use Bootstrap, which by all means is a good tool for all developers starting out. However, it was short-lived for me as I switched to Tailwind CSS soon after. For anyone trying Bootstrap, its a solid choice to get familiar with structured UI design.

Key Lesson: Use relative units and grid-based layouts for responsive designs. Media queries are essential but can often be simplified using modern frameworks like Tailwind.

Switching to Tailwind CSS: A Game-Changer

Switching to Tailwind CSS felt counterintuitive at first. The long class names seemed chaotic, and setting it up in React was a daunting task. But once I got the hang of it, Tailwind revolutionized how I approached styling. I could write styles directly in HTML without worrying about naming conflicts.

Time-Saving Features: Predefined classes like m-4, p-2, and shadow-md replaced repetitive CSS.
Custom Configurations: Tailwind's configuration file tailwind.config.js allowed me to customize themes, fonts, and colors, making my workflow seamless.
Built-In Responsiveness: Earlier, responsiveness felt like an afterthought. But Tailwind included intuitive breakpoints like md: and lg: which could be easily customized, allowing me to create adaptive designs without writing separate media queries.

Key Lesson: Tailwind CSS simplifies styling and responsiveness, but mastering its utility-first approach takes practice.

UI Libraries: The Magic of Pre-Designed Components

My first brush with a UI library was with Core UI. It was a pre-designed template, and I struggled to make changes due to lack of understanding. This experience taught me the importance of reading documentation and experimenting to learn. However, working with Material-UI (MUI) was the turning point.

Customization Made Easy: The createTheme function allowed me to define theme colors and typography globally, making my designs consistent and professional.
Pre-Designed Components: Elements like buttons, text fields, tabs, skeleton loaders, and progress bars saved me time and effort.
Finding the Balance: The real challenge was learning when to use Tailwind and when to rely on a UI library. Initially, I used MUI for almost everything, from layouts to individual components. Over time, I realized that Tailwind excels in layout and responsiveness, while UI libraries shine in pre-designed elements. Combining the two unlocked new levels of efficiency and creativity.

Additionally, I also explored Aceternity UI library when I needed visually pleasing elements. It offers pre-designed components with intricate animations, transitions, and backgrounds, simplifying what would otherwise be tedious to implement. Its ease of useinstalling the library and copying guided code for customizationmakes it attractive. However, tweaking styles or modifying its code can be complex due to its inherent structure. Still, it can be a great choice for someone who wishes to add visual flair to projects.

Key Lesson: Use UI libraries for pre-designed components and CSS frameworks like Tailwind for layout and alignment.

Key Lessons for Developers

CSS Fundamentals Are Crucial: Despite the convenience of modern frameworks, understanding the basics of CSS (e.g., specificity, box model, positioning) remains essential.
Combine Tools Effectively: Use Tailwind for layouts and responsiveness, and rely on UI libraries for complex, pre-designed components, saving time on repetitive tasks.
Debugging Is an Art: Always check for overlapping class names and prioritize understanding your tools.
Efficiency Matters: Customize Tailwind's config file and leverage UI library themes to speed up your workflow.

Its okay to feel lost when starting with CSS or switching to a new library. The key is to keep experimenting, asking questions, and learning from mistakes. Over time, youll find your rhythm and develop a style that works for you.

Conclusion: Embracing the Learning Curve

Balancing CSS and UI libraries is both an art and a science. My journeyfrom struggling with CSS basics to mastering Tailwind and Material-UIhas taught me the importance of adaptability and continuous learning. By combining the strengths of these tools, you can create efficient, responsive, and visually appealing web interfaces without losing your sanity.

To all the developers out there: its perfectly normal to feel dumb when things dont work as expected. Youll question everything, get stuck, and then find a solution that makes everything click. This process might be slow, but its worth the patience and persistence. One day, youll look back and realize youve created beautiful wonders of UI. Keep goingthe journey is as rewarding as the destination.

Happy DevLogging! <3

~s.b.m.

WomenWhoTech#SerialBlogger#CSS#Frameworks#TailwindCSS#UI#Libraries#MaterialUI#MUI#CoreUI#Bootstrap#2Articles1Week#Hashnode#Tech#Enthusiast

]]>

Navigating Databases: From SQL to NoSQL

Samana Mirza — Wed, 11 Dec 2024 04:30:39 +0000

Hey Folks!

In the world of development, understanding which database system to use for a project can make a huge difference in performance, scalability, and flexibility. As a developer whos worked extensively with both SQL Server and MongoDB , Ive experienced firsthand how the right choice can vary depending on the project requirements.

This article will take you on a journey through my experience with both database sstarting with the basics of SQL queries and optimization, followed by an introduction to MongoDB's schema-less flexibility. I'll highlight the strengths of each, help you understand when to use which, and share the lessons I've learned along the way. Whether you're new to databases or a seasoned developer, this article will provide useful insights to make better choices in your future projects.

1. Road to SQL Server: From Basics to Advanced Queries

Getting Started: Select, Insert, and Conditional Queries

When I first started working with SQL Server, I had the misconception that SQL queries were mostly about creating complex conditions. I remember my first encounters with SELECT, INSERT, and WHERE conditions thinking that conditional queries were the hardest part. To be honest, I found them enjoyable, perhaps because they were straightforward and familiar. But, little did I know, that was just the tip of the iceberg.

The Pivot Point: Dynamic Tables and Complex Queries

My real learning began when I had to use pivot queries and generate dynamic tables. This is when SQLs true complexity hit me. Without a line-by-line debugger, I was often stuck on syntax errors and struggled to find solutions. I spent countless hours researching, trying and retrying until I finally got it right. It was during this time I understood how SQLs power could really shine when dealing with large, complex datasets. Now, adding conditions, modifying queries, and fine-tuning results has become second nature.

From Debugging Nightmares to Mastering Stored Procedures

Another significant moment was realizing the value of stored procedures. Initially, I used to write long and complex queries directly in APIs, which required me to keep updating the code every time I needed to tweak a query. Then, I discovered stored procedures a real game-changer. Now, I can simply modify the procedure without needing to redeploy or rewrite the entire code. This made my workflow significantly more efficient.

One of the most humbling yet funny experiences in my SQL journey was an interview where I failed to answer a simple question: "How do you fetch the top 1000 entries from a database?" Today, however, the SELECT TOP 1000 query is something I use almost daily.

While I've a good hold on Common Table Expressions (CTEs), CASE statements, and nested queries , I know there's still more to learn like working with views and triggers and handling SQL injections which are crucial for advanced SQL management.

2. Switching from SQL Server to MongoDB

The Struggles of Transitioning to NoSQL

After spending so much time with SQL Server, switching to MongoDB felt like a whole new world. The biggest challenge was adapting to the NoSQL mindset, working with collections instead of tables, handling unstructured data , and understanding how data could be inserted and updated without running SQL queries. At first, I felt lost and overwhelmed, especially when it came to importing and inserting data.

However, as I began to get more comfortable, I started appreciating MongoDB's flexibility. Unlike SQL, you don't need to define a rigid schema upfront. You can insert documents of varying structures into a collection, which provides great flexibility especially when dealing with dynamic, changing data.

MongoDB's Flexibility: Nesting Data and Collections

One of MongoDB's main advantages is how easily it allows nesting of data. It was liberating to insert and retrieve complex data structures without worrying about foreign keys and joins. However, this flexibility also led to confusion when trying to model more complex relationships. Unlike SQL, where you can normalize data with foreign keys, MongoDB encourages denormalization , meaning you sometimes need to embed entire documents within others.

Aggregation and Pipelines: Cracking the Tough Nut

I was initially confused by MongoDB's aggregation framework. While simple queries were easy to handle, performing complex filtering, grouping, and transformations using pipelines took some time to grasp. But after much research, trial and error, I started to feel more confident in using aggregation to perform complex operations. Despite my progress, I still have a lot to learn especially with advanced aggregation features and pipeline optimization.

3. SQL Server vs MongoDB: When to Use What

Now that I've worked with both SQL and MongoDB, I can confidently say that both have their own strengths and use cases. Here's a breakdown to help you decide when to use which:

Use SQL Server when:

You need to handle structured data with well-defined relationships.
Your data requires complex queries, such as joins, aggregations, and subqueries.
You are building transactional systems where ACID compliance is crucial.

Use MongoDB when:

Your data is unstructured or semi-structured and you don’t need a rigid schema.
You require scalability and need to store large amounts of data across multiple servers.
You want flexibility in handling data with evolving or nested structures.

4. Final Thoughts: Embracing Both for Better Projects

After working with both SQL Server and MongoDB, I've learned that the choice isn't about what's easier or what I prefer, it's about what the project requires. Each database excels in different areas:

SQL Server is powerful for relational data with complex relationships.
MongoDB shines in handling large-scale, unstructured data with flexibility.

There's no one-size-fits-all solution, and as developers, we must choose the right tool for the job. My advice to you is to learn both mastering SQL will provide you with a strong foundation in data management, while MongoDB's flexibility will allow you to build scalable, modern applications.

As I continue my journey, I know there's still more to explore in both worlds. But understanding the strengths of each database has helped me become a more adaptable developer. And I hope this article helps you make informed choices when working on your own projects.

Happy DevLogging! <3

~s.b.m.

WomenWhoTech#SerialBlogger#SQL#NoSQL#Journey#SQLServer#MongoDB#2Articles1Week#Hashnode#Tech#Enthusiast

]]>

Into the React Web: From Chaos to Confidence

Samana Mirza — Tue, 10 Dec 2024 09:48:44 +0000

Greetings, fellow developers and enthusiasts!

I know I'm late to the developer blogosphere party, but hey, better late than never, right? After almost a year of professional experience in the tech world, I finally decided to pen down my thoughts, challenges, and learnings. So, here I am, ready to share my journey in the ever-evolving world of development.

The Chaotic Start

When I Didn't Know What I Didn't Know

Let me take you back to the beginning where all the confusion started.

Like many budding developers, I procrastinated about starting projects and learning. The sheer number of tools and frameworks left me overwhelmed: Should I start with C++ ? Java ? Or maybe JavaScript ? Even after I picked React, uncertainty loomed.

I was underconfident and unsure about how anything worked. useEffect ? Sounds cool, but do I even need it here? Debugging felt like a superpower I didn't possess. My approach was simple yet disastrous:

Google everything.
Copy-paste from ChatGPT (Once, I even pleaded please solve this; I cant do it myself 🤦- very dumb, right?).
Call seniors at the slightest hint of an error instead of debugging or understanding the issue.

If you've been there, you know the pain. If you haven't, consider yourself lucky. But looking back, that chaotic phase was vital, it forced me to confront what I didn't know.

The Turning Point: From Chaos to Curiosity

When Everything Started Clicking

Something shifted. Maybe it was hitting one error too many times or realizing my reliance on external help was slowing me down. I started learning instead of just doing:

React Hooks became less of a mystery. I figured out when to use useEffect and when to let it sit this one out. Finally understanding the difference between useCallback and useMemo.
I learned to modularize components instead of creating massive, unmanageable files.
Debugging became my second nature thanks to the console (and yes, some persistence).

The first aha! moment came when I solved a bug without copying a single line from ChatGPT. It wasn't perfect, but it was mine.

I also began to see patterns:

Single Responsibility Principle (SRP) simplified my logic and code.
Thinking in modular, reusable components made my projects more manageable.

Every small success added confidence, and I realized that understanding the why behind the what is the true key to progress.

From React to Querying New Horizons

How Am I React-ing To Code Now'

Today, I feel a sense of control over my development journey. React, which once felt intimidating, is now my comfort zone. My foundation in hooks, SRP, and modularization has grown strong, and I've started exploring React Query to make state management a breeze.

But the journey isn't over, its just evolving:

I'm now delving into optimizations and exploring how to improve app performance.
Experimenting with design systems to improve user interfaces.
Understanding context beyond React, be it Node.js, MongoDB, Tailwind or new tools on the horizon.

Final Thoughts

Its Not The End

To anyone who feels overwhelmed, uncertain, or just plain stuck: Its okay. We all start somewhere, and no one is born a developer. Mistakes, Googling, and asking for help (as small as How to start VS Code?) are part of the process.

The key is to stay curious, consistent, and open to learning. Embrace your failures, they're just stepping stones to success.

If my journey resonates with you or if you've been on a similar path, Id love to hear your story. Lets grow together, one line of code at a time.

What Next?

A Little About Me

Currently, I am an aspiring full stack developer and my tech stack includes React.js, MongoDB, Node.js, SQL Server, Express, Java, Tailwind and ArcGIS, but I also have a passion for designing with tools like Canva and Figma. I love exploring new technologies and concepts and have a lot of stories to tell about deployment , documentation , and designing all of which I plan to share in future articles. Stay tuned for more insights, tips, and personal experiences as I continue my developer journey.

Happy DevLogging! <3

~s.b.m.

WomenWhoTech#React#Development#Journey#Reactjs#Developer#tech#enthusiast

]]>