DEV Community: Victor J. Rosario V.

Production Is Not a Joke: A Lesson I Learned the Hard Way

Victor J. Rosario V. — Sun, 18 Jan 2026 22:42:30 +0000

Hi there, it’s me again.

Today, I want to share a great (and painful) experience I had while deploying a product to production.

My team and I were working on a very simple product. Its only responsibility was to register users — nothing complex, no heavy business logic. Simple, right?

Well… not exactly.

The DevOps team never explained how the infrastructure worked, so we built the product assuming things would “just work.”

Spoiler: they didn’t.

The first real deployment session lasted 6 hours.

Six fantastic hours staring at a simple “Hello World”, just to verify that the backend and frontend were running.

At that point, my patience and aura were gone.

I have 4+ years of experience in this industry, and honestly, it was the first time I had seen something like this.

The Production Conversation

There’s a moment I’ll never forget — right in the middle of deploying the backend to production:

DevOps team: The backend can’t start because it can’t read the database. Please create a script to create the database.
Me: What do you mean? Are you saying we need to create a script to create the database if it doesn’t exist?
DevOps team: Yes.
Me: … OK.

Why did I say “OK”?

Because I remembered some advice I once received:

“To fight, you need two people.”
“We didn’t research enough how the infrastructure works.”
“Senior, look at me. Don’t stress. I’m 30 years old, and I already look like I’m 50.”

Conclusion

This experience taught me something very important:

Never assume — always ask how the infrastructure works.
To fight, you need two — and sometimes it’s better not to fight at all.
I’m only 26 years old, and I don’t want to become a meme of a stressed senior developer.

Sometimes, the best solution is patience, communication, and learning the hard way.

Thanks for reading my powerful story 😉

Why Learning C Is My First Step Toward Becoming a Game Engine Programmer

Victor J. Rosario V. — Thu, 01 Jan 2026 00:15:33 +0000

Hi there! Happy new year 🥳🎉🎊

My name is Victor Rosario. I’m originally a Web Developer, and I usually work with technologies like Next.js, FastAPI, Express.js, and Nest.js.

Recently, while browsing YouTube, I discovered a channel called The Cherno. I started watching his Game Engine (Hazel) playlist, and that’s when everything changed. I felt a huge wave of excitement — finally seeing how game engines like Unity, Unreal, or Godot work under the hood.

At the same time, I was completely lost.

I was looking at real engine code, and honestly… I couldn’t understand anything. That confusion made me realize something important: I was missing the fundamentals.

After doing a lot of research and talking with friends who work closer to low-level systems, I reached a clear conclusion:

My first real step must be learning the C language.

My reasoning is simple: if I deeply understand C, then learning C++ — with all its extra features — will become much easier and more natural.

To reinforce this path, I started reading the book “Build Your Own Lisp”, which I honestly think is fantastic. It doesn’t just teach syntax; it forces you to think about memory, data structures, and low-level concepts.

At the moment of writing this post, I’m on Chapter 9: “Reading Expressions”, and this blog series is my way of documenting this learning adventure.

Conclusion

Right now, my main goal is to strengthen my C knowledge by building small projects that help me truly understand:

How memory works
How to allocate and deallocate memory
How to properly use and master pointers

This is just the beginning, but it feels like the right foundation for my long-term goal: becoming a Game Engine Programmer.

Thanks for reading 😁

🔍 Say Goodbye to Slow Renders: Optimizing React Apps with `react-scan`

Victor J. Rosario V. — Mon, 02 Dec 2024 17:22:39 +0000

Performance optimization is a critical aspect of building robust React applications, especially those with complex components or dynamic data flows. react-scan is a powerful tool that helps developers diagnose and fixes rendering inefficiencies, making your app faster and more efficient.

In this blog, we’ll explore how to install and configure react-scan, leverage its APIs, and apply practical optimization techniques for your React components.

What is `react-scan`?

react-scan is a diagnostic tool for React apps, designed to analyze performance issues and identify unnecessary renders. It logs detailed information about component render cycles and generates reports to help you address bottlenecks efficiently.

Installation and Setup

Depending on your workflow, you can integrate react-scan in several ways, ranging from CLI usage for quick analysis to embedding scripts directly in your codebase.

I. Quick Start with CLI
The easiest way to start using react-scan is through its CLI. This opens an isolated browser instance for analyzing any React app.

Scan your local app:

npx react-scan@latest http://localhost:3000

Analyze any React-based website:

npx react-scan@latest https://react.dev

This method is ideal for quick diagnostics without modifying your source code.

II. Integrating into Your Development Workflow
You can incorporate react-scan into your development process by running it alongside your local development server. For example, in a Next.js project:

A. Update the scripts section in your package.json:

{
  "scripts": {
    "dev": "next dev",
    "scan": "next dev & npx react-scan@latest http://localhost:3000"
  }
}

B. Start your development environment with:

npm run scan

This will launch both the development server and react-scan for real-time analysis.

III. Embedding the Script in Your App
If you want a more integrated experience, you can embed the react-scan script directly in your project.

For Next.js (pages mode):

Add the script to your pages/_document.tsx:

import { Html, Head, Main, NextScript } from 'next/document';

export default function Document() {
  return (
    <Html lang="en">
      <Head>
        <script src="https://unpkg.com/react-scan/dist/auto.global.js"></script>
      </Head>
      <body>
        <Main />
        <NextScript />
      </body>
    </Html>
  );
}

For Next.js (app mode):

Embed the script in your app/layout.tsx:

export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    <html lang="en">
      <head>
        <script src="https://unpkg.com/react-scan/dist/auto.global.js" async />
      </head>
      <body>{children}</body>
    </html>
  );
}

For Vite or Create React App:

Add the script in your index.html:

<!doctype html>
<html lang="en">
  <head>
    <script src="https://unpkg.com/react-scan/dist/auto.global.js"></script>
  </head>
  <body>
    <div id="root"></div>
  </body>
</html>

Key APIs of `react-scan`

react-scan provides versatile APIs for diagnosing and improving component performance:

`scan(options)`: An imperative API to start scanning.
`useScan(options)`: A hook for targeted scanning in functional components.
`withScan(Component, options)`: A Higher-Order Component (HOC) to analyze specific components.
`getReport()`: Generates a detailed report of all renders.

Examples of Component Optimization

A. Prevent Unnecessary Renders with React.memo
Without optimization, a child component may re-render whenever its parent updates, even if the child’s props don’t change:

const Child = ({ data }) => {
  console.log('Child render');
  return <div>{data}</div>;
};

export default Child;

Using React.memo, you can prevent redundant renders:

import React from 'react';

const Child = React.memo(({ data }) => {
  console.log('Child render');
  return <div>{data}</div>;
});

export default Child;

B. Use useScan for Targeted Analysis
Analyze specific components with the useScan hook:

import React from 'react';
import { useScan } from 'react-scan';

const HeavyComponent = ({ count }) => {
  useScan({ log: true }); // Enables scanning for this component
  console.log('HeavyComponent render');

  return <div>Count: {count}</div>;
};

export default HeavyComponent;

III. Generate Detailed Reports with getReport
Generate a comprehensive performance report for all components:

import { getReport } from 'react-scan';

const generateReport = () => {
  const report = getReport();
  console.log('Performance Report:', report);
};

Best Practices for Optimization

Break Down Large Components: Smaller, focused components are easier to optimize.
Leverage React.memo and React.useMemo: Avoid recomputation and re-rendering when dependencies haven’t changed.
Avoid Inline Functions: Use React.useCallback to ensure stable function references.
Virtualize Long Lists: Use libraries like react-window for handling large data sets efficiently.

Conclusion

react-scan is an indispensable tool for React developers aiming to enhance application performance. Whether you use the CLI for quick insights or integrate it into your codebase for ongoing analysis, react-scan helps identify and fix bottlenecks effectively.

Start using react-scan today and take your React app performance to the next level. 🚀

GitHub project: Project Link

Battle of the Node.js ORMs: Sequelize vs. Prisma

Victor J. Rosario V. — Wed, 28 Feb 2024 03:59:34 +0000

In the ever-evolving landscape of Node.js development, choosing the right Object-Relational Mapper (ORM) can significantly impact your project's efficiency and maintainability. Two prominent contenders in this arena are Sequelize and Prisma, each offering distinct advantages and catering to different development preferences.

Sequelize: The Established Veteran

Developers looking for a dependable and well-documented ORM frequently choose Sequelize because of its extensive community and established reputation. With its broad API, you may connect with your data in a variety of relational databases, such as PostgreSQL, MariaDB, Oracle DB, MySQL, SQL Server, and SQLite.

Here are some of Sequelize's key strengths:

Mature and stable: With years of active development and a vast user base, Sequelize offers proven reliability for your projects.
Versatile database support: It caters to a wide range of relational databases, giving you flexibility in your database choice.
Comprehensive features: Sequelize offers a rich set of features, including migrations, associations, and query builders, to streamline your development workflow.
Active community: The large and active community provides extensive documentation, tutorials, and support resources.

However, Sequelize also has some potential drawbacks:

Steeper learning curve: Compared to Prisma, Sequelize's API can be more complex for beginners to grasp.
Potential for boilerplate code: The flexibility of Sequelize can sometimes lead to writing more code compared to Prisma's declarative approach.

Languages:

TypeScript: Sequelize offers full type support through its official TypeScript definitions. This allows for type-safe interactions with your database models and queries, enhancing code maintainability and catching errors early on.
JavaScript: Sequelize also works well with vanilla JavaScript. However, you won't benefit from the type safety features available in TypeScript.

Prisma: The New Challenger

Although Prisma is a more recent entrant into the ORM market, its innovative approach and focus on developer experience have helped it gain notoriety. It uses a declarative schema language to build your data models and offers a type-safe, intuitive interface for interacting with your database, you may connect with your data in a variety of relational databases, such as PostgreSQL, MySQL, SQL Server, SQLite, CockroachDB and PlanetScale.

Here are some of Prisma's key benefits:

Simplified development: The declarative schema language reduces boilerplate code and improves code readability.
Strong type safety: Prisma leverages TypeScript for type-safe interactions with your database, enhancing code maintainability and catching errors early.
Integrated tooling: Prisma comes with a comprehensive CLI that provides tools for generating migrations, schema validation, and data introspection.
Focus on performance: Prisma is built with performance optimizations in mind, offering efficient query execution.

However, it's important to consider some potential limitations of Prisma:

Limited database support: Currently, Prisma only supports PostgreSQL and MySQL natively, though community connectors exist for other databases.
Relative immaturity: As a newer technology, Prisma might have a smaller community and fewer resources compared to Sequelize.

Languages:

TypeScript: Prisma is built with TypeScript in mind and provides seamless integration. The Prisma schema uses TypeScript for defining your data models, ensuring type-safe interactions throughout the development process.
JavaScript: While Prisma primarily focuses on TypeScript, it can also be used with JavaScript. However, you'll miss out on its core strength, which is type safety.

Choosing the Right Champion for Your Project

So, which ORM reigns supreme? The answer depends on your specific needs and preferences. Here's a quick guide to help you decide:

Choose Sequelize if:
- You need an established and well-documented solution.
- You require support for a wider range of databases.
- You are comfortable with a more flexible and customizable API.
Choose Prisma if:
- You prioritize simplicity and developer experience.
- You value strong type safety and code maintainability.
- You are building applications with PostgreSQL or MySQL.

Ultimately, the best approach is to experiment with both ORMs on a small project to get a feel for their strengths and weaknesses before making a decision for your larger projects.

By understanding the unique capabilities of Sequelize and Prisma, you can equip yourself to choose the ideal champion to streamline your Node.js development experience.

Example Code

Sequelize (using PostgreSQL):

const Sequelize = require('sequelize');

const sequelize = new Sequelize('your_database_name', 'your_username', 'your_password', {
  host: 'your_host',
  dialect: 'postgres',
});

async function connectAndQuery() {
  try {
    await sequelize.authenticate();
    console.log('Connection established successfully.');

    const result = await sequelize.query('SELECT * FROM users LIMIT 1');
    console.log('First user:', result[1][0]);
  } catch (error) {
    console.error('Error:', error);
  } finally {
    await sequelize.close();
  }
}

Prisma (using PostgreSQL):

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

model Patient {
  id      Int      @id @default(autoincrement())
  name    String
  dob     DateTime
  // ... other patient related fields
}

model Appointment {
  id          Int      @id @default(autoincrement())
  patient     Patient  @relation(fields: [patientId], references: [id])
  patientId   Int
  doctor      Doctor   @relation(fields: [doctorId], references: [id])
  doctorId    Int
  dateTime    DateTime
  // ... other appointment related fields
}

model Doctor {
  id      Int      @id @default(autoincrement())
  name    String
  // ... other doctor related fields
}

// prisma/client.js (generated by Prisma CLI)
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

async function getConsultationData(patientId: number): Promise<any> {
  try {
    const consultation = await prisma.appointment.findUnique({
      where: { patientId },
      include: {
        patient: true,
        doctor: true,
      },
    });

    if (consultation) {
      const patientData = {
        name: consultation.patient.name,
        dob: consultation.patient.dob,
      };
      const doctorData = {
        name: consultation.doctor.name,
      };
      const appointmentData = {
        dateTime: consultation.dateTime,
      };

      // Further process or combine data as needed for the consultation

      return { patientData, doctorData, appointmentData };
    } else {
      console.log(`No consultation found for patient with ID: ${patientId}`);
      return null;
    }
  } catch (error) {
    console.error("Error fetching consultation data:", error);
    return null;
  }
}

// Usage example
(async () => {
  const consultationData = await getConsultationData(123); // Replace with actual patient ID

  if (consultationData) {
    console.log("Patient:", consultationData.patientData);
    console.log("Doctor:", consultationData.doctorData);
    console.log("Appointment:", consultationData.appointmentData);
  }
})();

The Best ORMs for Node.js App Development in 2023

Victor J. Rosario V. — Wed, 01 Nov 2023 20:44:10 +0000

What is an ORM?

Object-relational mapping (ORMs) are a type of software that provides a layer of abstraction between a programming language and a database. ORMs allow developers to interact with databases using object-oriented concepts, such as classes and objects, rather than having to write SQL statements.

ORMs can be especially beneficial for Node.js projects, as they can simplify database access and make it easier to write maintainable code. There are a number of different ORMs available for Node.js.

Importance of ORMs

ORMs bridge the gap between the object-oriented programming world and relational databases, making it easier for developers to interact with databases using JavaScript. Here are five key benefits of using ORMs in Node.js app development:

Abstraction of Database Operations: ORMs provide a higher-level abstraction, allowing developers to work with JavaScript objects and classes rather than writing complex SQL queries. This abstraction simplifies database operations, making code more readable and maintainable.
Database Agnosticism: ORMs are often database-agnostic, which supports multiple database systems. This flexibility allows developers to switch between databases (e.g., MySQL, PostgreSQL, SQLite) without major code changes, making it easier to adapt to evolving project requirements.
Code Reusability: ORMs encourage code reusability by providing a consistent API for database interactions. Developers can create generic database access codes that can be reused across different application parts, reducing duplication and minimizing the chances of errors.
Security: ORMs help mitigate common security vulnerabilities, such as SQL injection attacks, by automatically sanitizing and parameterizing SQL queries. This helps in building more secure applications by default.
Rapid Development: ORMs accelerate development by simplifying database setup and management. Developers can focus on application logic rather than excessive time on database-related tasks. This results in faster development cycles and quicker time-to-market for Node.js applications, making ORMs a valuable asset in the modern development landscape.

Sequelize

Sequelize is a widely adopted Object-Relational Mapping (ORM) tool for Node.js. This ORM provides support for several relational databases, including MySQL, PostgreSQL, SQLite, and MSSQL. Sequelize is known for its extensive feature set, making it a popular choice for database modeling and querying in Node.js projects. It offers flexibility in coding styles by accommodating both Promise and Callback-based APIs, allowing developers to work with their preferred approach. In addition, Sequelize includes advanced functionalities such as transactions, migrations, and associations, making it exceptionally suitable for handling complex database operations with ease.

Pros:

Flexible and easy to use
Support for complex data models and relationships
Automatic data validation
Migration support
A powerful query builder
Large and active community

Cons:

Can be slow for complex queries
Some features can be difficult to learn
Low support with Typescript

TypeORM

TypeORM is another prominent ORM for Node.js, and it stands out for its strong support for both TypeScript and JavaScript. This ORM is versatile, with compatibility across various database systems like MySQL, PostgreSQL, MariaDB, SQLite, and Oracle. TypeORM simplifies entity management, facilitates database schema changes through migrations, and promotes the use of the repository pattern. Developers can easily get started with TypeORM in their Node.js applications, making it a reliable choice for those who prefer strong typing and the benefits of TypeScript.

Pros:

Good support for TypeScript
Automatic type generation
Integrated code completion and error checking in IDEs
Supports a variety of databases, including PostgreSQL, MySQL, and SQLite
Provides a comprehensive query builder
Offers features such as migrations, data validation, and eager loading

Cons:

Can be more complex to set up and configure than some other ORMs
Not as well-established as some other ORMs, such as Sequelize
Can be slower than some other ORMs, such as Objection.js

Prisma

Prisma is a modern and popular Object-Relational Mapping (ORM) tool designed for Node.js and other programming languages. What sets Prisma apart is its support for various databases, including PostgreSQL, MySQL, SQLite, and SQL Server. Prisma offers a unique approach to database interactions through its ability to generate type-safe query builders based on your database schema. This feature leverages TypeScript to provide autocompletion, strong typing, and improved developer experience when writing database queries.

Pros:

Clean and type-safe API
Real-time data synchronization
Support for multiple databases
Automatic query generation
Support for GraphQL
Well-documented and easy to use
Actively maintained and updated
Open source and free to use, even for commercial projects

Cons:

Relatively new and less mature than some other ORMs
Can be difficult to debug
Can be slower than some other ORMs for complex queries
Only supports JavaScript and TypeScript

Objection.js

Objection.js is an ORM built on top of the Knex.js query builder, offering a unique approach to database interactions in Node.js applications. It primarily supports SQL-based databases like PostgreSQL, MySQL, and SQLite. What sets Objection.js apart is its fluent query builder and flexible schema design, allowing developers to write expressive and powerful database queries with ease. Integrating Objection.js into your Node.js project provides you with a powerful tool for managing and interacting with relational databases in a highly customizable way.

Prop:

Lightweight and performant
Simple and easy to learn
Supports complex data models and relationships
Supports automatic data validation
Supports migration support
Supports a powerful query builder
Supports both Active Record and Data Mapper patterns
Supports storing complex documents as single rows
Completely Promise based API
Easy to use transactions
Optional JSON schema validation

Cons:

Less well-established than some other ORMs, such as Sequelize and TypeORM
Community support is not as large as some other ORMs
Only supports JavaScript

Bookshelf.js

Bookshelf.js is a lightweight ORM for Node.js, built on top of the Knex.js query builder. It primarily supports SQL databases like MySQL, PostgreSQL, and SQLite. Bookshelf.js focuses on simplicity and efficiency, providing features like model relationships and eager loading. Developers who prefer a straightforward and minimalistic ORM for their Node.js applications will find Bookshelf.js to be a valuable tool for managing database interactions and relationships effectively.

These explanations provide insights into the key features, database support, and unique characteristics of each ORM, helping readers understand their strengths and use cases in Node.js projects.

Pros:

Lightweight and performant
Simple and easy to learn
Supports nested models
Supports eager loading
Supports custom query builders
Supports both Active Record and Data Mapper patterns
Completely Promise based API
Easy to use transactions
Optional JSON schema validation

Cons:

Less well-established than some other ORMs, such as Sequelize and TypeORM
Community support is not as large as some other ORMs
Only supports JavaScript

Choosing the right ORM for your Node.js project

When choosing an ORM for your Node.js project, there are a number of factors to consider, such as:

The types of databases you need to support
The features you need, such as support for complex data models, relationships, migrations, and data validation
The performance requirements of your project
Your team's experience with different ORMs

It is also important to note that some ORMs are better suited for certain types of projects than others. For example, Prisma is a good choice for modern Node.js projects that need to support multiple databases and real-time data synchronization. Objection.js and Bookshelf.js are good choices for lightweight Node.js projects that need a simple and performant ORM.

Conclusion

ORMs can be a valuable tool for Node.js developers, as they can simplify database access and make it easier to write maintainable code. However, it is important to choose the right ORM for your project based on your specific needs.

From Good to Great: Scaling Applications with TypeORM Optimization

Victor J. Rosario V. — Mon, 16 Oct 2023 13:29:58 +0000

TypeORM is a popular Object-Relational Mapping (ORM) library for Node.js. It provides a high-level abstraction over relational databases, making it easy to perform CRUD (Create, Read, Update, Delete) operations.

However, like any ORM, TypeORM can be used in ways that can lead to performance problems. In this blog post, we will discuss some tips on how to improve TypeORM operations.

1. Use a connection pool

A connection pool is a group of database connections that can be reused. This can improve performance by reducing the overhead of opening and closing database connections.

To use a connection pool in TypeORM, simply set the connection option in your TypeORM configuration to a DataSource instance.

import { DataSource } from "typeorm"

const connectionPool = new DataSource({
  type: 'mysql',
  host: 'localhost',
  port: 3306,
  username: 'root',
  password: '',
  database: 'test',
});

const typeormConfig = {
  connection: connectionPool,
};

2. Use lazy loading

Lazy loading is a technique that delays the loading of database entities until they are actually needed. This can improve performance by reducing the amount of data that needs to be transferred between the database and your application.

To enable lazy loading in TypeORM, simply set the lazy property to true on your entity definitions.

import {
    Entity,
    BaseEntity,
    PrimaryGeneratedColumn,
    Column,
    OneToMany,
    ManyToOne
} from "typeorm"

@Entity()
export class PostEntity extends BaseEntity {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  title: string;

  @Column()
  comment: string;

  @Column()
  userId: number;

  // Lazy load the post's user
  @ManyToOne(() => UserEntity, user => user.posts)
  user: UserEntity[];
}

@Entity()
export class UserEntity extends BaseEntity {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column()
  email: string;

  // Lazy load the user's posts
  @OneToMany(() => PostEntity, post => post.user)
  posts: PostEntity[];
}


// ❌ Bad Query
const users = await UserEntity.find();

Promise.all(users.map( async (user) => {
    const posts = await PostEntity.find({
        where: { userId: user.id }
    });
    return posts
}));

// ✅ Good Query
const users = await UserEntity.find({
    relations: {
        posts: true
    }
}).catch(() => []);

3. Use caching

Caching can also improve performance by storing frequently accessed data in memory. TypeORM provides built-in support for caching, so you can easily enable it in your application.

To enable caching in TypeORM, simply set the cache option in your TypeORM configuration to a Cache instance.

// Cache global
const connection = new DataSource({
  type: 'mysql',
  host: 'localhost',
  port: 3306,
  username: 'root',
  password: '',
  database: 'test',
  cache: true
});

// One query
const user = await UserEntity.findOne({
    where: { id: 1 },
    cache: 10000
}).catch(() => null)

4. Use transactions

Transactions are a way to ensure that multiple database operations are performed as a single unit. This can help to prevent data corruption and improve the reliability of your application.

To use transactions in TypeORM, simply wrap your database operations in a transaction() call.

const connection = new DataSource()

await connection.manager.transaction( async (manager) => {

    // lets now open a new transaction:
    await manager.startTransaction()

    try {
         // execute some operations on this transaction:
        await manager.save(user);
        await manager.save(userInfo);

        // commit transaction now:
        await manager.commitTransaction()
    } catch (error) {
        // since we have errors let's rollback changes we made
        await manager.rollbackTransaction()
    } finally {
        // you need to release query runner which is manually created:
        await manager.release()
    }
});

5. Optimize your queries

TypeORM provides a number of features that can help you to optimize your queries, such as the ability to use named parameters and subqueries.

You can also use a query profiler to identify performance bottlenecks in your queries.

Database Profiling and Monitoring Tools:

Database Profiling and Monitoring Tools:
- pgAdmin (for PostgreSQL): pgAdmin provides a query tool that allows you to execute and analyze SQL queries. You can view query execution plans, see query statistics, and track slow queries.
- MySQL Workbench (for MySQL): MySQL Workbench has query execution profiling features that can help you analyze query performance.
- SQL Server Management Studio (for SQL Server): SSMS offers query execution plans and query statistics features for performance analysis.
ORM-Specific Query Logging:
- TypeORM and other ORMs often allow you to enable query logging. This can be a valuable source of information about executed queries, especially when combined with other monitoring tools.
Visual Query Builders:
- Tools like TablePlus, DBeaver, or HeidiSQL provide visual query building interfaces. While not performance analysis tools per se, they can help you build and understand complex queries more easily.
Third-party Profiling Tools:
- Tools like "pg_stat_statements" for PostgreSQL can be used to log and analyze query performance. It's not a visual tool, but it can provide insights into query efficiency.
Database Monitoring Platforms:
- Tools like Datadog, New Relic, and AppDynamics provide visual dashboards for monitoring database performance and identifying bottlenecks.
Query Visualizers:
- Tools like EverSQL Query Optimizer can take an SQL query and provide visual representations of query execution plans, suggesting optimizations.
Custom Dashboard Solutions:
- You can build custom dashboards using Grafana, Kibana, or other visualization tools, integrating database performance metrics and logs for a holistic view of your application's performance

6. Monitor your application

It is important to monitor the performance and health of your TypeORM application. This can help you to identify and troubleshoot problems before they cause outages.

There are a number of TypeORM monitoring tools available that can help you to do this.

By following these tips, you can improve the performance and scalability of your TypeORM application.

Exploring the Contrast: Helpers and Utils Demystified

Victor J. Rosario V. — Wed, 11 Oct 2023 14:24:39 +0000

Helpers and utils are both commonly used terms in software development to refer to classes or modules that provide common functionality. However, there is a subtle difference between the two.

Helpers are typically specific to a particular project or layer of an application. They provide functionality that is needed by other classes or modules in the same project, but is not general-purpose enough to be reused in other projects. For example, a helper class might provide methods for mapping between database entities and DTOs, or for validating user input.

Utils, on the other hand, are general-purpose classes or modules that can be reused in multiple projects. They provide functionality that is common to many different types of applications, such as string manipulation, date and time formatting, or mathematical operations. For example, a utils module might provide functions for converting strings to different encodings, parsing dates and times, or calculating the square root of a number.

Characteristic	Helper	Util
Scope	Project- or layer-specific	General-purpose
Reusability	Not typically reused in other projects	Can be reused in multiple projects
Examples	Mapping database entities to DTOs, validating user input	String manipulation, date and time formatting, mathematical operations

In general, it is best to use utils whenever possible, as this can help to reduce code duplication and make your code more reusable. However, there are some cases where it is necessary to create a helper class, such as when you need to provide functionality that is specific to your project or layer of an application.

Example code for helpers and utils in TypeScript:

Helper:

export function validatePassword(password: string): boolean {
  if (password.length < 8) {
    throw new Error("Password must be at least 8 characters long");
  }
  if (!/[A-Za-z]/.test(password) || !/[0-9]/.test(password)) {
    throw new Error("Password must contain at least one letter and one number");
  }
  return true;
}

This helper class provides a method for validating user passwords. It can be used in other classes or modules in the same project to ensure that all user passwords are strong and secure.

Util:

import { format } from "date-fns";

export function formatDateTime(datetimeObj: Date, formatStr = "yyyy-MM-dd HH:mm:ss"): string {
  return format(datetimeObj, formatStr);
}

This util function formats a date time object into a string using the date-fns library. It can be used in any class or module in the project to format date time objects consistently.

Tips for writing good helpers and utils
Here are some tips for writing good helpers and utils:

Make them clear and concise. The code in your helpers and utils should be easy to read and understand. Avoid using complex logic or unnecessary abstractions.
Document them well. Include clear and concise documentation for all of the methods and functions in your helpers and utils. This will help other developers to understand how to use them.
Test them thoroughly. Make sure to write unit tests for all of the methods and functions in your helpers and utils. This will help to ensure that they work correctly.
Keep them up to date. As your project evolves, make sure to update your helpers and utils as needed. This will help to ensure that they continue to work correctly and meet the needs of your project.

Unlocking Node.js Performance: The Art of Data Caching

Victor J. Rosario V. — Mon, 09 Oct 2023 12:21:02 +0000

Introduction

Caching is a technique that stores data in memory so that it can be accessed quickly and easily. This can improve the performance of your Node.js application by reducing the number of times that you need to fetch data from a database or other external source.

There are many different caching libraries available for Node.js, but it is also possible to implement caching without using any libraries. This can be useful if you want to have more control over your caching implementation or if you are using a very small Node.js application.

Implementing caching without libraries

To implement caching without libraries in Node.js, you can use a simple object to store the cached data. The key of the object should be the unique identifier for the data that you are caching, and the value of the object should be the cached data itself.

For example, the following code shows how to cache the results of a database query:

const cache: { posts: any[] } = {}

async function getPosts() {
  const posts = await database.query('SELECT * FROM posts');

  // Cache the results of the query
  cache.posts = posts;

  return posts;
}

// Get the posts from the cache if it is available
async function getPostsFromCache() {
  if (!cache.posts) {

    // Otherwise, fetch the posts from the database
    return await getPosts();

  }

  return cache.posts;
}

To use the cache, you can simply call the getPostsFromCache() function. This function will check if the posts are already cached, and if so, it will return the cached data. Otherwise, the function will fetch the posts from the database and cache them for future use.

More complex caching strategies

You can also implement more complex caching strategies, such as eviction policies and time-to-live (TTL). For example, you could implement an eviction policy that removes the least recently used data from the cache when it becomes full. Or, you could implement a TTL that expires cached data after a certain period of time.

Conclusion

Implementing caching without libraries can give you more control over your caching implementation, but it can also be more complex. If you are new to caching, it is recommended that you use a caching library. However, if you need more control over your caching implementation or if you are using a very small Node.js application, then implementing caching without libraries can be a good option.

Additional tips

When choosing which data to cache, consider factors such as how frequently the data is accessed and how expensive it is to fetch the data from the external source.
If you are caching data that is frequently updated, you may need to implement a cache invalidation strategy to ensure that the cached data is always up-to-date.
You can use monitoring tools to track how your caching implementation is performing and to identify any potential problems.

👟 Optimizing Your Node.js Project: Best Practices for Performance and Efficiency

Victor J. Rosario V. — Tue, 13 Jun 2023 14:04:12 +0000

Introduction

Welcome to our blog on optimizing Node.js projects! We'll explore best practices and techniques to maximize efficiency and performance. From code optimization to caching, error handling, load balancing, and more, we'll provide insights and practical examples to help you achieve optimal results. Let's optimize your Node.js project for peak performance!

Code Efficiency

Writing clean and efficient code is crucial for optimal performance. It involves avoiding unnecessary computations, using appropriate algorithms, and optimizing data structures. Optimize loops, minimize function calls, and reduce memory footprint. Additionally, consider using libraries or frameworks that provide optimized solutions for common tasks.

Example: Optimizing a loop to sum an array efficiently

function sumArray(arr) {
  let sum = 0;
  const length = arr.length;
  for (let i = 0; i < length; i++) {
    sum += arr[i];
  }
  return sum;
}

Asynchronous Programming

Leveraging the non-blocking I/O model of Node.js through asynchronous programming is essential for handling I/O operations and long-running tasks efficiently. Utilize callbacks, promises, or async/await to avoid blocking the event loop and enable the server to handle more concurrent requests.

Example: Using async/await for asynchronous operations


async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Error fetching data:', error);
    throw error;
  }
}

Caching

Implementing caching mechanisms can significantly improve response times and reduce the load on databases or external APIs. Utilize caching frameworks like Redis or Memcached to store frequently accessed data in memory and avoid repetitive database or computation operations.

Example: Caching data using Redis

const redis = require('redis');
const client = redis.createClient();

function getCachedData(key) {
  return new Promise((resolve, reject) => {
    client.get(key, (err, cachedData) => {
      if (err) {
        reject(err);
      }
      if (cachedData) {
        resolve(JSON.parse(cachedData));
      } else {
        resolve(null);
      }
    });
  });
}

function cacheData(key, data) {
  client.set(key, JSON.stringify(data));
}

Proper Error Handling

Implementing robust error handling mechanisms is crucial to handle exceptions and errors effectively. Use try-catch blocks, error middleware, or error-handling frameworks like Sentry or New Relic to gracefully handle errors and prevent crashes or performance degradation.

Example: Handling errors using try-catch blocks

app.get('/data', async (req, res) => {
  try {
    const data = await fetchData();
    res.json(data);
  } catch (error) {
    console.error('Error retrieving data:', error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});

Load Balancing and Scaling

Utilize load balancing techniques to distribute incoming requests across multiple Node.js instances, preventing a single instance from becoming a bottleneck. Consider scaling horizontally by adding more instances, or vertically by upgrading hardware resources.

Example: Load balancing using the cluster module

const cluster = require('cluster');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
} else {
  // Worker process logic
  const server = app.listen(3000, () => {
    console.log(`Worker ${cluster.worker.id} listening on port 3000`);
  });
}

Continuous Testing and Profiling

Implement a comprehensive testing strategy, including unit tests, integration tests, and performance tests. Utilize profiling tools like Node.js's built-in profiler or external tools like Clinic.js to identify performance hotspots and optimize critical sections of code.

Example: Unit testing with Jest

// test.js
const sum = require('./sum');

test('adds 1 + 2 to equal 3', () => {
  expect(sum(1, 2)).toBe(3);
});

Security Measures

Implement proper security measures to protect your Node.js application from vulnerabilities and attacks. Use secure coding practices, validate and sanitize user inputs, implement authentication and authorization mechanisms, and keep dependencies up to date to address known security issues.

Example: Implementing input validation and sanitization using a library like validator.js:

const validator = require('validator');

app.post('/register', (req, res) => {
  const { username, password, email } = req.body;

  if (!validator.isEmail(email)) {
    return res.status(400).json({ error: 'Invalid email address' });
  }

  // Other input validation and sanitization logic...

  // Save the user to the database
});

Code Profiling

Profile your Node.js application to identify performance bottlenecks and optimize critical sections of code. Use profiling tools like Node.js's built-in profiler or external tools like Clinic.js to gather performance metrics, analyze CPU and memory usage, and pinpoint areas that can be optimized.

Example: Profiling a Node.js application using the built-in perf_hooks module:

const { PerformanceObserver, performance } = require('perf_hooks');

// Start profiling
performance.mark('start');

// Code to be profiled...

// End profiling
performance.mark('end');
performance.measure('My Application', 'start', 'end');

// Output the performance measurement
const obs = new PerformanceObserver((items) => {
  const measure = items.getEntriesByName('My Application')[0];
  console.log(`Execution time: ${measure.duration} milliseconds`);
  performance.clearMarks();
});
obs.observe({ entryTypes: ['measure'] });

Battle of the Node.js ORMs: Sequelize vs TypeORM

Victor J. Rosario V. — Fri, 07 Apr 2023 21:00:56 +0000

Popular Object-Relational Mapping (ORM) libraries for Node.js include Sequelize and TypeORM. Both of these libraries offer a higher level of abstraction over relational databases and simplify database operations by offering a user-friendly API.

While there are numerous parallels across these libraries, there are also significant variances. Some of the most significant distinctions between Sequelize and TypeORM will be discussed in this post.

Language Support

The language support offered by Sequelize and TypeORM is one of their key distinctions. When compared to TypeORM, Sequelize supports TypeScript as well as JavaScript.

Sequelize may therefore be a better option for you if you're working on a JavaScript-based project. However, if you're using TypeScript, TypeORM might be a better choice.

Querying

Another difference between Sequelize and TypeORM is in how they handle queries. Sequelize uses a query builder, which allows you to construct complex queries using JavaScript or TypeScript. On the other hand, TypeORM uses a repository pattern, which allows you to perform basic CRUD (Create, Read, Update, Delete) operations using methods like find, findOne, save, update, and delete.

Both approaches have advantages, however, TypeORM's repository design may be easier to use for simple CRUD operations while Sequelize's query builder mechanism may be better suited for more complex queries.

Relationships

You can specify one-to-many, many-to-many, and one-to-one relationships between tables in your database using both Sequelize and TypeORM. They manage relationships differently, though.

Sequelize defines relationships using a conventional method, in which the foreign key constraint is specified in the migration or model definition. On the other hand, TypeORM employs a more contemporary methodology in which relationships are defined using decorators in your model design.

This indicates that Sequelize might be a better option for you if you want a more conventional way of defining relationships. Nonetheless, TypeORM can be a better choice if you choose a more contemporary strategy.

Support for Other Databases

Their support for different databases is yet another distinction between Sequelize and TypeORM. Despite the fact that both libraries support a variety of databases, Sequelize offers broader support for more databases, such as MySQL, PostgreSQL, SQLite, and Microsoft SQL Server. Contrarily, MySQL, PostgreSQL, MariaDB, SQLite, Oracle, Microsoft SQL Server, and MongoDB are all supported by TypeORM.

This can be a crucial consideration if you're using a particular database that neither library supports.

Sample CRUD using both ORMs

Sequelize Example

Here is an example of how to create a model and carry out CRUD operations on a database table using Sequelize:

const { Sequelize, Model, DataTypes } = require('sequelize');

const sequelize = new Sequelize('database', 'username', 'password', {
  host: 'localhost',
  dialect: 'mysql'
});

class User extends Model {}
User.init({
  firstName: DataTypes.STRING,
  lastName: DataTypes.STRING,
  email: DataTypes.STRING
}, { sequelize, modelName: 'user' });

(async () => {
  await sequelize.sync();
  const user = await User.create({ firstName: 'John', lastName: 'Doe', email: 'john.doe@example.com' });
  console.log(user.toJSON());
  const users = await User.findAll();
  console.log(users.map(user => user.toJSON()));
})();

This code establishes a connection to a MySQL database, defines a User model with three characteristics, synchronizes the model with the database, creates a new user record, retrieves all users from the database, and logs the results to the console.

TypeORM Example

Here's an example of using TypeORM to define a model and perform CRUD operations on a database table:

import { createConnection } from 'typeorm';

@Entity()
class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  firstName: string;

  @Column()
  lastName: string;

  @Column()
  email: string;
}

(async () => {
  const connection = await createConnection();
  const user = new User();
  user.firstName = 'John';
  user.lastName = 'Doe';
  user.email = 'john.doe@example.com';
  await connection.manager.save(user);
  console.log(user);
  const users = await connection.manager.find(User);
  console.log(users);
})();

By creating a new user record, building a User entity with three properties, extracting all users from the database, and logging the results to the console, this application connects to a normal MySQL database.

As you can see, both Sequelize and TypeORM provide similar APIs for defining models/entities and performing CRUD operations on a database table. However, the syntax and approach are different due to the language and design choices made by each library.

Sample relationship table using both ORMs

TypeORM Example

Take the User and Post objects as an example. Each post has a single owner, and each user is permitted to have several posts. Here is how this relationship might be expressed using TypeORM:

@Entity()
class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @OneToMany(() => Post, post => post.user)
  posts: Post[];
}

@Entity()
class Post {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  title: string;

  @Column()
  content: string;

  @ManyToOne(() => User, user => user.posts)
  user: User;
}

In the User entity, we define a one-to-many relationship with Post using the @OneToMany decorator. We specify that the relationship is to the Post entity and that it's related to the user property on the Post entity.

In the Post entity, we define a many-to-one relationship with User using the @ManyToOne decorator. We specify that the relationship is to the User entity and that it's related to the posts property on the User entity.

With this setup, we can fetch a user and all their posts like this:

const user = await connection.manager.findOne(User, 1, { relations: { posts: true } });

This will fetch the user with the ID of 1 and eagerly load all their posts.

Sequelize Example

Here's how we can define the same relationship using Sequelize:

const { Sequelize, Model, DataTypes } = require('sequelize');

const sequelize = new Sequelize('database', 'username', 'password', {
  host: 'localhost',
  dialect: 'mysql'
});

class User extends Model {}
User.init({
  name: DataTypes.STRING
}, { sequelize, modelName: 'user' });

class Post extends Model {}
Post.init({
  title: DataTypes.STRING,
  content: DataTypes.STRING
}, { sequelize, modelName: 'post' });

User.hasMany(Post);
Post.belongsTo(User);

In this example, we define the User and Post models using Model.init. We then define the relationship between the two models using the User.hasMany(Post) and Post.belongsTo(User) methods.

With this setup, we can fetch a user and all their posts like this:

const user = await User.findByPk(1, { include: [Post] });

This will fetch the user with the ID of 1 and eagerly load all their posts.

Maximize Your Coding Efficiency with These Top VS Code Plugins

Victor J. Rosario V. — Mon, 27 Mar 2023 03:18:17 +0000

Visual Studio Code is a super popular code editor that lots of developers use. It's packed with cool features and functions that make it an excellent choice for coding. One of the coolest things about VS Code is that you can add plugins to make it even better. In this post, we're going to talk about the top 5 plugins for VS Code.

1. ESLint

ESLint is a plugin that helps you make sure your code is good quality. It looks at your JavaScript code and tells you if it's doing anything weird or bad. The plugin gives you feedback as you code, so you can catch mistakes early. Plus, it helps you write consistent code that follows best practices.

2. GitLens

GitLens is a plugin that makes working with Git in VS Code much easier. It gives you all sorts of info about your code, like who wrote it and when it was last changed. It also shows you a visual history of your code changes, so you can easily see what's been happening.

3. Bracket Pair Colorizer

Bracket Pair Colorizer is a plugin that makes it way easier to read code. It colors the brackets in your code, so you can see which ones match up. This is especially useful when you're working with nested code blocks.

4. Live Server

Live Server is a plugin that lets you see changes to your code in real time. It sets up a local server that refreshes your code automatically whenever you make changes. This is super useful for web development, where you need to see changes quickly.

5. REST Client

REST Client is a plugin that helps you test APIs. It gives you a simple way to send HTTP requests and see the responses. This is a must-have for developers who work with APIs a lot.

So those are the top 5 best plugins for VS Code! They'll help you write better code, work more efficiently, and have a better coding experience overall.

Variable Declaration in JavaScript

Victor J. Rosario V. — Sat, 25 Feb 2023 23:34:10 +0000

In JavaScript, variables are declared using the keywords const, let, and var. Each of these keywords has different ways of handling variable scope, meaning each is used in different situations.

const 💪

It is used to declare variables that will not change throughout the software life cycle. Once a value is assigned to a constant variable, it cannot be reassigned.

const PI = 3.14;
PI = 3; // TypeError: Assignment to constant variable.

Advantages:

Variables declared with const are safe and cannot be accidentally reassigned.
Variables declared with const are easier to track, since they will always have the same value.

Disadvantages:

Variables declared with const cannot be changed later, which can be a problem if you need to update the value of a variable.

let 🤗

It is used to declare variables that may change during the software life cycle. Unlike const, you can reassign values to variables declared with let.

let count = 0;
count = 1;

Advantages:

Variables declared with let can be reassigned throughout the program, which means that you can update their values at any time.
Variables declared with let are easier to read, since they show that the variable may change over time.

Disadvantages:

If not handled properly, excessive use of variables declared with let can make the code difficult to read.

var 👴

This is the oldest form of declaring variables in JavaScript. Unlike const and let, variables declared with var have a function scope.

function exampleFunction() {
  var message = 'Hello world';
  console.log(message);
}

console.log(message);

Advantages:

Variables declared with var have a function scope, which means that they can be accessed from anywhere within the function in which they are declared.

Disadvantages:

Variables declared with var can be declared in the same function, which can lead to errors and code maintenance problems.
If a variable is declared with var outside a function, it will become a global variable, which can be dangerous in large programs.

Conclusion

In summary, each keyword has a specific use in JavaScript. const is used to declare variables that won't change throughout a program's lifecycle, let is used to declare variables that can change over time, and var is primarily used in older versions of JavaScript. Overall, it's recommended to use const and let instead of var to ensure safer and more readable code.

DEV Community: Victor J. Rosario V.

Production Is Not a Joke: A Lesson I Learned the Hard Way

The Production Conversation

Conclusion

Why Learning C Is My First Step Toward Becoming a Game Engine Programmer

Conclusion

🔍 Say Goodbye to Slow Renders: Optimizing React Apps with `react-scan`

What is react-scan?

Installation and Setup

Key APIs of react-scan

Examples of Component Optimization

Best Practices for Optimization

Conclusion

Battle of the Node.js ORMs: Sequelize vs. Prisma

Sequelize: The Established Veteran

Prisma: The New Challenger

Choosing the Right Champion for Your Project

Example Code

Sequelize (using PostgreSQL):

Prisma (using PostgreSQL):

The Best ORMs for Node.js App Development in 2023

What is an ORM?

Importance of ORMs

Sequelize

TypeORM

Prisma

Objection.js

Bookshelf.js

Choosing the right ORM for your Node.js project

Conclusion

From Good to Great: Scaling Applications with TypeORM Optimization

Exploring the Contrast: Helpers and Utils Demystified

Unlocking Node.js Performance: The Art of Data Caching

Introduction

👟 Optimizing Your Node.js Project: Best Practices for Performance and Efficiency

Introduction

Code Efficiency

Asynchronous Programming

Caching

Proper Error Handling

Load Balancing and Scaling

Continuous Testing and Profiling

Security Measures

Code Profiling

Battle of the Node.js ORMs: Sequelize vs TypeORM

Language Support

Querying

Relationships

Support for Other Databases

Sample CRUD using both ORMs

Sequelize Example

TypeORM Example

Sample relationship table using both ORMs

TypeORM Example

Sequelize Example

Maximize Your Coding Efficiency with These Top VS Code Plugins

1. ESLint

2. GitLens

3. Bracket Pair Colorizer

4. Live Server

5. REST Client

Variable Declaration in JavaScript

const 💪

let 🤗

var 👴

Conclusion

What is `react-scan`?

Key APIs of `react-scan`