DEV Community: bube.js

Understanding the differences between micro-service and monolithic architecture.

bube.js — Thu, 13 Jun 2024 22:38:59 +0000

One of the initial decisions you'll face when building an application is choosing the right architecture. This choice will significantly impact your application's scalability, maintainability, and overall success. Two popular architecture approaches are monolithic and microservice architecture. This article will explain the differences between these two approaches, which are crucial to making an informed decision. To understand better we are going to use an illustration, lets get started.

Monolithic Architecture

Meet "The Guardian," a lone superhero. He is extremely strong, swift, and agile. He is powerful. He defends the city from evildoers, but his own might is the only thing that can keep the day from falling apart. Should he be hurt or unable to serve, the city is left exposed.

This is comparable to monolithic architecture, in which an application is confined within a single, self-contained unit. The entire system is vulnerable if one component malfunctions or is corrupted.

The phrase "monolith" can be described as massive and glacial. In a monolithic architecture all components are tightly coupled and interconnected.

Advantages

Easier to develop and deploy.
Simplified testing and debugging.
Faster communication between components.
Lower overhead in terms of resources and infrastructure.

Disadvantages

Difficult to scale and maintain.
A single point of failure can bring down the entire system.
Limited flexibility and adaptability.
Can become bulky and hard to manage as the application grows.

Micro-Service Architecture

Imagine now a group of superheroes, each possessing unique abilities and powers. "The Spark" (energetic projection), "The Cyclone" (speed), "The Guard" (protection), and others are among them. They cooperate to keep the city safe, but if one hero is hurt or unable to serve, the others can step in and keep the city safe.

This is comparable to microservice architecture, in which an application comprises several independent services. Every service has a distinct task, so if one fails, the other services can still function, reducing the damage.

Each service is responsible for a specific task or functionality. Services communicate with each other through APIs.

Advantages

Scalable and flexible.
Allows for independent development and deployment of services.
Improves fault tolerance and reduces the risk of a single point of failure.
Enables the use of different programming languages and frameworks.

Disadvantages

More complex to develop and deploy.
Higher overhead in terms of resources and infrastructure.
Requires careful planning and coordination.
Can be challenging to manage and orchestrate services.

When to Apply Each:

Monolithic Architecture:

Well-suited for applications of small to medium scale.
Perfect for applications with straightforward, well-defined specifications.
Simpler to create and implement.

Micro-Service Architecture:

Fit for complex, big-data applications.
Perfect for applications with several separate components.
Provides increased flexibility and scalability.

By understanding the differences between monolithic and microservice architecture, you can make an informed decision about which approach best fits your application's needs.

To learn more check out these two articles. Monolith vs Micro-Service and
Amazon Explanation

Understanding DevOps : A Step-by-Step Guide for Beginners

bube.js — Tue, 30 Jan 2024 23:03:27 +0000

Developer Operations(DevOps) refers to a comprehensive set of practices, tools, and cultural principles aimed at fostering seamless collaboration between development and operations teams. This collaborative approach is driven by effective communication and coordination to enhance application development and fast product releases. DevOps is not a technology but a methodology.

Imagine a sports club where player development and overall club maintenance are traditionally handled independently. DevOps, in this scenario, is like the club owner bringing these two teams together for improved efficiency and quicker achievement of goals.

In the sports club scenario:

Development Team: This is like the team responsible for developing players, enhancing their skills, and preparing them for matches. In DevOps, this is similar to the development team creating and improving the application or software.

Operations Team: This is similar to the team that looks after the club's facilities and infrastructure and makes sure everything functions properly. This is equivalent to the operations team in DevOps, which is in charge of deploying, overseeing, and maintaining the software.

Fundamentals Aspects and Practices Of DevOps.

By using our previous example as a guide, we will delve deeper into various devOps practices and elements.

Communication:

DevOps Illustration: The club owner encourages open communication between the player development and maintenance teams to align goals.

DevOps Practice:In software development, frequent communication ensures everyone is on the same page, enhancing collaboration and problem-solving.

Collaboration:

DevOps Illustration: Players and maintenance staff collaborate to address challenges and achieve the club's overall success.

DevOps Practice: Development and operations teams collaborate closely to integrate code seamlessly, streamline processes, and enhance product reliability.

Automation:

DevOps Illustration: Imagine if repetitive tasks in player training and club maintenance are automated to save time and reduce errors.

DevOps Practice: Automation in the software development lifecycle reduces manual efforts, minimizes errors, and accelerates the release of high-quality software.

Continuous Integration and Deployment:

DevOps Illustration: Regular training sessions (integration) and swift player deployment to matches (deployment) keep the team in top form.

DevOps Practice: Continuous integration and deployment ensure that code changes are consistently and automatically tested, integrated, and deployed, leading to a more reliable and efficient development process.

Continuous Integration and Deployment:

DevOps Illustration: Regular training sessions (integration) and swift player deployment to matches (deployment) keep the team in top form.

By adopting DevOps practices, development and operations teams work harmoniously, just like the player development and maintenance teams in the sports club, resulting in faster, more reliable software releases that meet the evolving needs of the organization.

Benefits of DevOps

Aids in clear communication and collaboration between the development and operations teams.
Ensures customer satisfaction and faster release of product.
Improved scalability and availability.
Better workload management.

Who is a DevOps Engineer

A DevOps Engineer is a flexible engineer with extensive experience in development and operations. They are proficient in coding, infrastructure, system management, and devOps toolchains. DevOps engineers have strong interpersonal and non-technical abilities, which allow them to collaborate and establish a cohesive and conducive atmosphere. Their talents are diverse, including code reviews, unit testing, and adhering to agile standards.

A DevOps Engineer reduces the disparity between the actions required to alter an application and the tasks that ensure the app's reliability. DevOps is all about integration and automation. A DevOps engineer must comprehend both the software development lifecycle and the devops lifecycle, practices, philosophy, and culture.

Responsibilities Of A DevOps Engineer

Building and deploying application code.
Deploying and maintaining servers, storage and networking resources necessary for hosting applications.
Foster communication and collaboration between development and operations teams to streamline workflows.
Automate infrastructure deployment and management using tools like Terraform, Ansible, or Puppet.
Utilize cloud platforms like AWS, Azure, or Google Cloud for scalable and flexible infrastructure.
Implement and maintain CI/CD pipelines to automate the software delivery process.
Set up monitoring tools and logging systems to track application performance and troubleshoot issues.
Manage version control systems like Git to track changes and facilitate collaboration among team members.
Implement containerization (e.g., Docker) and orchestration tools (e.g., Kubernetes) for scalable and portable deployments.
Stay updated on industry trends, new tools, and technologies to bring innovative solutions to the team.

DevOps Tools

Understanding devops is critical, as are the tools used in devops. We will walk through the devops lifecycle and the tools used at each stage.

Discover: The team researches and defines the scope of the project, goals and requirements. Tools involved include, Jira, Trello and asana.
Plan: The team plans tasks and further divide tasks into smaller achievable and deliverable task. They engage in sprint planning, set timelines and allocate resources and budget needed. Tools include, Click-up, Microsoft planner, e.t.c
Build: This is the development phase where the dev team develop and integrate the code. This is were CI/CD(Continuous Integration and Delivery/Deployment) takes place. Tools include Gitlab CI, GitHub actions, Jenkins, git.
Test: Automated tests are done to ensure code quality and functionality. Tools include Jira Xray, Junit, Jest. e.t.c.
Deploy: The application is released to the production environment for deployment. Tools include, Docker, Kubernetes, Ansible and terraform.
Monitor: The team monitor the application status, the services and the infrastructure performance. Tools include, Prometheus, Grafana, ELK Stack.
Continuous feedback: The team collects continuous feedback for continuous improvement. Tools include, Slack, teams, GitHub issues and Microsoft teams.

To summarize, DevOps is a transformational methodology that combines development and operations, promoting communication, collaboration, and automation throughout the software development life cycle. DevOps helps teams develop high-quality software faster and more efficiently by integrating tools and techniques across stages such as planning, coding, testing, deploying, monitoring, and getting continuous feedback. This iterative and collaborative process emphasizes adaptability, scalability, and continual improvement, making it a foundation for modern software development practices. DevOps is more than simply a set of tools; it is a cultural transformation that enables teams to produce, deploy, and maintain software with speed and quality. To get started with devOps you can take the devOps course on kodeKloud(Highly recommend for beginners)or Microsoft devOps course(Advanced devs) or Amazon devOps course.

Cookies Of The Internet: A Comprehensive Guide

bube.js — Tue, 21 Nov 2023 22:29:57 +0000

Cookies play an important role in shaping the modern internet landscape because they are small pieces of information stored within your browser that help to customize user experiences on websites. Consider the operation of an e-commerce platform as an example. These cookies enable the platform to remember the contents of your shopping cart even if you close and reopen your browser, eliminating the need to log in multiple times. In the digital realm, cookies, like the characters in a detective or spy film, serve as both allies and adversaries.

Cookies, in this analogy, act as online detectives, collecting and storing data that aids in the smooth operation of websites. They act as silent observers, gathering data on your preferences, items in your shopping cart, and browsing habits. This monitoring is not malicious; rather, it improves user convenience.

Cookies, like characters in a movie, can be perceived as potential threats, displaying a dual nature. While they help to provide personalized experiences, there is a potential downside to the indiscriminate collection of user data. In some cases, these digital detectives may be used against the user's best interests, raising concerns about privacy and data security.

Let's Go Deeper

Let's go back in time to when cookies first appeared. Cookies were invented in 1994 by Lou Montulli, a Netscape Communication employee. Montulli collaborated with John Giannandrea to create a one-of-a-kind solution that would aid in the creation of shopping carts for e-commerce stores.

Initially, supported browsers accepted all cookies by default, which meant that users were unaware that cookies were present in their browser. Later Everything changed in 1996 when they were revealed in a magazine called the Financial Times, and they were subjected to intense scrutiny over the next few years due to the privacy risks they posed as they tracked visitors across a website.

The Internet Engineering Task Force (IETF) was tasked with creating a formal cookie specification. This meant that third-party cookies (tracking cookies) were supposed to be blocked or allowed only when a user specifically requested them.

Types Of Cookies

We will look at some of the different types of cookies and how they are used.

1) Session Cookies: They are temporary data files stored in the memory of your browser. They exist only for the duration of your browsing session due to their limited storage capacity. Session cookies are automatically deleted when you close your browser, similar to how a refrigerator's light turns off when the door is closed. They enable seamless, temporary communication between your browser and a website, enhancing your online experience by storing data only for the duration of your active session.

2)Persistent Cookies: They are long-lasting data files that are stored on your device for an extended period of time. In contrast to session cookies, persistent cookies are intended to track your browsing activity over time and frequently have an expiration date. Even after you close your browser, these cookies remain, allowing them to retain information beyond a single session.

A common example is the "remember me" feature on website logins, which uses persistent cookies to save login credentials across multiple sessions. This increased storage duration improves user convenience while also raising concerns about privacy and data tracking practices.

3) Authentication Cookies: They are required to keep user sessions on websites active. When a user logs in, they generate a unique identifier string that is linked to the user's account information. Consider authentication cookies to be a digital vacation guide; just as you would receive a guide upon arrival at a destination, they provide a personalized experience by ensuring that the correct information is delivered to the right user during their online journey.

Authentication cookies, similar to how a vacation guide helps you navigate and discover the best places, help users access their accounts securely and receive information tailored to their profiles.

4) Zombie cookies, also known as evercookies or supercookies, have the unusual ability to regenerate even after users delete them. To create backup copies of themselves, zombie cookies use multiple storage techniques, often beyond the conventional browser cookie storage, much like a resilient superhero in a movie who can revive after facing adversity. This persistence allows them to reappear, retaining their presence and tracking capabilities despite attempts by users to remove them. Because of this, zombie cookies are a particularly difficult and intrusive form of online tracking.

Third Party Cookies

Third-party cookies are set by a domain other than the one the user is currently on. When a user visits a website (let's call it Website A) that contains ads served by a different domain (Website B), the cookies set by Website B are referred to as third-party cookies. One of the major concerns of third party cookies are user privacy and tracking. Because these cookies are set by domains other than the one with which the user is currently interacting, they can be used to track users across multiple websites. This information may be used by advertisers, analytics companies, and other third-party entities to create user profiles, deliver targeted ads, and analyze user behavior.

To address these privacy concerns, there has been an increase in user control over cookies, as well as regulatory measures aimed at improving transparency and user consent regarding cookie usage. Many web browsers now include tools for blocking or limiting third-party cookies, and laws such as the General Data Protection Regulation (GDPR) and the California Consumer Privacy Act (CCPA) require websites to obtain user permission before storing cookies, particularly those related to tracking and personal data.

Risks Of Cookies

While cookies play an important role in improving the functionality and user experience of websites, there are risks associated with them, particularly in terms of privacy and security. Here are some of the most common risks associated with cookies:

Tracking User Behavior: Cookies can be used to track users across websites, building detailed profiles of their online activities. Because users may be unaware of the extent of data collection, this tracking raises privacy concerns.

Security Concerns:

Session Hijacking: If an attacker obtains access to a user's session cookie, he or she can impersonate the user without requiring the login credentials. This is referred to as session hijacking.

XSS (Cross-Site Scripting):
Injection of Malicious Code: If a website is vulnerable to XSS attacks, attackers can inject malicious scripts into cookies, potentially compromising user data and allowing unauthorized access.

Unauthorized Actions: Cookies can be used in Cross-Site Request Forgery (CSRF) attacks, in which an attacker tricks a user's browser into performing actions on a website without the user's consent.

Cookie Theft:
Unauthorized Access: If cookies are intercepted, attackers can use them to gain unauthorized access to user accounts, potentially resulting in data breaches.

Third-Party Cookies:
Data Sharing: Third-party cookies, which are frequently used for advertising and analytics, can result in extensive tracking and sharing of user data across websites, potentially jeopardizing user privacy.

Targeted Advertising: Cookies are frequently used to create user profiles for targeted advertising. While this can improve ad relevance, it can also feel distracting and raise questions about data exploitation.

Browser FingerPrinting: Cookies and other tracking technologies contribute to browser fingerprinting, in which a user's unique device and browser characteristics are used for identification, potentially without their knowledge.

Browsers have implemented privacy features such as cookie management settings, incognito modes, and tracking prevention to mitigate these risks. Furthermore, regulatory frameworks such as the GDPR and the CCPA seek to protect user privacy by requiring transparent disclosure and obtaining user consent for cookie usage. Website owners and developers are also important players in implementing secure coding practices and respecting user privacy preferences.

In conclusion, while cookies are necessary for improving website functionality, they are not without risks, the most serious of which are privacy and security concerns. User tracking, session hijacking, malicious code injection, unauthorized actions, and data breaches are among the risks. Supercookies and evercookies are advanced tracking techniques that raise concerns about persistent user profiling. Third-party cookies and browser fingerprinting also contribute to privacy concerns.

Node.js Unit Testing with Jest: A Quick Guide

bube.js — Fri, 27 Oct 2023 02:06:42 +0000

Unit testing is a part of automated testing that involves testing the smallest part of your application called units. It helps find bugs faster and fix bugs early on in development.

Unit testing is like a coach carefully assessing a football team during practice. Unit testing examines the smallest parts of an application, much like the coach evaluates each player's skills according to their positions. Coaches evaluate players on man marking, alertness, tackling, and shooting range; attackers are evaluated on positioning, dribbling, and one-on-one play. Similarly, unit testing checks that each "unit" in the application functions as intended by testing specific abilities or functionalities. This comparison highlights the accuracy and detail of unit testing in the context of software development.

Getting Started with unit testing node.js

After understanding what unit testing is and why it is vital. Let's talk about how to get started with unit testing.

Let's build a simple app.

We'll make a simple task manager to store and retrieve tasks. Because this would be a simple program, we will store the data in an array. You'll use the command line to create a new directory, navigate to it, and launch a new app:

mkdir task-manager
cd task-manager

Open the app in your preferred code editor. Navigate to your terminal and run the command.

 npm init i

This is to install all your node_modules.

Run the next command.

npm init -y

This is for your package.json file. Open your package.json and you will see the following code.


{
  "dependencies": {
    "init": "^0.1.2"
  },
  "name": "task-manager",
  "version": "1.0.0",
  "main": "index.js",
  "devDependencies": {},
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": ""
}

Let's build our app

A task manager app was chosen because many developers must have built a simple to do list or a complex task manager as a project. Because we are performing small and simple unit testing, we will build a relatively simple and small app.

Let's proceed. Create a file named taskManager.js in your project directory. This module will include functions for managing tasks. Paste the following code.

// task-manager.js
const tasks = [];

function addTask(task) {
  tasks.push(
    { 
        task, 
        completed: false 
    }
    );
}

function listTasks() {
  return tasks;
}

function completeTask(index) {
  if (index >= 0 && index < tasks.length) {
    tasks[index].completed = true;
  }
}

module.exports = { addTask, listTasks, completeTask };

The code above performs three functions. The first function is to add a task to the array of tasks. The tasks array will accept an object with two values: one for the task and another to indicate whether or not the task has been completed. The second function returns a list of all tasks that have been added, and the last function sets a task to completed using the task's index value.

Lets a create a simple script to execute the functions and see if our app works using the command line.

Create another file called app.js and paste the following code.

// app.js

const taskManager = require('./task-manager')

taskManager.addTask('Buy groceries');
taskManager.addTask('Finish assignment');
taskManager.addTask('Go to schoolnode');
taskManager.completeTask(0)
taskManager.completeTask(1)
taskManager.listTasks().forEach((task, index) => {
  console.log(`Task ${index + 1}: ${task.task} (Completed: ${task.completed})`);
});

Run the following command to see your output

node app.js

Getting started with unit testing. Install a test framework

In order to get started with unit testing we are going to install a unit testing framework. There are different unit testing framework out there but for today's tutorial we are going to use jest.

What is Jest
Jest is an open source JavaScript testing framework designed to ensure correctness of any JavaScript codebase. Jest is designed to make simple and fun. Some features of jest include:

Good documentation
Feature rich-API that gives result quickly
Simple to use
Little to no configuration and can be extended to match your requirements
Fast and safe.

Jest has two commonly used methods in a test file, which include:

1) describe(): Groups related tests together. It helps to structure your test and add context to them. The method takes in two arguments: a string describing the test suite (the suite name) and a callback function that contains one or more test or it functions. For example look at the code below:

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

  test('multiplies 3 by 4 to equal 12', () => {
    expect(3 * 4).toBe(12);
  });
});

2) test(): The test function is used to define individual test cases. It takes two arguments: a string describing the test (the test name) and a callback function that contains the test logic. For example look at the code below:

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

Jest also includes other testing options such mocking, assertions, e.t.c.

Installing and setting up Jest
Now that we have understood what jest is all about, let's go back to our application and test it out with jest. You can install jest using your favorite package manager.

npm

npm install --save-dev jest

yarn

yarn add --dev jest

pnpm

pnpm add --save-dev jest

Once installation is complete, go to your package.json and make a small change. Take a look at the code below

  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },

Replace the above with "test": :"jest".

Now run the code below to test your app.

 npm test

You will see the following when you run the code.

No tests found, exiting with code 1

Lets write our first unit test

Create a directory named tests (double underscore) in your project directory to store your test files. Inside the tests directory, create a file named task-manager.test.js.

Now paste the following code.

// __tests__/task-manager.test.js

const taskManager = require('../task-manager');

test('addTask should add a task to the task list', () => {
  taskManager.addTask('Buy groceries');
  expect(taskManager.listTasks()).toEqual([{ task: 'Buy groceries', completed: false }]);
});

test('completeTask should mark a task as completed', () => {
  taskManager.completeTask(0);
  expect(taskManager.listTasks()[0].completed).toBe(true);
});

test('listTasks should return the list of tasks', () => {
  expect(taskManager.listTasks()).toEqual([{ task: 'Buy groceries', completed: true }]);
});

Run your code with npm test. You will see the following result.

 PASS  __tests__/task-manager.test.js
  ✓ addTask should add a task to the task list (2 ms)
  ✓ completeTask should mark a task as completed
  ✓ listTasks should return the list of tasks (4 ms)

Test Suites: 1 passed, 1 total
Tests:       3 passed, 3 total
Snapshots:   0 total
Time:        0.35 s
Ran all test suites.

Finally, let's make our test fail by modifying the code in the task manager file. It is crucial to see your tests fail since it decreases the risk of error and defects. Instead, I set the completed to true in the following code.

// task-manager.js

function addTask(task) {
  tasks.push(
    { 
        task, 
        completed: true
    }
    );
}

Now this is what a failed test would look like

 FAIL  __tests__/task-manager.test.js
  ✕ addTask should add a task to the task list (7 ms)
  ✓ completeTask should mark a task as completed (1 ms)
  ✓ listTasks should return the list of tasks (1 ms)

  ● addTask should add a task to the task list

    expect(received).toEqual(expected) // deep equality

    - Expected  - 1
    + Received  + 1

      Array [
        Object {
    -     "completed": false,
    +     "completed": true,
          "task": "Buy groceries",
        },
      ]

      3 | test('addTask should add a task to the task list', () => {
      4 |   taskManager.addTask('Buy groceries');
    > 5 |   expect(taskManager.listTasks()).toEqual([{ task: 'Buy groceries', completed: false }]);
        |                                   ^
      6 | });
      7 |
      8 | test('completeTask should mark a task as completed', () => {

      at Object.toEqual (__tests__/task-manager.test.js:5:35)

Test Suites: 1 failed, 1 total
Tests:       1 failed, 2 passed, 3 total
Snapshots:   0 total
Time:        0.342 s, estimated 1 s
Ran all test suites.

As you can see, our test provided us with feedback. So we know where to focus our efforts in our code.

Congratulations on the completion of your first unit test. You're on your way to becoming a fantastic developer.
To learn learn more you can check out the jest documentation itself.

Benefits of Unit testing

High code quality: Unit testing ensures that every component of your code works properly and meets quality standards.
Early Bug Identification: Unit testing aids in the detection of bugs early in the SDLC, lowering development costs and requiring less time to fix bugs.
Documentation: Unit tests serve as documentation by demonstrating how components are expected to function. Unit tests can help new developers understand the behavior of the code.
Easier Scaling: Having a comprehensive suite of unit tests becomes increasingly important as your software grows. It serves as the foundation for scaling your application while maintaining its dependability.
Enhanced User Experience: Unit tests help ensure that the software meets the specified requirements, which, in turn, leads to a more positive user experience with fewer functional issues.

The isolation of issues and a small portion of the application is the only disadvantage of unit testing. Users do not concentrate on minor details within the app, but rather on the app as a whole. That is why it is critical to conduct end-to-end testing.

Overall, unit testing is an important part of software development because it helps to improve code quality, increase productivity, and lower long-term costs. It's a useful technique for creating dependable and maintainable software.

To top it all off, unit testing is only one component of a well-rounded testing strategy. It is not a substitute for other types of testing, such as integration and end-to-end testing, which are required to validate the overall functionality, user experience, and interactions throughout the application. A well-rounded testing strategy employs a variety of testing techniques to ensure that an application meets user expectations and functions properly as a whole.