DEV Community: Giuliana Olmos

Technical Interview Questions - Part 7 - Promises Methods

Giuliana Olmos — Thu, 19 Dec 2024 13:07:43 +0000

Introduction

Hello! 😊

We've reached the end of this series! 🎉

It's been months of interviewing, thinking, writing, and coding.

Interviews can be stressful and challenging, and staying positive through rejections is never easy. I started this series after going through several interviews where I struggled—whether it was not knowing enough, giving inconsistent answers, or having difficulty expressing myself clearly.

I truly hope these posts have been as helpful to you as they have been to me.

For this final post, I’m covering just one question, so it’ll be a short one. Let's dive in!

## Questions
1. What Are Promise.all(), Promise.allSettled(), and Promise.race()?

What Are `Promise.all()`, `Promise.allSettled()`, and `Promise.race()`?

🎯Promise.all()

This method takes an iterable of promises and returns a single promise that fulfills when all the input promises have fulfilled. If any of the promises reject, the returned promise immediately rejects with the reason for the first rejection. All the promises run at the same time, and the total time it takes equals the time taken by the slowest promise to resolve.

🎯Promise.allSettled()

This method works similarly to Promise.all(), but the difference is in the returned value. Instead of stopping at the first rejection, it waits for all promises to settle (either resolve or reject). The result is an array that shows the outcome of each promise. All promises run at the same time, and the total time it takes equals the time taken by the slowest promise to settle. If one or more promises fail, you’ll still be able to see the result, since the status of each promise will be included in the returned array, in the same order as the input promises.

🎯Promise.race()

Like Promise.all() and Promise.allSettled(), this method also takes an iterable of promises. The difference is that instead of waiting for all the promises, it settles as soon as the first promise resolves or rejects. The returned promise adopts the state (fulfilled or rejected) and value or reason of the first settled promise. This method is part of the promise concurrency methods.

✨Key Points✨

All three methods handle arrays (or iterables) of promises.
Promise.all() and Promise.allSettled() execute all promises concurrently, while Promise.race() resolves/rejects based on the first settled promise.
Each method has its use case depending on whether you need all results, individual outcomes, or the fastest result.

End

As I mentioned, this was a really short post. 😉
This marks the end of this series (at least for this season). 🥰

I've been thinking about a lot of topics to write about next. Interviews have taught me so many new things—new topics, new ways of thinking, and a lot about architecture. So maybe the next series will be about that. 🤩

For now, I’m planning to take a few weeks to rest before I start writing again. I really want to take some time to recharge.

I truly hope all of you find your dream job.💖 Wishing you the best of luck on this journey! If any of you land a job or successfully answer interview questions thanks to my posts, I’d love to hear about it.

Thank you so much for reading! 🥹

Have a wonderful end of the year and an even better new year filled with opportunities, interviews, and exciting challenges! 🎉

Technical Interview Questions - Part 6 - SQL 2

Giuliana Olmos — Thu, 12 Dec 2024 12:46:10 +0000

Introduction

Hello, everyone! 😀

We're getting close to the end of this series, and I hope you've been enjoying it so far.

In this post, I'll dive into some SQL questions that I couldn't include in the earlier posts. These questions are pretty recent—I had to answer them just a few days ago—and interestingly, they came up twice!

As you've probably noticed, this post is titled "SQL 2." If you're curious about the first post on SQL, you can check it out here.

Now, let's jump into the questions!

## Questions
1. What is the difference between OUTER JOIN and INNER JOIN?
2. What is an Index? What are the Trade-offs of Using Indices?

Question 1: What is the difference between OUTER JOIN and INNER JOIN?

This will be a short answer since it’s not too complicated...

Inner Join: The inner join is used when we want to return only the common values (or rows) between two tables.

Outer Join: In contrast, the outer join returns the same values as the inner join, plus any rows that don’t have a match in the other table.

Which table will be prioritized?

It depends on the type of outer join being used:

Left Join: Returns the inner join results plus all the rows from the left table.
Right Join: Returns the inner join results plus all the rows from the right table.
Full Join: Returns all the rows from both tables, regardless of matches.

Question 2: What is an Index? What are the Trade-offs of Using Indices?

The short answer is...

An index is an object in the database used to optimize query performance. By creating an index, you can significantly speed up how quickly the database retrieves data.

In most cases, interviewers might not directly ask, "What is an index?" Instead, you could first encounter a question like, "How would you debug a slow query or improve its performance?" This is when you might respond, ✨“I would improve this query using an index.”✨ This response could lead the interviewer to ask more about indices.

Then...

An index is a tool associated with a database table designed to improve query performance. It’s stored within the database, meaning it occupies storage space.

Indexes can be composed of one (Single-column Index) or more (Composite Index) columns.

What are the trade-offs of using indices? 🎯

Increased Disk Space Usage
Indexes take up additional storage in the database. The more indexes you create, the more disk space is consumed.
Slower Write Operations
When we use INSERT, UPDATE, or DELETE operations, the database also needs to update the indices. This makes these operations take more time to process.
More Maintenance
Using indices adds maintenance overhead. Every time we update the data, we need to consider how the indices on the affected tables will be impacted. Here are some questions to keep in mind:
- Does this change affect the index?
- How much time will it take to update the index?
- Will the table or index be locked during the update?

Extra Data: Index Usage in Firestore

Indices can sometimes be expensive, both in terms of resources and limits. For example, in Firestore, you are limited to 200 indices if billing is not enabled for your Google Cloud project.

If you need more indices, enabling billing increases the quota to 500 indices. This limitation means you need to be strategic and efficient with how you use your indices to avoid unnecessary costs or hitting quota limits.

End

In recent interviews I’ve participated in, I’ve noticed an increase in database-related questions. 🧐
I hope these posts help clarify some of those questions and also help you answer them in a more consistent way.

As always, if you have any questions from a previous interview that you’d like to share, feel free to let me know!🤓

Wishing you all a great week.🥰

Thank you so much!

Bye-bye!

Technical Interview Questions - Behavioral Questions

Giuliana Olmos — Thu, 05 Dec 2024 12:43:34 +0000

Introduction

Hello Everyone! 👋

I hope you’re all doing well! 😄

I know many of you are following this series for the technical questions and examples, but today, I want to dive into a different part of the interview process: behavioral questions and the STAR method.

This idea came to me after an interview I had a few weeks ago with a former Google HR. During our chat, she shared some great tips that I think could really benefit you, so I’m excited to pass them along! 💪🏼

Now, I know that some of you might think these questions are pretty simple. But for those of us who aren’t native English speakers, a little preparation can help us feel more confident.

Also, while I was applying for different positions, I noticed that more and more companies are adding behavioral questions right from the start of the process, sometimes even in the application form itself. Some call this early step an “email screening” or “chat screening.” So, I think it's really important to be prepared.

## Topics
1. What are Behavioral Questions?
2. What is the STAR Method?
3. Questions
4. Recommendations

What are Behavioral Questions?

✨Behavioral questions✨ are the questions interviewers ask to understand how you react in certain situations, how you handle challenges, and to learn more about your experience and ability to solve problems on your own.

These types of questions help the recruiter get to know you beyond your technical skills.

What are they expecting?

They expect you to answer these questions clearly and consistently. During my interview with this recruiter, one of the improvement areas she mentioned was that I sometimes answered questions without a clear structure. I also tended to spend too much time on each answer, occasionally circling back to the same points and repeating myself.

To answer these questions effectively and stay focused, one helpful approach is the 🎯STAR method.🎯

Which leads us to the next topic...

What is the STAR Method?

The STAR method gives us a simple format to structure our answers, helping us cover key details without missing anything important. The idea is to think through your answers using these four points:

S => Situation: Describe the context or background of the challenge you faced.
T => Task: Explain your role and responsibility in that situation.
A => Action: Walk through the steps you took to handle the situation.
R => Result: Share the outcomes you achieved because of those actions.

A Quick Example

Question: Tell me about a time you cooked.

S: It was my friend’s birthday, and he couldn’t host at his place.

T: My goal was to host at my house and make a good meal for everyone.

A: I looked up recipes, bought the ingredients, and spent hours cooking.

R: We had a fantastic celebration, and everyone enjoyed the evening together.

You should use this method for all your behavioral questions—it really helps you stay focused!

(And yes, you could even use STAR to write LinkedIn posts about daily goals, like cooking, washing dishes, or cleaning the bathroom... but please, don’t do that 😅 )

Now that you know the STAR method, here are some behavioral questions I strongly recommend preparing for before your next interview.

Questions

These aren’t questions I came up with or asked GPT—these are actual questions I was asked in interviews where I participated.

What is the most challenging project or feature that you developed? Explain the technical details.
Tell me about a time when you made a mistake at work and how you resolved it.
Tell me about a time when you couldn’t meet a deadline. What did you do?
Have you ever had a disagreement with someone at work? How did you handle the situation, and what strategies did you use to reach a common understanding or compromise?

Personal Note: From my experience as someone who has also interviewed candidates, if you’re in a senior position—whether as a Team Lead, Manager, or beyond—you can’t really say that you’ve “never had a disagreement.” Not having disagreements could suggest you’re not taking ownership or actively contributing to team decisions. The goal with this question is not to bring up a “bad” situation but to share a time when different perspectives were involved. Show your skills in discussing, defending your approach, and finding a shared solution.
Can you describe a situation where you had to use {{Insert company’s tech stack here}} to solve a challenge like scalability, performance, or deployment?
Tell me about a time when you had to take on a task outside your usual responsibilities. How did you approach it, and what did you learn?
Provide an example of a time when you had to work with other teams (Frontend, Backend, Product, etc.).

Recommendations

Here are my tips:

Copy these questions and write out your answers for each one using the STAR method. ⭐️
Practice answering these questions out loud. 🔊
If possible, record yourself. Personally, I find practicing in front of a mirror a bit cringy—but hey, if it works for you, go for it!
Why write out your answers?✏️
Writing them forces you to think through at least one solid response that you can use in the future. But another reason is, as I mentioned before, many companies are adding these “behavioral questions” in application forms or emails. Having your answers ready in a document will save you time.

The next time you encounter a similar question, you can use ChatGPT to refine your response instead of rewriting everything. Try a prompt like this:

"You are an expert in the STAR method, and I need help answering this question: {Add question here} using my previous answer: {Copy your answer here}. Keep it short, don’t create experience I don’t have, use the STAR method, and keep my wording as much as possible."

This approach will help you apply faster, without resorting to overly generic AI answers.

The end

I’m sorry if this post wasn’t the technical post you were expecting. I hope it’s as helpful for you as it was for me after I got that feedback from the recruiter. I’m really grateful to her for taking the time to help me improve my interview performance. 💖

Have a great week! 🫶🏻

See you next week for a technical post about interview questions!

Bye-bye.

Technical Interview Questions - Part 5 - Event Loop

Giuliana Olmos — Thu, 28 Nov 2024 12:54:45 +0000

Introduction

Hello, everybody!

Today, as the title says 😉, I’ll be talking about the event loop.

This is not a topic that interviewers often ask about directly (I can only remember two occasions when they asked me to explain the event loop). BUT, in most interviews, they ask questions that are related to it. For example:

"If I do this… what should be the behavior?"
"If my code looks like this, what will be the output?"
"Why does this code produce this output?"

All those questions are much easier to answer if you understand how the event loop works.

I'll be honest: this topic isn’t my favorite. I much prefer questions about the behavior of code rather than explaining how the event loop works for 10 minutes straight.😅

Let’s dive in! 😀

## Questions
1. What is the event loop?
2. Examples

What is the event loop?

Short Answer:

The event loop is responsible for handling asynchronous tasks in the JavaScript runtime.

To be honest, I don’t think this answer is enough to satisfy the curiosity of an interviewer asking about the event loop. So, in this post, I’d like to dive deeper into this topic.

More than just knowing the concepts, it’s important to understand how it works. That’s why I’ve added some examples at the end.

Theory

What is the Event Loop?

JavaScript has a runtime based on an event loop, which is responsible for handling tasks. Each language has a unique runtime, and an important point to note is that JavaScript is single-threaded.

What Does Single-Threaded Mean?

Single-threaded means that JavaScript can handle only one task at a time. This is why the event loop is so essential in JavaScript; it helps manage tasks efficiently despite this single-thread limitation.

Components of the Runtime

To understand the event loop better, let’s first look at its main components:

Call Stack

The call stack is a data structure that keeps track of the functions we call. You can think of it like a stack of plates: when a function is called, it’s added to the stack, and when it finishes, it’s removed from the stack.

The call stack operates on a LIFO (Last-In-First-Out) principle, meaning JavaScript executes functions in the order they’re stacked—from the topmost item down to the bottom, one at a time (remember, JavaScript is single-threaded).

Queues

In JavaScript’s runtime, we have queues, which hold lists of tasks to be processed. Tasks in these queues wait until the call stack is empty.

Task Queue (or Callback Queue): This queue stores tasks like setTimeout() and setInterval() calls. Tasks here are processed after the call stack is empty and after all tasks in the Microtask Queue have been processed. See more examples of tasks that are stored in this queue on MDN.
Microtask Queue: This queue has priority over the Task Queue. It includes microtasks such as Promise callbacks and asynchronous functions like process.nextTick() and async functions.

The Task Queue works on a FIFO (First-In-First-Out) basis, meaning tasks are processed in the order they’re added, but only after the Microtask Queue is empty.

Event Loop

The event loop is a mechanism that manages the execution of asynchronous code. It observes the call stack and coordinates between the call stack and the queues (Task Queue and Microtask Queue) to keep the code running smoothly.

How Does It Work?

Let's go through the event loop process step by step. Refer to the image below for a visual representation.

In this example:

The Call Stack has one function.
The Microtask Queue has two messages.
The Task Queue has one message.

Step 1: Process the Call Stack

The event loop starts by looking at the Call Stack.
It finds a function in the stack and begins executing it.
Once this function completes, it is removed from the Call Stack.

Step 2: Process the Microtask Queue

After the Call Stack is empty, the event loop checks the Microtask Queue.
It takes the first message from the Microtask Queue and pushes it to the Call Stack for execution.

The function runs and, once completed, is removed from the Call Stack.
The event loop then moves to the next message in the Microtask Queue and repeats the process.
This continues until there are no more messages left in the Microtask Queue.

Step 3: Process the Task Queue

Once both the Call Stack and the Microtask Queue are empty, the event loop turns to the Task Queue.
It picks the first message in the Task Queue and adds it to the Call Stack.
The function runs, and when it completes, it’s removed from the Call Stack.
The event loop will continue this process with each task in the Task Queue, ensuring all tasks are handled one by one.

By following this order—Call Stack, then Microtask Queue, and finally Task Queue—the event loop helps JavaScript handle asynchronous code efficiently, even within its single-threaded environment.

Examples

Now that we understand how the event loop works and how tasks are prioritized, let’s look at some examples.

Example 1

const a = new Promise(function showA(resolve){
  console.log('A');
  resolve('B');
});

setTimeout(function showC() {
  console.log('C');
}, 0);

a.then(function showB(b) {
  console.log(b);
});

const d = function showD() {
  console.log('D');
};

d();

Before continuing, try to think about the order of the output.

✨What do you expect it to be?✨

Let’s break down each part of the code to understand why we get this output.

1. Creating the Promise

const a = new Promise(function showA(resolve) {
  console.log('A');
  resolve('B');
});

Here, we create a new promise with a callback function.
Inside this function, console.log('A') is executed immediately, so "A" is printed to the console.
After logging "A", the promise is resolved with the value "B".
JavaScript recognizes there’s a .then callback (i.e., showB) that should run once the main call stack is clear, so it adds showB to the Microtask Queue (since promise resolutions go there).

2. setTimeout Call

setTimeout(function showC() {
  console.log('C');
}, 0);

The setTimeout function schedules showC to run after 0 milliseconds.
JavaScript places showC in the Task Queue because it’s a timer-based function.

3. a.then Callback

a.then(function showB(b) {
  console.log(b);
});

This line registers a .then handler for the promise we already resolved in the previous step (resolve('B')).
Since the promise is resolved, showB (the .then callback) is added to the Microtask Queue.

4. Defining d

const d = function showD() {
  console.log('D');
};

This line simply defines the function showD but doesn’t execute it yet, so nothing happens here.

5. Calling d()

d();

Now, we call d(), which is added to the Call Stack and executed. This results in console.log('D'), so "D" is printed to the console.

Final Output Order:

A
D
B
C

GIF for reference

Interactive Example

Example 2

console.log("Start!");

setTimeout(function showTimeout() {
  console.log("Timeout!");
}, 0);

Promise.resolve("Promise!")
  .then(function showPromise(res) {
    console.log(res);
  });

console.log("End!");

Again, take a moment to think about the order of the output.

✨What do you expect it to be?✨

Let's go with the explanation...

1. Logging "Start!"

console.log("Start!");

This line is added to the Call Stack and executed immediately.
As a result, "Start!" is printed to the console.

setTimeout Call

setTimeout(function showTimeout() {
  console.log("Timeout!");
}, 0);

The setTimeout function schedules showTimeout to run after 0 milliseconds.
JavaScript places showTimeout in the Task Queue since it’s a timer-based function.

3. Promise Resolution

Promise.resolve("Promise!")
  .then(function showPromise(res) {
    console.log(res);
  });

The promise is resolved immediately with the value "Promise!".
JavaScript places showPromise (the .then callback) in the Microtask Queue because promises go into the microtask queue after being resolved.

4. Logging "End!"

console.log("End!");

This line is added to the Call Stack and executed immediately.
As a result, "End!" is printed to the console.

Final Output Order:

Start!
End!
Promise!
Timeout!

GIF for reference

Interactive Example

End

This chapter wasn’t too long, but I hope these examples helped you understand how the event loop works.

I strongly recommend experimenting with the interactive page to analyze other examples. Playing around on that page can make it much easier to understand the event loop in action.

Thank you so much for all the love on my previous posts!

See you next week! 😄

Bye Bye

Technical Interview - Boilerplate 2 - Node + Serverless + AWS + Github Actions

Giuliana Olmos — Thu, 21 Nov 2024 13:59:26 +0000

Introduction

Hello everyone!! 🤗

I want to share another boilerplate I prepared for take-home interviews. A few weeks ago, we talked about a boilerplate with Node.js, Express, and PostgreSQL.✨Today’s boilerplate is a bit different. This time, I’m using Node.js, Express, TypeScript, and a NoSQL database✨. Everything will be deployable on AWS using Lambda and DynamoDB through the Serverless Framework. I’ll also touch on setting up GitHub Actions for CI/CD.

This boilerplate is different because it allows interviewers to run live tests. We can use AWS’s free tier, which makes it cheaper than using a server and SQL database like before. Plus, it gives us a chance to show some real-world deployment experience. 🤓

The main idea is to create a serverless CRUD connected to a NoSQL database.

If you create both boilerplates, you’ll be able to handle about 90% of the take-home assignments companies usually ask for. You’ll be ready for projects that need either an SQL or NoSQL database.

You’ll also have examples that show you can work with autoscaling services, microservices, or even monolithic apps.

If I come across another take-home with a different approach, and it’s something that can be reused, I’ll create another boilerplate and share it in this post.

Now, let’s get into the project!

Like in the last boilerplate, I won’t explain every step to build it. I’ll just talk about some important points.

Topics

Before to start…
Serverless.yml
DynamoDB and Dynamoose
Lambdas
Tests
Github Actions
Final Steps
The End

Before to start…:

What is ✨Serverless✨? And is it the same as the ✨Serverless Framework✨?

Serverless is a cloud computing model where the cloud provider automatically manages the infrastructure and scales applications as needed. This allows you to focus on writing code, while the cloud provider handles server provisioning, scaling, and management. In other words, you don’t need to worry about DevOps or managing the infrastructure.

However, Serverless is not the same as the Serverless Framework.

The Serverless Framework is a specific tool that helps developers build and deploy serverless applications across different cloud platforms. In my case, I will be deploying to AWS, as it’s the platform I have the most experience with. Google Cloud Platform (GCP) is also a good option.

To work with AWS and the Serverless Framework, you’ll need to:

Set up your AWS credentials on your computer.
Install the Serverless Framework globally by running:

npm i serverless -g

Serverless.yml:

Serverless Framework v4 allows us to define all the infrastructure in the serverless.yml file.

Mine looks something like this:

app: boilerplateservelesslambadadynamo
service: boilerplate-serverless-Lambda-Dynamo

provider:
  name: aws
  runtime: nodejs18.x
  region: us-east-1
  iamRoleStatements:
    - Effect: Allow
      Action:
        - dynamodb:CreateTable
        - dynamodb:DescribeTable
        - dynamodb:PutItem
        - dynamodb:UpdateItem
        - dynamodb:DeleteItem
        - dynamodb:GetItem
        - dynamodb:Scan
        - dynamodb:Query
      Resource: "arn:aws:dynamodb:${self:provider.region}:*:table/${self:provider.environment.TABLE_NAME}"
  environment:
    TABLE_NAME: Users

package:
  individually: true

functions:
  createUser:
    handler: src/lambdas/createUser.handler
    events:
      - http:
          path: /users/create
          method: post
          cors: true

  getUsers:
    handler: src/lambdas/getUsers.handler
    events:
      - http:
          path: /users/getUsers
          method: get
          cors: true

  deleteUser:
    handler: src/lambdas/deleteUser.handler
    events:
      - http:
          path: /users/deleteUser
          method: delete
          cors: true

  updateUser:
    handler: src/lambdas/updateUser.handler
    events:
      - http:
          path: /users/updateUser
          method: put
          cors: true

  createUsersTransaction:
    handler: src/lambdas/createUsersTransaction.handler
    events:
      - http:
          path: /users/createUsersTransaction
          method: post
          cors: true

resources:
  Resources:
    UsersTable:
      Type: AWS::DynamoDB::Table
      Properties:
        TableName: Users
        AttributeDefinitions:
          - AttributeName: userId
            AttributeType: S
        KeySchema:
          - AttributeName: userId
            KeyType: HASH
        BillingMode: PAY_PER_REQUEST

plugins:
  - serverless-offline

Provider:

The provider section defines the cloud platform and configurations for deploying your serverless application.

Package: Individually: true :

I set this configuration to package and deploy each Lambda function individually, rather than bundling them all together. This is useful because it reduces deployment times and improves performance by packaging only the relevant code for each function.

Functions:

In this section, we define each Lambda function, the handler we will use, and the event that triggers the Lambda. Since this is an HTTP CRUD application, the Lambdas will be triggered by HTTP calls.
Make sure to enable CORS, otherwise, you might run into issues when consuming the endpoints from a frontend.

Resources:

The resources section is used to define additional AWS CloudFormation resources that the Serverless Framework doesn't natively support. In my case, I declared a DynamoDB table with userId as the key. You can also declare other resources like S3 buckets, SQS queues, and more if needed.

Plugins:

At the end, there's a list of plugins you can install. In my case, I installed a plugin to test my Lambdas locally without needing to redeploy them after every code change.

DynamoDB and Dynamoose:

To be honest, when I code take-home projects from scratch, I don’t include too many extra packages because it means spending more time on the project. However, since I had time to prepare a nice boilerplate, I decided to use ✨Dynamoose✨.

Why Dynamoose?

Working directly with DynamoDB can be a nightmare. It has one of the worst documentations I’ve ever read — and I’ve worked with the App Store Connect API documentation before! 🤣

Dynamoose is based on Mongoose, so it offers a similar experience but for DynamoDB. It helps us work faster and more clearly with the database.

Example Schema

For this example, I created a very simple schema for a user. This schema is then used in a controller to handle all the actions for the Lambdas.

import * as dynamoose from "dynamoose";

const UserSchema = new dynamoose.Schema({
  userId: {
    type: String,
    hashKey: true,
  },
  name: String,
  email: String,
});

export const User = dynamoose.model(process.env.TABLE_NAME!, UserSchema);

Transactions

As I mentioned earlier, I’ve included an example of transactions. Sometimes it may be necessary to implement a transaction in a take-home project, and I don’t want to waste too much time learning how to implement it during the process.

 //https://dynamoosejs.com/guide/Transaction
  async createUsersByTransaction(usersData: { name: string; email: string }[]) {
    try {
      const transactionItems = usersData.map((userData) => {
        return User.transaction.create({
          userId: uuidv4(),
          ...userData,
        });
      });

      await dynamoose.transaction(transactionItems);
    } catch (error) {
      throw new Error(`Failed to create Users by transaction ${error}`);
    }
  }

Lambdas:

The Lambdas are written in TypeScript. Luckily, Serverless Framework version 4 builds TypeScript automatically. If you're using an older version of Serverless, you may need to install:

npm i --save-dev serverless-plugin-typescript

Then, you’ll need to add it as a plugin:

plugins:
  - serverless-plugin-typescript

Here’s what my Lambda function to create a user looks like:

import { APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";
import { UserController } from "../controller/userController";

export const handler = async (
  event: APIGatewayProxyEvent
): Promise<APIGatewayProxyResult> => {
  const userData = JSON.parse(event.body || "{}");
  try {
    const userCtrl = new UserController();
    const response = await userCtrl.createUser(userData);
    console.log("User created:", response);
    console.log({ userData });
    return {
      statusCode: 200,
      body: JSON.stringify({ message: `User created`, response }),
    };
  } catch (error) {
    console.error("Error creating User:", error);
    return {
      statusCode: 500,
      body: JSON.stringify({ message: "Failed to create User" }),
    };
  }
};

After putting all the logic into my controllers, everything looks pretty much the same for each Lambda. 😅

Important Tip
Remember to export the handler, otherwise, when you reference it in serverless.yml, it won’t be able to find the module.

createUser:
   handler: src/lambdas/createUser.handler
   events:
     - http:
         path: /users/create
         method: post
         cors: true

Extra Info
If you're interested, I also have an example from a technical challenge where I had to deliver an app deployed in AWS with both a frontend and backend.

For the frontend, I used AWS Amplify: LoanPro Frontend - React.

For the backend, I used the Serverless Framework: LoanPro Backend - Serverless.

Tests:

One thing I've noticed a lot in take-home projects (since I used to review them) is that many people don’t add tests to their code. I understand that sometimes we don’t have enough time, so we focus more on the business logic. BUT, a good project is one that already has tests.

It's not necessary to work with TDD, but the code should still have tests.

It's also important to know how to mock services. Having this experience will help you in future take-home projects. If you take the time to write tests and mock services now, the next time you’ll be able to code them much faster.

For this project, I tested my code using Jest (mainly because I've used Jest throughout my experience).

Github Actions:

I wanted to try GitHub Actions to automate my deployments, so I took advantage of GitHub’s free tier to deploy this project.

For this type of deployment, where GitHub doesn’t need to host a frontend and you only use Actions, the free tier offers around 2,000 minutes per month.

In this project, each deploy takes about 1 minute.

This is my .github/workflows/main.yml file.

# Documentation: https://docs.github.com/en/actions/writing-workflows/workflow-syntax-for-github-actions
name: Deploy to AWS using Serverless Framework

on:
  release:
    types: [created]

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout the repository
        uses: actions/checkout@v2

      - name: Setup Node.js
        uses: actions/setup-node@v2
        with:
          node-version: "18"

      - name: Install dependencies
        run: npm install

      - name: Build TypeScript code
        run: npm run build

      - name: Deploy with Serverless
        run: npx serverless deploy
        env:
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          SERVERLESS_ACCESS_KEY: ${{ secrets.SERVERLESS_ACCESS_KEY }}

I set it to run every time I create a release. I recommend this option instead of deploying with every commit because, if you can deploy manually or test offline, it won’t be necessary to use up your free tier minutes unnecessarily.

An important point is that, for this automatic deployment, you only need to set some credentials.

AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
SERVERLESS_ACCESS_KEY: ${{ secrets.SERVERLESS_ACCESS_KEY }}

You set these credentials directly in the same GitHub repository. To do this, navigate to Settings > Secrets and variables > Actions in your GitHub repository to add the necessary secrets.

Final Steps:

This boilerplate is configured to be deployed either using GitHub Actions or manually via the console.

For GitHub Actions, as I mentioned before, you can trigger the deployment by creating a release.

Manual Deployment

If you prefer to deploy it manually without using CI/CD, you'll need to set up your AWS credentials on your computer and install the Serverless Framework (as I mentioned earlier).

Once that’s done, just run the following commands:

npm i
npm run build

Then, deploy your stack with:

serverless deploy

This will deploy the entire stack of your project, and you'll get the exposed endpoints for each Lambda function in return.

Running Locally

After the first deployment, if you don't want to redeploy every time you test a function, I’ve also installed a plugin in the serverless.yml file to run the Lambdas locally. This exposes the endpoints at localhost:3000.

To run locally, just follow these steps:

npm i
npm run build
serverless offline

This will expose the endpoints and allow you to monitor your logs directly in the project console.

Sharing Your Live Code

Deploying your project allows you to send a Postman collection to your interviewers so they can interact with your live code. This way, they won’t need to run the server on their machines. Just remember to delete the stack afterward to avoid any malicious use of your project.

Why Not Docker?

I chose not to use Docker for this project to avoid unnecessary complexity. When using the Serverless Framework and the AWS free tier, Docker isn’t needed. You can always add Docker if you want, but it’s not necessary.

In my experience working in FinTech, we used this setup for the entire serverless architecture, and the absence of Docker was never an issue.

The End:

I really hope this boilerplate and the explanation are useful to you in your job search. 🫶🏻

I’ll leave the link to my repo below: https://github.com/GiulianaEOlmos/boilerplate-node-lambdas-dynamodb

You are free to clone and use it for your take-home projects if you want, and if you receive any feedback about it, I would love to hear it! BUT, as I mentioned in the previous boilerplate, you should still try to create your own. It’s a great way to learn how to configure Serverless and GitHub Actions, and you'll be able to explain it confidently if an interviewer asks about it.

This time, I added a lot of extra comments from my previous experiences, and I hope those were helpful to you as well.

See you next week, and I wish everyone the best of luck in their job search! We’ll get that dream job! 💖

Bye bye!

Technical Interview Questions - Part 4 - Git + SQL vs noSQL

Giuliana Olmos — Thu, 14 Nov 2024 13:45:39 +0000

Introduction

Hello!!
I hope you’re doing well. 🫶🏻

In this post, I’ll talk about two different topics, because I didn’t want to write a post with just ONE question. These aren’t common interview questions, but I had to answer them in two separate situations. Since they were so unusual, I didn’t respond as well as I could have.

So, I want to help you by sharing some points that, in my case, the interviewers expected me to mention.

## Questions
1. Difference between Git Merge and Git Rebase
2. What are the differences between SQL and NoSQL databases?

Question 1: Difference between Git Merge and Git Rebase

The short answer:

Both Git rebase and Git merge are ways to integrate changes from one Git branch into another, but they work differently.

Git rebase: Rewrites the commit history of the original branch.

Git merge: Creates a new commit that combines both branches.

...

GIT REBASE

Git rebase integrates changes from one branch into a new base branch by replaying all the commits from the old branch onto the new one.

This command rewrites the commit history of the original branch and creates a new branch by applying the same set of commits on top of the target branch.

Syntax:

git rebase <base>

When should you use it?

When you want to incorporate changes from a feature branch into the main branch.
When you don’t need to track individual commits from the feature branch (because all commits will be rewritten and added on top of the target branch).

...

GIT MERGE

Git merge allows you to merge changes from two different branches into one, usually the main branch. In this process, Git creates a new commit to combine the changes.

git merge <branch>

When should you use it?

When you want to incorporate changes from one branch into another without losing the commit history.
When you know you'll need to check your past commits.
When you're working with another developer and want to keep the full commit history intact.

Question 2: What are the differences between SQL and NoSQL databases?

Answer:

SQL uses structured data, while noSQL does not.

SQL scales vertically, whereas noSQL scales horizontally.

In some situations, noSQL can be faster than SQL.

I want to dive more into these points.

SQL databases contain structured data and relationships that are handled using variables and keys. On the other hand, noSQL databases handle unstructured data with dynamic schemas, and they are not designed to handle complex relationships.

Scalability

SQL scales better vertically (Scale Up). This means that to handle more data or higher workloads, you need to increase the computational power of a single server (e.g., by adding more CPU, RAM, or storage).
noSQL, however, scales better horizontally (Scale Out). Instead of upgrading a single machine, you add more servers to handle increasing loads.

Is noSQL faster than SQL?
In some cases, noSQL can be faster than SQL because it is schema-less and doesn’t need to follow ACID properties. Since there’s no need to validate schemas, data writing and retrieval can be faster. Additionally, noSQL often uses denormalized data, meaning there is less need for JOIN operations, which are among the most performance-heavy operations in SQL.

However, SQL is generally more efficient when working with:

transactional systems,
complex queries, and
situations where strict data consistency and structure are required.

Farewell & Thoughts

I hope these explanations help you in your interviews.

If you have any interview questions you'd like me to answer, or if you want to share your experience, I'd love to hear about it.

See you in the next post!

Technical Interview Questions - Part 3 - SQL

Giuliana Olmos — Thu, 07 Nov 2024 13:57:28 +0000

Introduction

Hi everyone! 🤗
I’m back with a new set of SQL questions. They aren't too complicated (I think), but I've often struggled to explain them clearly 🥹. I could give examples from my own use, but I couldn't always find the right words to describe them.

I'll keep this intro short, so let's dive into the questions! 🤓

## Questions
1. What is a key in SQL, and what types do you know?
2. What is a subquery?
3. What is a transaction in SQL??

Question 1: What is a key in SQL, and what types do you know?

The short answer is...

A key is a set of attributes that we use to identify a specific row in a table or to create relationships between tables.

There are different types of keys:

Primary Key

Candidate Key

Super Key

Alternate Key

Unique Key

Composite Key

Foreign Key

...

Primary Key

A primary key is the key to uniquely identifying each row (record) in a table.

A table can have only one primary key.
Can be made up of one or more columns.
Cannot be NULL.
Cannot be duplicated.

Table students

In this example, StudentID is the primary key. Each student has only one StudentID.

...

Candidate key

A candidate key is a set of columns that can uniquely identify each row in a table. A table can have multiple candidate keys, but only one will be chosen as the primary key. A candidate key must be minimal and cannot include extra columns.

Table vehicles

VIN and LicensePlate are the candidate keys for this table because both can uniquely identify a vehicle.

...

Super Key

A super key is a set of columns that can uniquely identify records in a table.

All candidate keys are super keys, but not all super keys are candidate keys because super keys may include columns that are not necessary for uniqueness.

Table employees

{EmployeeID, Email} and {EmployeeID, Email, PhoneNumber} are Super Keys because the combination of those columns can uniquely identify each record.

...

Alternate Key

When a primary key is selected, any remaining key becomes an alternate key.

Table Authors

Primary Key => AuthorID
Alternate Key => SSN (Since it can also uniquely identify a record but is not chosen as the Primary Key).

...

Unique Key

It also uniquely identifies records BUT allows NULL values.

Table employees

Primary Key => EmployeeID (Unique for each employee).
Unique Key => Email (Each email is unique).

...

Composite Key

These keys are made up of two or more columns that uniquely identify a record.

Table CourseEnrollments

The composite key is {StudentID, CourseID} because a student can enroll in multiple courses, but this combination is unique.

...

Foreign Key

A foreign key is used to set relationships between tables. It ensures referential integrity between tables, helping to avoid duplicate data.

For this example, I need two tables:

Table orders

Table customers

The primary keys are OrderID for the Orders table and CustomerID for the Customers table.

The foreign key in Orders: CustomerID (References CustomerID in Customers).

Question 2: What is a subquery?

Answer:

A subquery is a query that appears inside another query statement. It’s also called an inner query or nested query. It’s used to perform a query that returns data to be used by the “outer” query.

An example:
If I have two tables...

Table Employees

And the table Departments

If I want to find the names of employees in the HR department. The query I should write looks like this:

SELECT Name
FROM Employees
WHERE DepartmentID = (
    SELECT DepartmentID
    FROM Departments
    WHERE DepartmentName = 'HR'
);

Where the inner query is

SELECT DepartmentID
    FROM Departments
    WHERE DepartmentName = 'HR'

And the outer query is

SELECT Name
FROM Employees
WHERE DepartmentID = 10;

Question 3: What is a transaction in SQL?

Answer:

A transaction is a sequence of one or more SQL operations that run as a single execution.

It’s used to maintain the integrity of the database and to ensure that changes aren't applied until all queries are fully completed without errors. Otherwise, the transaction will rollback any changes.

What is `ACID`?

ACID represents the key properties of transactions:

A for Atomicity: The transaction should be completed successfully or unsuccessfully, but not by parts. If any part fails, the transaction must rollback.
C for Consistency: The transaction ensures data integrity. If any query in the transaction tries to violate a constraint, the entire transaction will fail, preventing changes in the database.
I for Isolation: Ensures that transactions do not interfere with each other, even when executed simultaneously.
D for Durability: Ensures the transaction is committed. Its change is permanently stored even in the event of a system failure.

Transactions are widely used in Fintech. For example, when working with clients' bank accounts, we use transactions to ensure the integrity of the database.

Example:

Suppose we want to transfer 100 currency units from Account 1 to Account 2. This requires two operations:

1 - Deduct 100 from Account 1's balance.
2 - Add 100 to Account 2's balance.

Here’s how our transaction query would look:

BEGIN;

UPDATE Accounts
SET Balance = Balance - 100
WHERE AccountID = 1;

UPDATE Accounts
SET Balance = Balance + 100
WHERE AccountID = 2;

COMMIT;

BEGIN starts the transaction
UPDATES modifies the balances of the accounts.
COMMIT finalizes the transaction and saves the changes, making them permanent in the database.

If any part of this process fails, we can use:

ROLLBACK to undo all changes, ensuring that the database remains consistent.

Farewell & Thoughts

That's all for this post!

It’s a bit short, but I included as many examples as possible to make things easy to understand. 🫶🏻
As I always say, if you have other questions you’d like me to cover, just let me know!

See you in the next post, and have a great week!

Technical Interview - Boilerplate 1 - Node + Typescript + PostgreSQL

Giuliana Olmos — Thu, 31 Oct 2024 13:42:37 +0000

Introduction

Hi! Hello! 🤗

You might have been expecting another post about technical interview questions (don’t worry, I’ll share more of those soon!). But today, I want to talk a bit about my experience with interviews and share some tips that worked for me.

I’ve been doing interviews for a few months now, mostly for Senior Backend Developer roles. If I had the chance, I aimed for positions as a Founding Backend Engineer. In many of these interviews, I was given take-home assignments. If not, they usually asked me to build a project from scratch—covering things like deployment, CI/CD, architecture, servers, databases, etc.

That’s why I decided to write this post.

After doing several interviews, I realized that the tasks and questions tend to repeat. That’s when I knew I needed to find a way to improve my process.

For me, creating reusable boilerplates was a game-changer. Having a solid base to start with helped me focus on the important parts, like the business logic, rather than starting from scratch each time.

In this post, I’ll talk about one of the first boilerplates I made—a template for projects that require a ✨server✨(using TypeScript, Node.js, and Express) and a ✨relational database✨(PostgreSQL).

I won’t share all the code here, but I’ll show you some key parts and explain why I included them.

To use this boilerplate, you’ll need to have

Node.js,
PostgreSQL
and Docker,

installed.

## Topics
* Server
* Database
* Docker
* Docker Compose
* How to run the project?
* How to stop the project?
* Tests

Server:

The project in the boilerplate is really simple—just a basic CRUD. The idea is to have a base to start working from.

Initialize the project using NodeJs, Typescript, and Express.

npm init -y

And then install some dependencies.

npm install express 
npm install --save-dev typescript ts-node @types/node @types/express

My tsconfig.ts looks like this.

 "compilerOptions": {
   "target": "ES2020",
   "module": "commonjs",
   "strict": true,
   "esModuleInterop": true,
   "skipLibCheck": true,
   "forceConsistentCasingInFileNames": true,
   "outDir": "./dist"
 },
 "include": ["src/**/*"],
 "exclude": ["node_modules"]
}

I created some basic endpoints as examples of each type. The routes are located in user.routes.ts.

import { Router } from "express";
import UserController from "../controllers/userController";


const userRoutes = Router();
const userController = new UserController();


userRoutes.get("/users", userController.getIndex);
userRoutes.post("/users", userController.createUser);
userRoutes.post("/usersTransaction", userController.createUserTransaction);
userRoutes.get("/users/:id", userController.getUserById);
userRoutes.put("/users/:id", userController.updateUser);
userRoutes.delete("/users/:id", userController.deleteUser);


export default userRoutes;

I also added userRoutes.post("/usersTransaction", userController.createUserTransaction); to include an example of a transaction using PostgreSQL.

Until now, I've never had to use a transaction query in a take-home project 🥹, but I think it's a good idea to have it implemented in this boilerplate in case I need it in the future. 🤓

Database:

For this boilerplate, I decided to use ✨PostgreSQL✨ instead of MySQL. The reason is that most of the positions I apply for expect experience with PostgreSQL.

I installed it using:

npm install pg

And created a pool in db.ts.

import { Pool } from "pg";

const pool = new Pool({
  user: "myuser",
  host: "db",
  database: "mydb",
  password: "mypassword",
  port: 5432,
});

export default pool;

The data for my local database is set in my docker-compose.yml file.

A good practice (especially if you plan to deploy this) is to store all the connection details in an .env file.

Once the database connection was set up, I completed the controllers with some queries. I created a CRUD with a few actions to provide examples of each query type.

To avoid spending too much time researching later, I included a link to the PostgreSQL query documentation as a "cheat sheet" in the boilerplate for future reference.

// https://node-postgres.com/features/queries
class UserController {
  public async getIndex(req: Request, res: Response): Promise<void> {
    try {
      const result = await pool.query("SELECT * FROM users");

      console.log({ result: JSON.stringify(result) });

      res.status(200).json(result.rows);
    } catch (error) {
      console.error(error);
      res.status(500).json({ error: (error as Error).message });
    }
  }
}

I also implemented a transaction and linked to the relevant documentation. While a transaction isn't necessary for this particular case, I wanted to include everything I might need in a take-home project to save time in the future. It also helped me understand how transactions work and what additional code is required.

For example, in this case, you need to create a "client" for the transaction where you can perform actions like BEGIN, COMMIT, and ROLLBACK.

The documentation states:

You must use the same client instance for all statements within a transaction. PostgreSQL isolates a transaction to individual clients. This means if you initialize or use transactions with the pool.query method, you will encounter problems. Do not use transactions with the pool.query method.

 //https://node-postgres.com/features/transactions
  public async createUserTransaction(
    req: Request,
    res: Response
  ): Promise<void> {
    const client = await pool.connect();

    try {
      await client.query("BEGIN");
      const users = req.body.users;
      const promises: Promise<QueryResult<any>>[] = [];
      for (const user of users) {
        const { name, email } = user;
        promises.push(
          client.query("INSERT INTO users (name, email) VALUES ($1, $2)", [
            name,
            email,
          ])
        );
      }

      await Promise.all(promises);

      await client.query("COMMIT");
      res.status(200).json({ message: "Users added successfully" });
    } catch (error) {
      console.error(error);
      await client.query("ROLLBACK");
      res.status(500).json({ error: (error as Error).message });
    }
  }

Docker:

I wanted to provide the option to run the server project locally. Sometimes, take-home projects don’t require a database. In those cases, you can remove the unnecessary code and simply run the server using Docker.

Here’s what my Dockerfile looks like:

FROM node:18-alpine 

WORKDIR /usr/src/app

COPY package*.json ./

RUN npm install

COPY . .

RUN npm run build

EXPOSE 3000

CMD ["npm", "run", "serve"]

Here’s how my Dockerfile is set up:

FROM node:18-alpine — This is the base image I’m using.
WORKDIR /usr/src/app — It sets the working directory inside the container.
COPY package*.json ./ — Copies package.json and package-lock.json into the working directory.
RUN npm install — Installs the necessary dependencies.
COPY . . — Copies the rest of the application code. (Make sure to use two dots! I once used just one and spent a while figuring out how to fix it 😅)
RUN npm run build — Builds the TypeScript code.
EXPOSE 3000 — Exposes port 3000 so the app can be accessed.
CMD ["npm", "run", "serve"] — This runs the app. (This line comes from your package.json file.)

"scripts": {
   "start": "ts-node src/index.ts",
   "build": "tsc",
   "serve": "node dist/index.js",
 },

Docker Compose:

Docker Compose will be your best ally if your take-home project requires a server and a database.

Why? 🤓☝️
Docker Compose allows you to run your server and database locally and ensures they are connected to each other.

I think this is a good approach when a take-home project requires both a server and a relational database. Hosting this kind of application live can be expensive, especially since relational databases (which usually come with costs on most cloud services) are involved. And for a take-home project, I don't recommend spending money to keep them live.

Been there, done that 😅

So, using Docker Compose is a great option to run the entire project on your computer, and it's also really easy to set up.

My docker-compose.yml

version: '3'

services:
  db:
    image: postgres:15
    environment:
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword
      POSTGRES_DB: mydb
    ports:
      - "5433:5432"
    volumes:
      - db-data:/var/lib/postgresql/data
      - ./sql:/docker-entrypoint-initdb.d
    container_name: my_postgres_db

  app:
    build:
      context: .
    environment:
      DATABASE_URL: postgres://myuser:mypassword@db:5432/mydb
    ports:
      - "3000:3000"
    depends_on:
      - db
    container_name: my_express_app

volumes:
  db-data:

I set up two services in my docker-compose.yml file:

Database (db): In the environment section, I set the necessary data to connect to my database. To avoid exposing sensitive information, you can use a .env file.
Server: This service is built using my existing Dockerfile and connects to the database that I defined in the same Docker Compose setup.

Here are some common questions I want to address:

1. If I have a docker-compose, do I still need a Dockerfile?

Yes, you still need a Dockerfile if you are building a custom image for your application in a multi-service setup like with Docker Compose. The Dockerfile defines how to build the image for your Node.js app, while docker-compose.yml orchestrates how the services (like your Node.js app and PostgreSQL) run together.

For example, when you write:

build:
  context: .

That means that you are using the Dockerfile from the current directory to build the server.

2. I run my docker-compose, and the container is created with random and funny names. Hoy I could change that?

Sometimes, when you're creating your docker-compose file from a template, you might forget to set a name for your containers. This will result in Docker assigning random, funny names like “beautiful_rainbow_container.”

To avoid this and be more specific, don’t forget to set a proper name for your service using the container_name option like this:

container_name: my_postgres_db

This way, your container will have a meaningful and predictable name.

3. I need to start my database with data already inserted. How can I do that?

If your take-home project needs to be tested with pre-existing data, you’ll need to create a database that already contains this data from the start. To achieve this, you can run a script to insert the data during the Docker Compose build, every time you set the volume for your database.

Here’s how to do it:

In the volumes section of your database service, add the following lines:

volumes:
  - db-data:/var/lib/postgresql/data
  - ./sql:/docker-entrypoint-initdb.d

The first line defines the volume for your database: db-data:/var/lib/postgresql/data.
The second line mounts a local directory (./sql) to the container’s initialization script directory (/docker-entrypoint-initdb.d).

This setup ensures that when you run docker-compose, it will look for the sql folder and execute all the scripts inside.

To ensure everything runs in the correct order, make sure your SQL scripts are sorted properly. For example, you might have:

This process ensures that your database is populated with the necessary data when the container is built.

4. If I stop (down) the project, will I lose my data?

No, you won’t lose your data. All the data is stored in the volume called db-data, which is declared in the docker-compose.yml file. So, even if you stop the project (docker-compose down), the data you’ve been working on will remain intact unless you manually delete the volume.

When you run docker-compose up again, the database will be restored from that volume.

How to run the project?

To build and run the entire project locally, you can use the following command:

docker-compose up

This command starts and runs all the services defined in your docker-compose.yml file. It also sets up the necessary containers, networks, and volumes. If the images haven’t been built, it will automatically build them before starting the containers. This command ensures that your entire project is up and running.

How to stop the project?

If you want to stop the Docker Compose services, you have two options:

docker-compose down — This stops and removes the containers but keeps the volumes, so your data remains intact.
docker-compose down -v — This stops the containers and removes all named volumes declared in the docker-compose.yml file. Be careful with this option, as it will delete any data stored in those volumes.

Tests

To test this project, I use ✨Jest✨. I've set up a simple test suite to test the CRUD functionality. It’s not complicated, but it's a solid base for my boilerplate.

Install the testing framework:

npm install --save-dev jest ts-jest @types/jest

Set up the configuration:

npx ts-jest config:init

This will create the jest.config.js file for you.

/** @type {import('ts-jest').JestConfigWithTsJest} **/
module.exports = {
  testEnvironment: "node",
  transform: {
    "^.+.tsx?$": ["ts-jest",{}],
  },
};

Write your tests, add a line in scripts in package.json

"test": "jest"

And then, run:

npm i
npm run test

The end

Now that you have a boilerplate, the next time you need to complete a take-home project, all you need to do is clone the repo, rename it, and start working on your solutioN. ✨No need to worry about the initial configuration!✨

I haven’t included all the code in this post, so if you want to check it out, here’s the repo:

https://github.com/GiulianaEOlmos/boilerplate-node-express-postgresql

Feel free to use it for your interviews, but I encourage you to create your own boilerplate with all the things you think you’ll need. That way, you’ll learn how to set it up and be ready to explain everything to your interviewers.

I hope this post was helpful to everyone. If you have any suggestions or improvements, please let me know in the comments.

And if any part of this post helped you in your job search, I’d love to hear about it!

Thank you so much, and have a great week!

Technical Interview Questions - Part 2 - Typescript

Giuliana Olmos — Thu, 24 Oct 2024 13:32:20 +0000

Introduction

Hello, hello!! :D

Hope you’re all doing well!

How we’re really feeling:

I’m back with the second part of this series. 🤓

In this chapter, we’ll dive into the ✨Typescript✨ questions I’ve faced during interviews.

I’ll keep the intro short, so let’s jump right in!

## Questions
1. What are generics in typescript? What is <T>?
2. What are the differences between interfaces and types?
3. What are the differences between any, null, unknown, and never?

Question 1: What are generics in typescript? What is `<T>`?

The short answer is...

Generics in TypeScript allow us to create reusable functions, classes, and interfaces that can work with a variety of types, without having to specify a particular one. This helps to avoid using any as a catch-all type.

The syntax <T> is used to declare a generic type, but you could also use <V>, <M>, or any other placeholder.

How does it work?

Let’s break it down with an example.

Suppose I have a function that accepts a parameter and returns an element of the same type. If I write that function with a specific type, it would look like this:

function returnElement(element: string): string {
 return element;
}


const stringData = returnElement("Hello world");

I know the type of stringData will be “string” because I declared it.

But what happens if I want to return a different type?

const numberData = returnElement(5);

I will receive an error message because the type differs from what was declared.

The solution could be to create a new function to return a number type.

function returnNumber(element: number): number {
 return element;
}

That approach would work, but it could lead to duplicated code.

A common mistake to avoid this is using any instead of a declared type, but that defeats the purpose of type safety.

function returnElement2(element: any): any {
 return element;
}

However, using any causes us to lose the type safety and error detection feature that Typescript has.
Also, if you start using any whenever you need to avoid duplicate code, your code will lose maintainability.

This is precisely when it’s beneficial to use generics.

function returnGenericElement<T>(element: T): T {
 return element;
}

The function will receive an element of a specific type; that type will replace the generic and remain so throughout the runtime.

This approach enables us to eliminate duplicated code while preserving type safety.

const stringData2 = returnGenericElement("Hello world");


const numberData2 = returnGenericElement(5);

But what if I need a specific function that comes from an array?

We could declare the generic as an array and write it like this:

function returnLength<T>(element: T[]): number {
 return element.length;
}

Then,

const stringLength = returnLength(["Hello", "world"]);

The declared types will be replaced by the type provided as a parameter.

We can also use generics in classes.

class Addition<U> {
 add: (x: U, y: U) => U;
}

I have three points to make about this code:

add is an anonymous arrow function (which I discussed in the first chapter).
The generic can be named <U>, <T>, or even <Banana>, if you prefer.
Since we haven't specified the type yet, we can't implement operations inside the classes. Therefore, we need to instantiate the class by declaring the type of the generic and then implement the function.

Here’s how it looks:

const operation = new Addition<number>();


operation.add = (x, y) => x + y; => We implement the function here


console.log(operation.add(5, 6)); // 11

And, one last thing to add before ending this question.
Remember that generics are a feature of Typescript. That means the generics will be erased when we compile it into Javascript.

From

function returnGenericElement<T>(element: T): T {
 return element;
}

function returnGenericElement(element) {
 return element;
}

Question 2: What are the differences between interfaces and types?

The short answer is:

Declaration merging works with interfaces but not with types.

You cannot use implements in a class with union types.

You cannot use extends with an interface using union types.

Regarding the first point, what do I mean by declaration merging?

Let me show you:
I’ve defined the same interface twice while using it in a class. The class will then incorporate the properties declared in both definitions.

interface CatInterface {
 name: string;
 age: number;
}


interface CatInterface {
 color: string;
}


const cat: CatInterface = {
 name: "Tom",
 age: 5,
 color: "Black",
};

This does not occur with types. If we attempt to define a type more than once, TypeScript will throw an error.

type dog = {
 name: string;
 age: number;
};


type dog = { // Duplicate identifier 'dog'.ts(2300)
 color: string;
};


const dog1: dog = {
 name: "Tom",
 age: 5,
 color: "Black", //Object literal may only specify known properties, and 'color' does not exist in type 'dog'.ts(2353)
};

Regarding the following points, let’s differentiate between union and intersection types:

Union types allow us to specify that a value can be one of several types. This is useful when a variable can hold multiple types.

Intersection types allow us to combine types into one. It is defined using the & operator.

type cat = {
 name: string;
 age: number;
};


type dog = {
 name: string;
 age: number;
 breed: string;
};

Union type:

type animal = cat | dog;

Intersection type:

type intersectionAnimal = cat & dog;

If we attempt to use the implements keyword with a union type, such as Animal, TypeScript will throw an error. This is because implements expects a single interface or type, rather than a union type.

class pet implements animal{
   name: string;
   age: number;
   breed: string;
   constructor(name: string, age: number, breed: string){
       this.name = name;
       this.age = age;
       this.breed = breed;
   }
}

Typescript allows us to use “implements” with:

a. Intersection types

class pet2 implements intersectionAnimal {
 name: string;
 age: number;
 color: string;
 breed: string;
 constructor(name: string, age: number, color: string, breed: string) {
   this.name = name;
   this.age = age;
   this.color = color;
   this.breed = breed;
 }
}

b. Interfaces

interface CatInterface {
 name: string;
 age: number;
 color: string;
}

class pet3 implements CatInterface {
 name: string;
 age: number;
 color: string;
 constructor(name: string, age: number, color: string) {
   this.name = name;
   this.age = age;
   this.color = color;
 }
}

c. Single Type.

class pet4 implements cat {
 name: string;
 age: number;
 color: string;
 constructor(name: string, age: number, color: string) {
   this.name = name;
   this.age = age;
   this.color = color;
 }
}

The same issue occurs when we try to use extends with a union type. TypeScript will throw an error because an interface cannot extend a union type. Here’s an example

interface petUnionType extends animal {
 name: string;
 age: number;
 breed: string;
}

You cannot extend a union type because it represents multiple possible types, and it's unclear which type's properties should be inherited.

BUT you can extend a type or an interface.

interface petIntersectionType extends intersectionAnimal {
 name: string;
 age: number;
 color: string;
 breed: string;
}


interface petCatInterface extends CatInterface {
 name: string;
 age: number;
 color: string;
}

Also, you can extend a single type.

interface petCatType extends cat {
   name: string;
   age: number;
   color: string;
   }

Question 3: What are the differences between `any`, `null`, `unknown`, and `never`?

Short answer:

Any => It’s a top-type variable (also called universal type or universal supertype). When we use any in a variable, the variable could hold any type. It's typically used when the specific type of a variable is unknown or expected to change. However, using any is not considered a best practice; it’s recommended to use generics instead.

let anyVariable: any;

While any allows for operations like calling methods, the TypeScript compiler won’t catch errors at this stage. For instance:

anyVariable.trim();
anyVariable.length;

You can assign any value to an any variable:

anyVariable = 5;
anyVariable = "Hello";

Furthermore, you can assign an any variable to another variable with a defined type:

let booleanVariable: boolean = anyVariable;
let numberVariable: number = anyVariable;

Unknown => This type, like any, could hold any value and is also considered the top type. We use it when we don’t know the variable type, but it will be assigned later and remain the same during the runtime. Unknow is a less permissive type than any.

let unknownVariable: unknown;

Directly calling methods on unknown will result in a compile-time error:

unknownVariable.trim();
unknownVariable.length;

Before using it, we should perform checks like:

if (typeof unknownVariable === "string") {
 unknownVariable.trim();
}

Like any, we could assign any type to the variable.

unknownVariable = 5;
unknownVariable = "Hello";

However, we cannot assign the unknown type to another type, but any or unknown.

let booleanVariable2: boolean = unknownVariable;
let numberVariable2: number = unknownVariable;

This will show us an error

Null => The variable can hold either type. It means that the variable does not have a value.

let nullVariable: null;

nullVariable = null;

Attempting to assign any other type to a null variable will result in an error:

nullVariable = "Hello";

Never => We use this type to specify that a function doesn’t have a return value.

function throwError(message: string): never {
 throw new Error(message);
}


function infiniteLoop(): never {
 while (true) {
   console.log("Hello");
 }
}

The end...

We finish with Typescript,

For today (?

I hope this was helpful to someone.

If you have any technical interview questions you'd like me to explain, feel free to let me know in the comments. 🫶🏻

Have a great week 💖

Technical Interview Questions - Part 1 - Javascript

Giuliana Olmos — Thu, 17 Oct 2024 13:16:55 +0000

Introduction

Hey everyone!

How's it going?

I’ve been thinking about starting a series based on the theoretical questions I’ve come across in technical interviews. I’ll be covering Javascript, NodeJS, Typescript, and SQL.

The goal of this series is to give quick responses and explain key concepts. Also, you’ll notice "Part 1" in the title—I'm not sure yet how many parts this series will have! 😅

This first chapter will dive into ✨Javascript✨.

So, let's go...

## Questions
1. What are the differences between regular and arrow functions in JavaScript?
2. What are the differences between then() and async/await?
3. What timing events do you know in JS, and how do they work?

Question 1: What are the differences between regular and arrow functions in JavaScript?

Answer:

They are syntactically different (Arrow functions were introduced in ECMAScript 6).

~~Arrow functions can be anonymous (they don’t need a name).~~ //Clarification in comments

The key difference lies in how they handle the this context.

In this post, I'll focus on the most commonly asked aspect: the difference in how this is handled.

Let’s use this object as an example.

const cat = {
 name: 'Rubi',


//This is a regular function
 regularGreet() {
   console.log(`Hello, my name is ${this.name}. I mean... meow`);
 },


//This is an arrow function
 arrowGreet: () => {
   console.log(`Hello, my name is ${this.name}. I mean... meow`);
 },
};

If you run those functions, the result will be the next.

cat.regularGreet(); // return "Hello, my name is Rubi. I mean... meow"

cat.arrowGreet(); // return "Hello, my name is undefined. I mean... meow"

In the arrow function, ${this.name} is undefined.

DISCLAIMER: This example works if you're using Node or Deno. However, it will throw an error in Bun because the default context is undefined.

But...

Because of how the this keyword works:

In regular functions, this refers to the object the function is a part of. However, arrow functions don’t have their own this; instead, they inherit it from the surrounding context.

For example, if I log this inside a regular function, it will output the cat object.

 regularGreet() {
   console.log({ this: this });
   console.log(`Hello, my name is ${this.name}. I mean... meow`);
 },

Log:

But, when I log this in an arrow function:

arrowGreet: () => {
   console.log({ this: this });
   console.log(`Hello, my name is ${this.name}. I mean... meow`);
 },

Log:

This is empty.

It's essential to know that when we don’t have a broader scope, this refers to the Window object.

How could you print the name in arrowGreet?

Well, you could define this, inside arrowGreet()

 arrowGreet: () => {
   console.log({ this: this });
   this.name = ‘Rubi’


   console.log(`Hello, my name is ${this.name}. I mean... meow`);
 },

Now, you will be logging:

Hello, my name is Rubi. I mean... meow

However, this is not a good practice; if you have to define this inside the function, use regular functions instead.

But if you want to inherit the context for the arrow function. You could do the next.

inheritContext() {
   const inceptionArrow = () => {
     console.log({ this2: this });
     console.log(`Hello, my name is ${this.name}. I mean... meow`);
   };
   inceptionArrow();
 },

inheritContext() => It’s a regular funcion. So the context of “this” is the same as regularGreet(), the object cat.

inceptionArrow() => It’s inside of inheritContext(). As we said before, the arrow function inherits its context. So, which context is it inheriting from?

Yes, cat.

The result of printing this2

We can apply the same approach with another example, this time using setTimeout(). In this case, we have a regular function that contains an arrow function, which inherits its context from secondCombinationFunctions().

 secondCombinationFunctions() {
   setTimeout(() => {
     console.log({ this3: this });
     console.log(`Hello, my name is ${this.name}. I mean... meow`);
   }, 1000);
 },

Question 2: What are the differences between `then()` and `async/await`?

Answer:

There are no differences between them other than their syntaxes.

If we have an existent function called asyncFunction() and we run it using async/await and then()

await asyncFunction();
console.log('Run this after running asyncFunction');


asyncFunction.then(() => {
 console.log('Run this after running asyncFunction');
});

The results and the order of its run will be the same.

The difference could be that sometimes we need to run several functions concurrently, and using then() could create a callback hell.
function1().then(()=>{
  function2().then(()=> {
    function3().then(() => {
      function4...
    })
  })
})

Question 2.5: How do you avoid a callback Hell?

Answer:

Using async/await.
Avoiding nested .then() calls.

The execution is almost the same, but it’s more readable in this way.

async/await:

await function1()
await function2()
await function3()
await function4()
...

.then():

function1()
  .then(function2)
  .then(function3)
  .then(function4)

Question 3: What timing events do you know in JS, and how do they work?

Answer:

I know about two different timing events in JS.

setTimeout()

setInterval()

Both methods from the “window” object allow you to run your code in intervals.

The definition of both from w3school is:

setTimeout(function, milliseconds)
Executes a function, after waiting a specified number of milliseconds.

setInterval(function, milliseconds)
It is the same as setTimeout() but repeats the function's execution continuously.

How it works setTimeout?

function testSetTimeout() {
 console.log('Start function');
 setTimeout(() => {
   console.log('Hello World');
 }, 3000);
 console.log('Waiting set Time out');
}


testSetTimeout();

Logs:

The order of how it runs is

Run console.log('Start function');
Run setTimeout(); The timing starts to count now before running the function inside setTimeout.
Run console.log('Waiting set Time out');
The timer hits 3000 and runs the function that shows the console.log.

How do I stop the `setTimeout`?

When the function set with the setTimeout has yet to run, you can stop it with clearTimeout().

function testSetTimeout() {
 console.log('Start function');
 const settedTimeout = setTimeout(() => {
   console.log('Hello World');
 }, 3000);
 console.log('Waiting setTimeout');
 clearTimeout(settedTimeout);
}


testSetTimeout();

Log:

How it works setInterval?

function testSetInterval() {
 console.log('Start function');
 setInterval(() => {
   console.log('Run interval');
 }, 2000);
 console.log('Waiting for interval starting');
}


testSetInterval()

Run console.log('Start function');
Run setInterval(); As setTimeout() in that line is when the timer starts to count.
Run console.log('Waiting for interval starting');
The timer hits 2000ms and runs the function that shows the console.log. Then, every 2000ms, the function runs again.

How could we stop it?

Using clearInterval()

function testSetInterval() {
 console.log('Start function');
 const settedInterval = setInterval(() => {
   console.log('Run interval');
 }, 2000);
 console.log('Waiting for interval starting');

 clearInterval(settedInterval);
}

testSetInterval()

The result is the next:

Or... we could combine the timers to step the interval after a specific time.

function testSetInterval() {
 console.log('Start function');
 const settedInterval = setInterval(() => {
   console.log('Run interval');
 }, 2000);
 console.log('Waiting for interval starting');


 setInterval(() => {
   clearInterval(settedInterval);
 }, 10000)
}


testSetInterval()

Then, the interval will run for 10k milliseconds for each 2k ms.

The end...

That’s all for now! I’m working on more posts covering common interview questions (I’ve got a list of others to tackle). If there’s a specific question you’d like me to explain, feel free to drop it in the comments, and I’ll make sure to include it.

✨I hope this is helpful to everyone!✨

Thank you so much, and see you next time 🫶🏻

Last but not least

I want to say thanks to Samuel Rouse for taking the time to write comments, correcting and adding clarifications that helped me improve this post.

Guessing Number Game using Hyperswarm.

Giuliana Olmos — Tue, 23 Apr 2024 18:48:06 +0000

Hello 🤗
Today, I will explain how to create a guessing number game using Javascript, NodeJS, and Hyperswam. I will also talk about this package, how it works, and what it is for.

I will leave the table content here to help you understand how this post's topics are divided more easily.

Table Of Contents

HyperSwarm
The structure of the game
Code
- Prepare environment
- Index.js - Main function
- Server
- Client
- Game
Demo
Bye Bye

HyperSwarm

What is Hyperswarm? What is it for?
Well, first of all, I wanted to talk about this package that Tether created. Hyperswam is a package that helps you create peers to find and connect between them, announcing a common 'topic.'

What is a peer? It is the way we call the participants in a P2P network.
If you want to know more about this, you can check my post, where I go through the topic :D

These are some important links.
Github => https://github.com/holepunchto/hyperswarm
Documentation => https://docs.pears.com/building-blocks/hyperswarm

The structure of the game

Hyperswam is an excellent tool for creating P2P networks, BUT this game will use peers in a server-client architecture. It is easy to understand how the peers interact in this type of architecture if client-server is the only architecture you know.

The flow is very simple:

The server will randomly choose a number between 1 and 100.
The first user that connects to the game will start the game.
The following users can join and play in the same party.
Every time a player guesses a number, the server makes a check and updates the game's status, then sends the updated status to all the connected players.
When someone guesses the number, the server notifies the players, and the game starts again.

Code

Let's go

Prepare environment

Before starting, you should have Node installed on your computer.

You can download it from here.

After this, open the terminal in the folder where you want to start your project. Run

npm init

and complete all the steps to initiate your node project.

Then, you have to install two packages to start to work.

npm install hyperswarm readline

Readline will provide an interface for reading data from the console. This means we can guess the number using the console without creating a front end.

Index.js - Main function

Once we have installed the packages, we will start to work on our index.js

const { CLI } = require("./cli");
const { Server } = require("./server");
const { Client } = require("./client");

async function main() {
  const cli = new CLI();
  const nickname = await cli.askTerminal("What is your nickname? ");

  const lowerCaseNickname = nickname.toLowerCase();

  if (lowerCaseNickname === "server") {
    //const server = new Server();
  } else {
    //const client = new Client(nickname);
  }
  console.log(`Welcome to the game, ${nickname}!`);
}

main();

Also, we need to create a module for reading that gets exported as CLI. This code creates the interface in the console.

cli.js

const rl = require("readline");
let readline;

class CLI {
  constructor() {}

  async askTerminal(question) {
    if (!readline) {
      readline = rl.createInterface({
        input: process.stdin,
        output: process.stdout,
      });
    }
    return new Promise((resolve) => {
      readline.question(question, (input) => resolve(input));
    });
  }
}

module.exports = { CLI };

Then, run your project with npm run start

The console will ask you for your nickname; if you type "server," you will start the peer that will work as the server in charge of managing the game. Otherwise, you will start the peer that acts as a client (or player) to join the game.

We haven't added the code to create the client and the server yet, so you will just see a console log with your nickname.

Server

The server is a class. I will create a new instance of the server module when the user types "server" in the console after running npm run start.

This is a basic UML of the class.


+---------------------+
|      Server         |
+---------------------+
| -server: Hyperswarm |
| -players: Map       |
| -clients: Array     |
| -game: Game         |
+---------------------+
| +constructor()      |
| +handleConnection(  |
|   Socket, PeerInfo) |
| +isValidGuess(int)  |
| +respontToClients(  |
|   String)           |
| +initializeGame()   |
+---------------------+

Now, there are some lines that I want to comment on. Server is an instance of Hyperswarm.

So, as I mentioned before, the peers need a topic to connect with each other. To join the topic, we need to use

swarm.join(topic, [options])

topic is a 32-byte Buffer, and options is an object that contains both options server and client and a boolean to indicate how the peer should act.

In this case,

{
   server: true,
   client: false,
}

For the topic, I will create a doc called constant.js

const GAME_CHANNEL = "hyperswarm-guessing-game";

module.exports = {
  GAME_CHANNEL,
};

Once the peer connects to the network, we must indicate how to react to some events. In this case, we will use

swarm.on('connection', (socket, peerInfo) => {})

Emitted whenever the swarm connects to a new peer. This means the server will do something every time a new peer (a player) connects with them.

Inside that function, I will handle the connections to store the data from the players. I will use that information to determine which connections the servers had and where I have to send messages with the game's status.
Also, we will have a socket.on(), which is the server receiving and showing the messages from players.

const Hyperswarm = require("hyperswarm");
const { GAME_CHANNEL } = require("./constants");
const { Game } = require("./game");

class Server {
  constructor() {
    this.server = new Hyperswarm();
    this.players = new Map();
    this.clients = [];
    this.game = new Game();

    const topic = Buffer.alloc(32).fill(GAME_CHANNEL);

    this.server.join(topic, {
      server: true,
      client: false,
    });

    this.handleConnection = this.handleConnection.bind(this);
    this.server.on("connection", this.handleConnection);
  }

  handleConnection(socket, peerInfo) {
    console.log("New connection ");
    const publicKey = peerInfo.publicKey.toString("hex");
    if (this.players.size) {
      if (!this.players.has(publicKey)) {
        console.log("New player ");
        this.players.set(publicKey, true);
        this.clients.push(socket);
      }
      this.respontToClients(
        this.game.lastClue ?? "Guess a number between 1 and 100:"
      );
    } else {
      console.log("First player");
      this.players.set(publicKey, true);
      this.clients.push(socket);
      this.initializeGame();
    }

    socket.on("data", (data) => {
      const jsonData = JSON.parse(data.toString());
      console.log(`Server: ${jsonData.nickname} guessed ${jsonData.guess}`);

      const guessedNumber = parseInt(jsonData.guess);
      if (this.isValidGuess(guessedNumber)) {
        if (this.game.isStarted) {
          if (guessedNumber === this.game.numberToGuess) {
            const message = `User ${jsonData.nickname} guessed ${jsonData.guess} and it's correct!\n The game is over! \n A new game will start soon.`;
            this.respontToClients(message);
            this.game.isEnded = true;
            this.initializeGame();
          } else {
            if (guessedNumber > this.game.numberToGuess) {
              this.game.lastClue = `User ${jsonData.nickname} guessed ${jsonData.guess} and it's too high!`;
            } else if (guessedNumber < this.game.numberToGuess) {
              this.game.lastClue = `User ${jsonData.nickname} guessed ${jsonData.guess} and it's too low!`;
            }
            this.respontToClients(this.game.lastClue);
          }
        }
      } else {
        const message = `User ${jsonData.nickname} guessed ${jsonData.guess} and it's not a valid guess. Please guess a number between 1 and 100.`;
        this.respontToClients(message);
      }
    });
  }

  isValidGuess(guess) {
    if (guess < 1 || guess > 100) {
      return false;
    }
    return true;
  }

  respontToClients(message) {
    for (const client of this.clients) {
      client.write(
        JSON.stringify({
          type: "game-update",
          message,
        })
      );
    }
  }

  initializeGame() {
    this.game.startGame();
    this.respontToClients("Game started! Guess a number between 1 and 100:");
  }
}

module.exports = { Server };

Client

+---------------------+
|      Client         |
+---------------------+
| -nickname: String   |
| -client: Hyperswarm |
| -cli: CLI           |
| -topic: Buffer      |
| -connection: Socket |
| -handleConnection:  |
|   Function          |
+---------------------+
| +constructor(String)|
| +handleConnection(  |
|   Socket, PeerInfo) |
| +askGuess()         |
+---------------------+

In the client, I will use swarm.join(topic, [options]) where

{
   server: false,
   client: true,
}

And swarm.on('connection', (socket, peerInfo) => {}) will inform us when we connect with the server.

const Hyperswarm = require("hyperswarm");
const { GAME_CHANNEL } = require("./constants");
const { CLI } = require("./cli");

class Client {
  constructor(nickname) {
    this.nickname = nickname;
    this.client = new Hyperswarm();
    this.cli = new CLI();

    this.topic = Buffer.alloc(32).fill(GAME_CHANNEL);
    this.client.join(this.topic, {
      server: false,
      client: true,
    });

    this.handleConnection = this.handleConnection.bind(this);
    this.client.on("connection", this.handleConnection);
  }

  handleConnection(socket, peerInfo) {
    console.log("Client connected to server!");
    this.connection = socket;
    socket.on("data", (data) => {
      const jsonData = JSON.parse(data.toString());

      if (jsonData.type === "game-update") {
        console.log(jsonData.message);
        this.askGuess();
      }
    });
  }

  askGuess() {
    this.cli.askTerminal("> ").then((number) => {
      this.connection.write(
        JSON.stringify({
          nickname: this.nickname,
          guess: number,
        })
      );
    });
  }
}

module.exports = { Client };

Game

+---------------------+
|        Game         |
+---------------------+
| -isStarted: Boolean |
| -numberToGuess: int |
| -isEnded: Boolean   |
| -lastGuess: int     |
| -lastClue: String   |
+---------------------+
| +constructor()      |
| +getNumberToGuess() |
| +startGame()        |
+---------------------+

In the server, we make an instance of the game. This is the code to initialize the game and the logic to choose the number.

class Game {
  constructor() {
    this.isStarted = false;
    this.numberToGuess = 0;
    this.isEnded = false;
    this.lastGuess = null;
    this.lastClue = null;
  }

  getNumberToGuess() {
    return Math.floor(Math.random() * 100) + 1;
  }

  startGame() {
    this.numberToGuess = this.getNumberToGuess();
    this.isStarted = true;
    console.log("Number to guess: ", this.numberToGuess);
  }
}

module.exports = { Game };

Demo

Before running the code, you must remember to uncomment the lines in index.js.

This is the link to the GitHub repo.

Now, ✨we have a game working.✨

1 - Starting server

2 - The first player joins the game

3 - The server starts the game

4 - The player guesses a number

5 - Another player joins the game

6 - The server is notified about the new player

7 - A resume of the game and the end.

Bye Bye

I hope you enjoyed creating this game and have understood more about how hyperSwarm works.

I want to mention that I took the main idea from here.

Thank you so much for reading. 💖
Please let me know your thoughts and if you would add something else to the game.

See you in the next posts. 🚀

What is a P2P (Peer to Peer) Network?

Giuliana Olmos — Tue, 02 Apr 2024 17:29:12 +0000

Hi all!

I started learning about P2P networks weeks ago and want to share with you what I understand.
So, here we go... :D

What is ✨P2P✨?

P2P is a computer network where all computers have the same privileges and functions. In a client-server model, the clients make the requests, the server responds, and the network needs a main server.
However, in a P2P network, all parties could work as clients and servers. The network is organized in a decentralized manner (it does not need a main server), where all the peers are connected.

How does P2P work? 🤓☝️

First, we need to understand how a client-server structure works to know how a P2P network works.

When you watch a video on a streaming platform like YouTube, your device (your phone, TV, or computer) works as a client. So, you open the app, select a video to watch, and the app sends a request to the server. The server will receive the request and provide you with the content you want to watch on your device.

But if you want to make the same request in a P2P network instead of sending it to a central server, your device will simultaneously send requests to multiple computers (also called peers) within the network.

Then, each peer will respond with a part of the video. This means that instead of downloading the entire video from a single source (a main server), you download separate parts from multiple sources within the network.

At the same time, as your device receives the parts of the video, it will start sharing those parts with other clients asking for the same content. Unlike in the client-server structure, where the data transfers occur in one direction, these actions in a P2P network go in many different directions simultaneously among the interconnected devices.

⭐️ Fun fact ⭐️ In the beginning, Spotify used a peer-to-peer structure to avoid overwhelming its servers.

What type of P2P architecture exists?

There are three P2P structures, depending on how peers manage their connections.

In Structured P2P networks, the network uses a DHT (Distributed Has Table) to store the link information. This makes it easy to know where the information you need is stored and in which peer it is stored, which means that when you need to search, it will return the information faster.

In Unstructured P2P networks, the other peers don't know the link information, so when they need to get the data, they have to use the flooding technique to look for the peer that contains the information.

With flooding, a node searching for a resource contacts its neighbors in the system, which in turn contact their own neighbors and so on until a node that shares the requested resource is located.

In Hybrid P2P networks, we use a main server that contains all the information of the peers. So, the request goes directly to the main server, and then the server redirects the request to the peers with the information you need.

The advantages of P2P:

Security

Since P2P networks don't have a main server (in most cases), they cannot be easily hacked. Even if one of the peers is attacked, the impact on the entire system is minimal.

Scalability

As more peers interact with the data, more peers work as servers. If we consider this, the capacity of a P2P network is unlimited.

Flexibility

As mentioned earlier, various types of P2P networks are available. Depending on our requirements, we can choose and implement the structure that best suits our needs for managing and securing our application's information.

The disadvantages of P2P:

Copyright

Since we don't have a main server controlling the uploaded data, it's hard to ensure that it does not violate copyright laws, which could result in legal issues.

Dependencies

Changes in one computer on the network can affect all other systems, as they are interconnected. The entire system could be at risk if someone deletes information or adds bad-intentioned data.

Unavailable information

A P2P network works by having peers connected to it. If the peers that contain the data that you need are turned off, those data will be unavailable until the peers are connected to the network again.

And... I think that is all for now.

I hope this will help you understand a little more about P2P networks. And, if there's something you don't understand or think I could add something else, please let me know.

Thank you!

DEV Community: Giuliana Olmos

Technical Interview Questions - Part 7 - Promises Methods

Introduction

What Are Promise.all(), Promise.allSettled(), and Promise.race()?

🎯Promise.all()

🎯Promise.allSettled()

🎯Promise.race()

✨Key Points✨

End

Technical Interview Questions - Part 6 - SQL 2

Introduction

Question 1: What is the difference between OUTER JOIN and INNER JOIN?

Which table will be prioritized?

Question 2: What is an Index? What are the Trade-offs of Using Indices?

What are the trade-offs of using indices? 🎯

Extra Data: Index Usage in Firestore

End

Technical Interview Questions - Behavioral Questions

Introduction

What are Behavioral Questions?

What are they expecting?

What is the STAR Method?

A Quick Example

Questions

Recommendations

The end

Technical Interview Questions - Part 5 - Event Loop

Introduction

What is the event loop?

Theory

What is the Event Loop?

What Does Single-Threaded Mean?

Components of the Runtime

Call Stack

Queues

Event Loop

How Does It Work?

Step 1: Process the Call Stack

Step 2: Process the Microtask Queue

Step 3: Process the Task Queue

Examples

Example 1

Example 2

End

Technical Interview - Boilerplate 2 - Node + Serverless + AWS + Github Actions

Introduction

Topics

Before to start…:

What is ✨Serverless✨? And is it the same as the ✨Serverless Framework✨?

Serverless.yml:

Provider:

Package: Individually: true :

Functions:

Resources:

Plugins:

DynamoDB and Dynamoose:

Why Dynamoose?

Example Schema

Transactions

Lambdas:

Tests:

Github Actions:

Final Steps:

Manual Deployment

Running Locally

Sharing Your Live Code

Why Not Docker?

The End:

Technical Interview Questions - Part 4 - Git + SQL vs noSQL

Introduction

Question 1: Difference between Git Merge and Git Rebase

GIT REBASE

GIT MERGE

Question 2: What are the differences between SQL and NoSQL databases?

Farewell & Thoughts

Technical Interview Questions - Part 3 - SQL

Introduction

Question 1: What is a key in SQL, and what types do you know?

Primary Key

Candidate key

What Are `Promise.all()`, `Promise.allSettled()`, and `Promise.race()`?

What is `ACID`?

Question 1: What are generics in typescript? What is `<T>`?

Question 3: What are the differences between `any`, `null`, `unknown`, and `never`?

Question 2: What are the differences between `then()` and `async/await`?

How do I stop the `setTimeout`?