Forem: Harold Mudosa

C++ Arrays and Vectors: How I understood the Differences

Harold Mudosa — Fri, 14 Nov 2025 12:03:27 +0000

Yearning to become an Unreal Engine and VR developer, I’ve been diving into C++ fundamentals. Coming from a JavaScript background, I initially thought that working with arrays would be more than enough. That was until I started tackling coding challenges and realized that arrays in C++ aren’t quite the all-stars they are in JavaScript.

I was soon forced to learn about vectors. Realizing I had a big knowledge gap, I spent over 10 hours trying to understand why things suddenly felt so complicated, especially when I thought I already had it figured out, being a JavaScript professional.

Through this process, I identified some key differences between arrays and vectors in C++ that really helped me make sense of things.

1. How to read their collection length

- Arrays

You need to know their size beforehand or calculate them manually based on your full array and its first element's size in bytes.

int numbers[5] = {1, 2, 3, 4, 5};
int length = sizeof(numbers) / sizeof(numbers[0]); // calculates number of elements based on their size in bytes(sizeof() is for sizes in bytes)
std::cout << "Array length: " << length << std::endl; //Array length: 5

- Vectors

They have a built-in .size() method, which makes it much easier(in my opinion😁).

#include <vector>
#include <iostream>
using namespace std;

vector<int> numbers = {1, 2, 3, 4, 5};
cout << "Vector length: " << numbers.size() << endl; //5

2. Their Memory Allocation

- Arrays

At compile time, their size must be known, and once an array is created, you cannot change its size.

int numbers[5]; // memory for 5 ints is allocated at compile time

- Vectors

They are dynamic, and since for them the memory is managed at runtime, their size doesn't need to be declared beforehand.

#include <vector>
#include <iostream>
using namespace std;

vector<int> numbers;      // no initial size needed

3. Their growth in size

- Arrays

Their size can grow, but only up to the number of elements you initially allocated. You cannot exceed that size (unless you create a new array😌).

int numbers[5] = {1, 2, 3}; // can only grow up to 5

- Vectors

They can grow beyond their initial capacity. When you add more elements than the current capacity(using the .push_back method), vectors automatically allocate more memory internally to accommodate the new elements.

#include <vector>
#include <iostream>
using namespace std;

vector<int> numbers = {1, 2, 3};
numbers.push_back(4);  // grows automatically
numbers.push_back(5);  
cout << "Vector size: " << numbers.size() << endl; // Vector size: 5

3. Their decrease in size

- Arrays

Their size is fixed at compile time. You cannot remove elements or shrink the array. You can only overwrite values, but the memory and “length” stay the same. Here is how it's done:

Knowing that int numbers[5] = {1,2,3} is the same as {1,2,3,0,0} under the hood, the only way to decrease numbers in size is by updating, for example, the item 3 to 0.

int arr[3] = {1, 2, 3};
arr[2] = 0; // you can overwrite but cannot remove arr[2] (now we'll have something similar to {1, 2, 0, 0, 0}) ❌

- Vectors

They are dynamic, so you can remove elements at runtime using .pop_back() to remove the last element or .erase() to remove specific elements.

#include <vector>
#include <iostream>
using namespace std;

vector<int> numbers = {1, 2, 3, 4};
numbers.pop_back();      // removes 4
numbers.erase(numbers.begin() + 1); // removes 2
cout << "Vector size: " << numbers.size() << endl; // Vector size: 2

4.Their compatibility with the STL algorithm

- Arrays

You can use the Standard Template Library(STL) Algorithms. But for some cases, you'll need to provide pointers or iterators, which feels kinda manual.

#include <algorithm>
#include <iostream>
using namespace std;

// to sort an array, you need to first specify the range
int numbers[] = {5, 2, 4, 1, 3};
int n = sizeof(numbers) / sizeof(numbers[0]);
sort(numbers, numbers + n);

for(int x : numbers)
    cout << x << " "; // 1 2 3 4 5

Vectors

They work directly with STL algorithms without extra pointers, making code cleaner and safer than it is for arrays (according to me🤫).

#include <algorithm>
#include <iostream>
using namespace stf;

vector<int> numbers = {5, 2, 4, 1, 3};
sort(numbers.begin(), numbers.end());

for(int x: numbers) {
  cout << x << " "; // 1 2 3 4 5
}

Conclusion

Arrays and vectors each have their strengths. Arrays are simple, fixed-size, and slightly faster for certain operations, while vectors are dynamic, flexible, and work seamlessly with modern C++ features like STL algorithms.

I hope the differences we covered here: length, dynamic growth, memory allocation, initialization, shrinking, templates, and STL compatibility, will help you understand when and why to use each.

For a deeper dive, check out GeeksforGeeks: Advantages of Vector over Array in C++.

How does Java work under the hood?

Harold Mudosa — Fri, 17 Jan 2025 12:56:58 +0000

First off, what is java ?

Java is a multiplatform object-oriented programming language.

What I mean by the word "multiplatform" is that not only can it be used to create web, mobile applications and games, It can also run on any device you can think of.

What I meant by Object-oriented programming(OOP) is that its main concept turns around objects, which are simply data that have properties and behaviors.

Now, How is it processed in our Computers ?

Java processing can be compared to a journey, and the best way to describe this journey is by breaking it down step by step:

Step 1. The code script

As we all know the code needs to be typed in a ".java" file from an editor(Notepad, IDE, etc.).

But this code is only understandable by humans so we'll need a way to convert our Java code into something that can be read and understood by our computer.

Step 2. Compilation into Bytecode

Javac or Java compiler, just as its name shows it, is the standard Java compiler.

So what it does is, take the Java code and compile it into something called Bytecode under the influence of some command.

A Bytecode is a set of instructions that can run on any device as long as it contains a Java Virtual Machine(JVM).

Step 3. JVM's role play

The JVM(Java Virtual Machine), is a powerful translator, it takes the Bytecode and makes it understandable by the computer's processor backed up by the JRE(Java Runtime Environment) that provides different libraries or interfaces that will help the JVM operate seamlessly.

One more thing though, the JVM doesn't just run our Bytecode directly, this is what it goes through:
- interpretation: Our JVM converts each line of code into an instruction or action the computer should execute, also called the Bytecode.
- JIT compilation: For things to run faster, the JVM takes those bytecodes and converts them into native machine code(the language our computer's processor can understand) by the JIT(Just-In-Time Compiler).

Step 4. Running the Program

Now that our JVM has done its work, it finally sends the instruction to the computer to run or print whatever the developer was intending to print(let's say may be a "hello world!!" on the screen, or that cool game above😊).

NextAuth.js authentication with Github and Google in NextJs

Harold Mudosa — Fri, 29 Nov 2024 09:33:11 +0000

NextAuth aims to make authentication simple, yet secure in Next.js apps. it handles automatically practices like passwordless flow, scoping access and more.

With it you can simply get authenticated through your existing logins from different platforms like Google, Atlassian, github, etc.

Step by step guide

Step 1. Setting up NextAuth for sign in

Run npm install next-auth@4.24.7 to install next auth dependecies
In in your src/app directory create a lib directory in which you'll add the authOptions.ts file with the following changes:

//src/app/lib/authOptions.ts

import { NextAuthOptions } from "next-auth";
import GithubProvider from "next-auth/providers/github";
import GoogleProvider from "next-auth/providers/google";

export const authOptions: NextAuthOptions = {
  providers: [
    GithubProvider({
      clientId: process.env.GITHUB_ID,
      clientSecret: process.env.GITHUB_SECRET
    }),
    GoogleProvider({
      clientId: process.env.GOOGLE_ID,
      clientSecret: process.env.GOOGLE_SECRET
    }),  
  ],
}

To get the values of the above clientId and clientSecret, we'll go through the following process in both github and googleCloud respectively:

For Github, let's go to our Github
- Navigate then through: Your profile icon(at the top right of the interface) > settings > developer settings > OAuth > New Project. And Then fill in the form this way:

Next, recover the clientId highlighted below and then generate client secret.

For Google, let's go to our Google Cloud
- Navigate then through: my Project(right near the logo) > Menu > API > Identifiers > Create identifier > ID client OAuth. And then do the following:
First select the web app as the application type
Then, Fill in the form like this:

Same process, by clicking on Create you'll be able to recover those keys as well.

NOTE:

replace "weiterbildung" by the name of your project
Go to your existing .env file in which you'll save those keys and more sensitive informations, create it if it doesn't exist in your root directory.

Step 2. Create the Authentication API route

In App Create the directory api/[...nextauth]/route.ts and implement the authentication API route the following way:

// route.ts

import { authOptions } from "@/lib/authOptions";
import NextAuth from "next-auth";
import { AuthOptions } from "next-auth";

const handler = NextAuth(authOptions as AuthOptions);

export { handler as GET, handler as POST };

Create a provider that will wrap your system, to make all its props available like a context, in your lib directory, create sessionWrapper.tsx where you'll do:

//sessionWrapper.tsx

"use client"

import { SessionProvider } from "next-auth/react"

const SessionWrapper = ({children}: {children: React.ReactNode}) => {
  return <SessionProvider>{children}</SessionProvider>
}

export default SessionWrapper;

implement the SessionWrapper component in layout.tsx after importing it and wrap the layout elements within it, its return should look like this:

//layout.tsx
import SessionWrapper from "../lib/sessionWrapper";

//...some code
return (
    <SessionWrapper> //here you are
      <html lang="en">
        <body
          className={`${geistSans.variable} ${geistMono.variable} antialiased`}
        >
          <ClientLayout session={session}>{children}</ClientLayout>
        </body>
      </html>
    </SessionWrapper> //here you are
  );

Step 3. Set up the connexion between your system and the google and github providers

In your log-in page or component do the following modification:

//logIn.tsx


"use client"

import { signIn, useSession } from 'next-auth/react';

export default function Login() {
  const { data: session } = useSession();

  if(session) {
    console.log('session', session);
  }


  return (
    <div>
          <button
            type="button"
            onClick={() => signIn('github')}
            className="w-full py-2 my-2 border border-red-500"
          >Login with Github
          </button>

          <button
            type="button"
            onClick={() => {signIn('google')}}
            className="w-full py-2 my-2 border border-red-500"
          >Login with Google
          </button>
    </div>
  );
}

In your log-out component do the following modification:

//signOut.tsx


import { signOut } from 'next-auth/react';

export default function Login() {  
  return (
    <div>
          <button
            type="button"
            onClick={() => signOut()}
            className="w-full py-2 my-2 border border-red-500"
          >Log out
          </button>

    </div>
  );
}

RESULT WITH GOOGLE:

NOTE:

In the console, you'll be able to see the user credential once the signIn function is triggered by any of the two buttons.
You can choose to get the JWT(Json Web Token) instead of a row object if you want to get your backend involved.

Easiest way of Implementing Authentication in NestJS

Harold Mudosa — Fri, 22 Nov 2024 11:03:00 +0000

In this article you'll be walked through the most straightforward guide of implementing authentication in NestJS, the most efficient scalable server-side applications builder among NodeJS frameworks.

We'll cover best practices, fundamental concepts that I believe you already have a slight prerequisite in by now and clearer examples. The purpose is to help you build the most robust authentication systems for your NestJS applications from simple concepts.

In simple words, Authentication is a process used to show that something or someone is legit, genuine or valid. hence authentication is a way of verifying if the user is really who they pretend to be before giving them access to a system or to some resources of this latter.

This goes hand in hand with Authorization, which is a process by which the server determines if a user has permission to have access on a specific resource of a system.

Developer Viewpoint Scenario

Before talking about Authentication, the client should register himself as a user of our system, and for that he will need to sign up, a process where he will post the credentials that will allow the system to recognize him later on.

Now talking of Authentication, the user will initiate the process by passing in his username/email and password, which will trigger the server to generate a JWT(Json Web Token) upon a successful authentication, Token that will then be transmitted as a bearer token in the authentication header for verification.

Step by Step guide:

Step_1. Create a resource for the users credentials

I assume that you already know how to create resources in NestJS, if not click here to learn how to do so.
Well, first thing first create a resource called maybe "user", this will manage the users credential data, remember the user credentials have to be stored somewhere, right ?

Step_2. Implement authentication in your REST API.

Run the following command and when prompted don’t generate the CRUD, this auth is a special type of resource.

npm nest generate resource auth

Install and configure passport(a library that manage authentication states).

npm install --save @nestjs/passport passport @nestjs/jwt passport-jwt npm install --save-dev @types/passport-jwt npm install passport-jwt

In auth.modute.ts, add the following highlighted code-lines[by red dots 🔴].

Implement a POST endpoint at /auth/login

Create a new file called login.dto.ts inside the src/auth/dto folder and then define the LoginDto class interface based on the email and password properties for the login.

Create a new file called auth.entity.ts inside the src/auth/entity that will describe the the shape of the jwt payload.

Create a new login method inside the auth.service.ts file.

Now, In auth.controller.ts create a POST endpoint at /auth/login

Step_3. Implement JWT authentication strategy

First create a new file called jwt.strategy.ts inside the src/auth/strategy directory.

Into Auth.module.ts import then add JwtStrategy in the imports and usersModule in the providers[see red dots 🔴].

To make UsersService accessible in our class(surely AuthService), you also need to add it in the exports of the UsersModule.

Step_4. Protecting our system resources from unverified users

JWT auth guard will be used to protect routes that require authentication in order to be accessed, in our case let's protect the users resource API routes. so, in src/auth, create a file called jwt-auth.guard.ts.

NOTE: The AuthGuard class expects the name of an authentication strategy. In this case, you are using the JwtStrategy that you implemented in the previous section, which is named “jwt”.

You can now use this guard (UseGuards(JwtAuthGuard)) as a decorator to protect your endpoints. Add the JwtAuthGuard to routes in the UsersController.

NOTE: If you're using Swagger, integrate an authentication indication that will highlight the routes that are protected using the @ApiBearerAuth() decorator. first define it in main, then implement it in users.controller.ts.

AND NOW YOU'RE ALL SET😮‍💨

Easiest way of Implementing Authentication in NestJS

Harold Mudosa — Fri, 22 Nov 2024 11:03:00 +0000

In this article you'll be walked through the most straightforward guide of implementing authentication in NestJS, the most efficient scalable server-side applications builder among NodeJS frameworks.

This goes hand in hand with Authorization, which is a process by which the server determines if a user has permission to have access on a specific resource of a system.

Developer Viewpoint Scenario

Step by Step guide:

Step_1. Create a resource for the users credentials

I assume that you already know how to create resources in NestJS, if not click here to learn how to do so.
Well, first thing first create a resource called maybe "user", this will manage the users credential data, remember the user credentials have to be stored somewhere, right ?

Step_2. Implement authentication in your REST API.

Run the following command and when prompted don’t generate the CRUD, this auth is a special type of resource.

npm nest generate resource auth

Install and configure passport(a library that manage authentication states).

npm install --save @nestjs/passport passport @nestjs/jwt passport-jwt npm install --save-dev @types/passport-jwt npm install passport-jwt

In auth.modute.ts, add the following highlighted code-lines[by red dots 🔴].

Implement a POST endpoint at /auth/login

Create a new file called login.dto.ts inside the src/auth/dto folder and then define the LoginDto class interface based on the email and password properties for the login.

Create a new file called auth.entity.ts inside the src/auth/entity that will describe the the shape of the jwt payload.

Create a new login method inside the auth.service.ts file.

Now, In auth.controller.ts create a POST endpoint at /auth/login

Step_3. Implement JWT authentication strategy

First create a new file called jwt.strategy.ts inside the src/auth/strategy directory.

Into Auth.module.ts import then add JwtStrategy in the imports and usersModule in the providers[see red dots 🔴].

To make UsersService accessible in our class(surely AuthService), you also need to add it in the exports of the UsersModule.

Step_4. Protecting our system resources from unverified users

JWT auth guard will be used to protect routes that require authentication in order to be accessed, in our case let's protect the users resource API routes. so, in src/auth, create a file called jwt-auth.guard.ts.

You can now use this guard (UseGuards(JwtAuthGuard)) as a decorator to protect your endpoints. Add the JwtAuthGuard to routes in the UsersController.

AND NOW YOU'RE ALL SET😮‍💨

Easiest way of Implementing Authentication in NestJS

Harold Mudosa — Fri, 22 Nov 2024 11:03:00 +0000

In this article you'll be walked through the most straightforward guide of implementing authentication in NestJS, the most efficient scalable server-side applications builder among NodeJS frameworks.

This goes hand in hand with Authorization, which is a process by which the server determines if a user has permission to have access on a specific resource of a system.

Developer Viewpoint Scenario

Step by Step guide:

Step_1. Create a resource for the users credentials

I assume that you already know how to create resources in NestJS, if not click here to learn how to do so.
Well, first thing first create a resource called maybe "user", this will manage the users credential data, remember the user credentials have to be stored somewhere, right ?

Step_2. Implement authentication in your REST API.

Run the following command and when prompted don’t generate the CRUD, this auth is a special type of resource.

npm nest generate resource auth

Install and configure passport(a library that manage authentication states).

npm install --save @nestjs/passport passport @nestjs/jwt passport-jwt npm install --save-dev @types/passport-jwt npm install passport-jwt

In auth.modute.ts, add the following highlighted code-lines[by red dots 🔴].

Implement a POST endpoint at /auth/login

Create a new file called login.dto.ts inside the src/auth/dto folder and then define the LoginDto class interface based on the email and password properties for the login.

Create a new file called auth.entity.ts inside the src/auth/entity that will describe the the shape of the jwt payload.

Create a new login method inside the auth.service.ts file.

Now, In auth.controller.ts create a POST endpoint at /auth/login

Step_3. Implement JWT authentication strategy

First create a new file called jwt.strategy.ts inside the src/auth/strategy directory.

Into Auth.module.ts import then add JwtStrategy in the imports and usersModule in the providers[see red dots 🔴].

To make UsersService accessible in our class(surely AuthService), you also need to add it in the exports of the UsersModule.

Step_4. Protecting our system resources from unverified users

JWT auth guard will be used to protect routes that require authentication in order to be accessed, in our case let's protect the users resource API routes. so, in src/auth, create a file called jwt-auth.guard.ts.

You can now use this guard (UseGuards(JwtAuthGuard)) as a decorator to protect your endpoints. Add the JwtAuthGuard to routes in the UsersController.

AND NOW YOU'RE ALL SET😮‍💨

Easiest way of Implementing Authentication in NestJS

Harold Mudosa — Fri, 22 Nov 2024 11:03:00 +0000

In this article you'll be walked through the most straightforward guide of implementing authentication in NestJS, the most efficient scalable server-side applications builder among NodeJS frameworks.

This goes hand in hand with Authorization, which is a process by which the server determines if a user has permission to have access on a specific resource of a system.

Developer Viewpoint Scenario

Step by Step guide:

Step_1. Create a resource for the users credentials

I assume that you already know how to create resources in NestJS, if not click here to learn how to do so.
Well, first thing first create a resource called maybe "user", this will manage the users credential data, remember the user credentials have to be stored somewhere, right ?

Step_2. Implement authentication in your REST API.

Run the following command and when prompted don’t generate the CRUD, this auth is a special type of resource.

npm nest generate resource auth

Install and configure passport(a library that manage authentication states).

npm install --save @nestjs/passport passport @nestjs/jwt passport-jwt npm install --save-dev @types/passport-jwt npm install passport-jwt

In auth.modute.ts, add the following highlighted code-lines[by red dots 🔴].

Implement a POST endpoint at /auth/login

Create a new file called login.dto.ts inside the src/auth/dto folder and then define the LoginDto class interface based on the email and password properties for the login.

Create a new file called auth.entity.ts inside the src/auth/entity that will describe the the shape of the jwt payload.

Create a new login method inside the auth.service.ts file.

Now, In auth.controller.ts create a POST endpoint at /auth/login

Step_3. Implement JWT authentication strategy

First create a new file called jwt.strategy.ts inside the src/auth/strategy directory.

Into Auth.module.ts import then add JwtStrategy in the imports and usersModule in the providers[see red dots 🔴].

To make UsersService accessible in our class(surely AuthService), you also need to add it in the exports of the UsersModule.

Step_4. Protecting our system resources from unverified users

JWT auth guard will be used to protect routes that require authentication in order to be accessed, in our case let's protect the users resource API routes. so, in src/auth, create a file called jwt-auth.guard.ts.

You can now use this guard (UseGuards(JwtAuthGuard)) as a decorator to protect your endpoints. Add the JwtAuthGuard to routes in the UsersController.

AND NOW YOU'RE ALL SET😮‍💨

Easiest way of Implementing Authentication in NestJS

Harold Mudosa — Fri, 22 Nov 2024 11:03:00 +0000

In this article you'll be walked through the most straightforward guide of implementing authentication in NestJS, the most efficient scalable server-side applications builder among NodeJS frameworks.

This goes hand in hand with Authorization, which is a process by which the server determines if a user has permission to have access on a specific resource of a system.

Developer Viewpoint Scenario

Step by Step guide:

Step_1. Create a resource for the users credentials

I assume that you already know how to create resources in NestJS, if not click here to learn how to do so.
Well, first thing first create a resource called maybe "user", this will manage the users credential data, remember the user credentials have to be stored somewhere, right ?

Step_2. Implement authentication in your REST API.

Run the following command and when prompted don’t generate the CRUD, this auth is a special type of resource.

npm nest generate resource auth

Install and configure passport(a library that manage authentication states).

npm install --save @nestjs/passport passport @nestjs/jwt passport-jwt npm install --save-dev @types/passport-jwt npm install passport-jwt

In auth.modute.ts, add the following highlighted code-lines[by red dots 🔴].

Implement a POST endpoint at /auth/login

Create a new file called login.dto.ts inside the src/auth/dto folder and then define the LoginDto class interface based on the email and password properties for the login.

Create a new file called auth.entity.ts inside the src/auth/entity that will describe the the shape of the jwt payload.

Create a new login method inside the auth.service.ts file.

Now, In auth.controller.ts create a POST endpoint at /auth/login

Step_3. Implement JWT authentication strategy

First create a new file called jwt.strategy.ts inside the src/auth/strategy directory.

Into Auth.module.ts import then add JwtStrategy in the imports and usersModule in the providers[see red dots 🔴].

To make UsersService accessible in our class(surely AuthService), you also need to add it in the exports of the UsersModule.

Step_4. Protecting our system resources from unverified users

JWT auth guard will be used to protect routes that require authentication in order to be accessed, in our case let's protect the users resource API routes. so, in src/auth, create a file called jwt-auth.guard.ts.

You can now use this guard (UseGuards(JwtAuthGuard)) as a decorator to protect your endpoints. Add the JwtAuthGuard to routes in the UsersController.

AND NOW YOU'RE ALL SET😮‍💨