Forem: Igahsamuel

"Node.js: Understanding the Difference Between Current and LTS Versions"

Igahsamuel — Thu, 27 Jun 2024 15:12:56 +0000

Introduction
Node.js is a powerful runtime environment that allows developers to execute JavaScript on the server side. As with any software, Node.js receives regular updates to improve performance, add new features, and enhance security. Understanding the different versions of Node.js, particularly the Current and Long-Term Support (LTS) versions, is crucial for making informed decisions about which version to use for your projects.

What is Node.js?
Node.js is an open-source, cross-platform runtime environment that allows developers to build server-side applications using JavaScript. It is built on the V8 JavaScript engine and is widely used for developing scalable network applications.

V8 is Google’s open source high-performance JavaScript and WebAssembly engine, written in C++. It is used in Chrome and in Node.js, among others. It implements ECMAScript and WebAssembly, and runs on Windows, macOS, and Linux systems that use x64, IA-32, or ARM processors. V8 can be embedded into any C++ application.

The History of Node.js
Node.js was created by Ryan Dahl and first released in 2009, about 13 years after the introduction of the first server-side JavaScript environment, Netscape's LiveWire Pro Web. The initial release supported only Linux and Mac OS X. Its development and maintenance was led by Dahl and later sponsored by Joyent.

Dahl's goal was to create a more efficient way to build scalable network programs, leveraging the asynchronous, event-driven programming model. Since its inception, Node.js has grown in popularity and become a cornerstone for many modern web development projects.

Node.js Versioning
Node.js follows a predictable release cycle with two main types of versions: the Current version and the Long-Term Support (LTS) version.

Available Node.js Versions
As of now till 2028, this are the available versions of Node.js:

Release	Status	Code Name	Release Date	Maintenance End
0.10.x	End-of-Life		2013-03-11	2016-10-31
0.12.x	End-of-Life		2015-02-06	2016-12-31
4.x	End-of-Life	Argon	2015-09-08	2018-04-30
5.x	End-of-Life		2015-10-29	2016-06-30
6.x	End-of-Life	Boron	2016-04-26	2019-04-30
7.x	End-of-Life		2016-10-25	2017-06-30
8.x	End-of-Life	Carbon	2017-05-30	2019-12-31
9.x	End-of-Life		2017-10-01	2018-06-30
10.x	End-of-Life	Dubnium	2018-04-24	2021-04-30
11.x	End-of-Life		2018-10-23	2019-06-01
12.x	End-of-Life	Erbium	2019-04-23	2022-04-30
13.x	End-of-Life		2019-10-22	2020-06-01
14.x	End-of-Life	Fermium	2020-04-21	2023-04-30
15.x	End-of-Life		2020-10-20	2021-06-01
16.x	End-of-Life	Gallium	2021-04-20	2023-09-11
17.x	End-of-Life		2021-10-19	2022-06-01
18.x	Maintenance LTS	Hydrogen	2022-04-19	2025-04-30
19.x	End-of-Life		2022-10-18	2023-06-01
20.x	Active LTS	Iron	2023-04-18	2026-04-30
21.x	Maintenance		2023-10-17	2024-06-01
22.x	Current	Jod	2024-04-24	2027-04-30
23.x	Planned		2024-10-14	2025-06-01
24.x	Planned	Krypton	2025-04-22	2028-04-30

Current Version: Node.js 22.x
The latest release with new features and improvements.
LTS Versions:
Node.js 20.x (Active LTS)
Node.js 18.x (Maintenance LTS)
Node.js 16.x (End-of-Life)

Current Version of Node.js
The Current version of Node.js is the latest release that includes the newest features, improvements, and updates. These versions are released approximately every six months, in April and October. Initially, a version is designated as "Current" and receives active feature updates for six months. After this period, it is either transitioned to LTS status or replaced by a new Current version.

Advantages of the Current Version:

Access to the latest features and improvements.
Ideal for development environments where early adoption of new features is important.
When to Use the Current Version:
When you want to leverage the latest advancements in Node.js.
For testing and development purposes, where stability is less critical.

Long-Term Support (LTS) Version of Node.js
The LTS version of Node.js is a stable release that is maintained and supported for a longer period, ensuring stability and reliability. A Current version transitions to LTS status one year after its initial release. LTS versions have two phases: Active LTS and Maintenance LTS. Active LTS lasts for 18 months and includes regular updates, while Maintenance LTS lasts for 12 months and includes only critical fixes and security updates.

Advantages of the LTS Version:

Stability and long-term support.
Suitable for production environments where stability is crucial.
When to Use the LTS Version:
For production deployments to ensure stability and reliability.
When long-term support is needed for enterprise projects.

key differences between Current and LTS versions

Aspect	Current Version	LTS Version
Stability vs. New Features	Focuses on introducing new features and improvements, which may sometimes introduce breaking changes.	Prioritizes stability and long-term support, making it ideal for production use.
Support Duration and Update Frequency	Supported for six months, with frequent updates and improvements.	Supported for 30 months, with regular updates in the Active LTS phase and critical fixes during Maintenance LTS.
Use Cases	Suitable for development environments and early adopters.	Preferred for production environments and enterprises requiring stable and reliable software.

Practical Example: npx create-react-app vs. npm create vite@latest

When creating a new React application using npx create-react-app, you might encounter compatibility issues with the latest Node.js Current version. On the other hand, npm create vite@latest, a command for initializing a project using Vite, tends to be more up-to-date with the latest Node.js versions. Therefore, if you face issues with create-react-app, it might be safer to use the LTS version of Node.js, which ensures compatibility and stability.

Conclusion

Understanding the differences between the Current and LTS versions of Node.js helps you make informed decisions about which version to use for your projects. While the Current version offers the latest features, the LTS version provides stability and long-term support, making it ideal for production environments.

if you are a newcomer to Node.js, I strongly recommend starting with the LTS version. This will provide you with a stable and reliable environment, allowing you to build a solid foundation. Once you become well-versed in Node.js, you can explore the Current version to take advantage of the latest features and improvements. Choose the version that best fits your project's needs and development stage.

if this article was helpful please share and comment your thoughts on it.

Reference from Wikipedia (https://en.wikipedia.org/wiki/Node.js#:~:text=since%20February%202024-,Node.,and%20later%20sponsored%20by%20Joyent.), Node documentation (https://nodejs.org/en/download/package-manager), V8 Dev(https://v8.dev/) and lastly my favourite AI(ChatGPT(https://chatgpt.com/))

Cypress vs. Selenium: Choosing the Right Automation Tool

Igahsamuel — Wed, 20 Mar 2024 20:02:55 +0000

What is Testing?
Testing is the process of executing a program to find errors. To make our software perform well it should be error-free. If testing is done successfully it will remove all the errors from the software.

Principles of Testing

Start testing with small parts and extend it to large parts.
All the tests should meet the customer’s requirements.
It follows the Pareto rule(80/20 rule) which states that 80% of errors come from 20% of program components. https://www.getclockwise.com/blog/pareto-principle-software-development
All the tests to be conducted should be planned before implementing it

Types of Testing
Basically there are two major types of testing which are :

Manual testing
Automation testing

Manual testing
Manual testingis a technique to test the software that is carried out using the functions and features of an application. In manual software testing, a tester carries out tests on the software by following a set of predefined test cases. In this testing, testers make test cases for the codes, test the software, and give the final report about that software. Manual testing is time-consuming because it is done by humans, and there is a chance of human errors.

Automation testing
Automated Testing is a technique where the Tester writes scripts on their own and uses suitable Software or Automation Tool to test the software. It is an Automation Process of a Manual Process. It allows for executing repetitive tasks without the intervention of a Manual Tester.

Hurry!!! We are finally in automation testing lets dive deep down
Automation testing is divided into three forms

Types of testing
Type of tests
Phase of testing

Under types of testing we have:
functional and Non-functional

under type of test we have :

Smoke test
Regression test
Integration test
Security test
Performance test
Acceptance test

under phase testing we have :

Unit test
API testing
Ul testing

Tools to Use for Your Automated Tests

Selenium
katalon studios
Ranorex
Apache jmeter
Cypress

Finally lets go into the differences between cypress and selenium, but first we have to know them properly
What is Selenium Framework?

Selenium is a testing automation tool that enables developers to automate web browser testing.

The Selenium WebDriver protocol enables sending commands in various development languages — like Java, Java Script, C#, Python, and others — from the test environment (IDEs) to a selected desktop browser (Chrome, Firefox, Edge, Safari).

Selenium is now on version 4.18.1 with great features like :

Full World Wide Web Consortium (W3C) compliance.
Relative locators for more reliable and stable test scripts.
A new integration with CDP (chrome debugging protocol) to extend your test coverage.
New Selenium Grid for robust parallel testing
New Selenium IDE with plugins for Chrome and Firefox browsers

What is cypress Framework?

Cypress a JavaScript-based testing automation solution used for modern web automation that enables teams to create web test automation scripts. The Cypress frameworks also enables frontend developers and test automation engineers to write web JavaScript (the de-facto web language) tests in for web test automation.

Cypress is currently on version 13.7.00 with the following features:

Time travel for real-time debugging of web apps.
Cypress network control.
API testing capabilities.
Innovative component testing capabilities.
A beta version of Cypress Studio as a record and playback solution.
Mocking and stubbing capabilities.
A rich set of plugins to advance test automation coverage, such as AXE for accessibility, test coverage measurements (Istanbul), visual testing, and more.

When considering which tool to use, it’s important to evaluate factors such as the skill level of your development team, the complexity of the web application being tested, the need for cross-browser or mobile testing, and the available budget and resources. Ultimately, the right tool will depend on your specific testing goals and requirements. Here are some general guidelines on Selenium vs Cypress that can help you decide which tool is best for your project.

Choose Cypress if

Your application is a single-page application (SPA)
You prefer a tool that is easy to set up and use
You want a tool that provides real-time reloading and time-travel debugging
You prioritize stable and reliable tests, and value automatic waiting and retrying
You are comfortable with JavaScript and do not require support for multiple programming languages

Choose Selenium if

Your application requires cross-browser testing or mobile device testing
You prefer a more traditional web testing framework that has been around for a long time
You require support for multiple programming languages, such as Java, Python, or C#
You require a more customizable testing tool or want to create and manage tests that are tailored to specific project requirements
You are comfortable with a more complex and feature-rich testing tool and have the resources and expertise to manage and maintain it

Test Framework: Selenium WebDriver

Supported Dev Languages: Java, C#, JavaScript, Python, Ruby, Objective-C

Supported Browsers: Chrome, Safari, Firefox, Edge, IE

Supported Test Frameworks: Mocha JS, Jest, Other super set on top of Selenium (Protractor, WebDriverIO, etc.)

Setup and Execution: Download relevant driver, set up a grid, network and location impacts execution speed

Integrations: Plenty of integrations (CI, CD, reporting, visual testing, cloud vendors)

Breadth of Testing Options: End-to-end, security, unit

Maturity, Documentation, Support: Robust community, multiple bindings, best practices

Test Framework: Cypress.io

Supported Dev Languages: JavaScript, Typescript

Supported Browsers: Chrome, Electron, Edge, Firefox

Supported Test Frameworks: Mocha JS

Setup and Execution: Comes with bundled Chrome browser, no complex environment setup

Integrations: Limited integrations, but many plugins

Breadth of Testing Options: End-to-end

Maturity, Documentation, Support: Good documentation and code sample, growing community

Conclusion
While it is difficult to predict the future of automation, Cypress has gained popularity in recent years due to its modern architecture and comprehensive features. It offers efficient and reliable testing, making it a preferred choice for many developers. However, other frameworks may also continue to evolve and gain popularity, so it is important to keep an eye on the industry and stay up to date with the latest tools and technologies

With all being said we have come to the end of this post. Please like, share and follow and most importantly comment on which testing framework you use and what you think about the post Bye for now see you in the next post

Reference:
Cypress vs Selenium- Which Framework is Best Fit for You? by Shanika Wickramasinghe
Cypress vs. Selenium: What’s the Right Cross-Browser Testing Solution for You? by Eran Kinsbruner
Types of software testing from geeksforgeeks
The Pareto Principle for Software Developers by Alyssa Towns

HOW TO MANAGE MULTIPLE GITHUB ACCOUNTS USING GIT BASH AND SSH

Igahsamuel — Wed, 21 Feb 2024 20:00:19 +0000

INSTALL GIT ON YOUR SYSTEM
Go to your web browser and then install git using the link below and follow the process.
On installing it will also install git bash
https://gitforwindows.org/

Go to your command for those using Macbook and the windows key for those using windows and type git bash and then open it

Generating the SSH Keys
so before you generate a new SSH keys, you have to check if there is an already available SSH keys which you may have installed a long time ago by running this line of code

ls -al ~/.ssh

After running the command it will show the list of available private and public keys as shown in the image below

if not available, then you can run this command

ssh-keygen -t rsa

when asked for the location to save the keys accept the default location by pressing the enter key.

By default the git bash recognizes your personal Github account, you can check that by running the command

git config user.name

git config user.email , to check the username and email .

After generating the SSH keys for your personal github account, you can do the same for the work account or any other account using the command line below

ssh-keygen -t rsa -C "email@work_mail.com" -f "id_rsa_work_user1"

so the "email@work_mail.com" is your work email, the one you used to create the work github account or whatever email you used.
and "id_rsa_work_user1" is your username on github, so it distinguishes between the personal and the work SSH keys

So by now we have two different SSH keys
~/.ssh/id_rsa
~/.ssh/id_rsa_work_user1

Adding the new corresponding SSH key to your Github account
Copy the public key pbcopy < ~/.ssh/id_rsa.pub and then log in to your personal GitHub account:

To see the key on git bash, enter this command

cat ~/.ssh/id_rsa.pub
cat ~/.ssh/id_rsa_work_user1.pub
N/B: id_rsa.pub is the name for your personal SSH key and >id_rsa_work_user1 is name for your work SSH key or the name you used to save it, if it is your username, that's how it will appear

a. Go to Settings
b. Select SSH and GPG keys from the menu to the left.
c. Click on New SSH key, provide a suitable title, and paste the key in the box below
d. Click Add key — and you’re done!

Then do the same thing for your work Github account, if successful github will show a prompt message that you have successfully added your SSH key.

Registering the new SSH Keys with the ssh-agent
Ensure the ssh-agent is running by inputting this command
eval "$(ssh-agent -s)", and will show something like this "Agent pid 1280"

Then add the ssh-agent like this :
ssh-add ~/.ssh/id_rsa
ssh-add ~/.ssh/id_rsa_work_user1

if successfully added it will show something like
identity added : path to where it was added

To check the list of SSH keys in your computer, you can run the command

ssh-add -l
And it will show the list of keys

Creating the SSH config File

$ cd ~/.ssh/
$ touch config // Creates the file if not exists
$ code config // Opens the file in VS code, use any editor

so this creates a mark down file in vs code then you input this values
N/B: make sure that there is no comment else there will be an error

Host personalemail@gmail.com
HostName personalemail@gmail.com
User github username
IdentityFile ~/.ssh/id_rsa

Host workemail@gmail.com
HostName workemail@gmail.com
User github username
IdentityFIle ~/.ssh/id_rsa_work_user1

One active SSH key in the SSH agent at a time **
so as I mentioned above you can use **ssh-add -l to see the list of SSH key in your system or computer. Then you can use ssh-add -D to delete all the keys, then you can add them one by one by using this command in accordance with the github account you want to use at the moment be it personal or work
for personal ssh-add ~/.ssh/id_rsa
for work ssh-add ~/.ssh/id_rsa_work_user1
N/B: "~/.ssh/id_rsa" this is the path it was stored in your computer

The ssh-agent now has the key mapped with the personal GitHub account, and we can do a Git push to the personal repository.

To push to your work GitHub account, change the SSH key mapped with the ssh-agent by removing the existing key and adding the SSH key mapped with the GitHub work account.

Setting the git remote Url for the local repositories
Once we have local Git repositories cloned /created, ensure the Git config user name and email is exactly what you want. GitHub identifies the author of any commit from the email id attached with the commit description.

To list the config name and email in the local Git directory, do git config user.name and git config user.email. If it’s not found, update accordingly.

git config user.name "User 1" // Updates git config user name
git config user.email "user1@workMail.com"
git config --globe user.name "User1"
git config --globe user.email "user1@workMail.com"
N/B: This will add the username and email to the globe

While Cloning Repositories
Note: The next step will help, if we have the repository already available on local.

Now that the configurations are in place, we can go ahead and clone the corresponding repositories. On cloning, make a note that we use the host names that we used in the SSH config.

Repositories can be cloned using the clone command Git provides:

git clone git@github.com:personal_account_name/repo_name.git
The work repository will require a change to be made with this command:

git clone git@github.com-work_user1:work_user1/repo_name.git
This change is made depending on the host name defined in the SSH config. The string between @ and : should match what we have given in the SSH config file.

so for an example I was able to clone the repo of one of my favorite developers JONAS SCHMEDTMANN by using the steps stated above

For Locally Existing Repositories
If we have the repository already cloned:

List the Git remote of the repository, git remote -v

Check whether the URL matches our GitHub host to be used, or else update the remote origin URL.

git remote set-url origin git@github.com-worker_user1:worker_user1/repo_name.git
Ensure the string between @ and : matches the Host we have given in the SSH config.

If you are creating a new repository on local:

Initialize Git in the project folder git init.

Create the new repository in the GitHub account and then add it as the Git remote to the local repository.

git remote add origin git@github.com-work_user1:work_user1/repo_name.git
Ensure the string between @ and : matches the Host we have given in the SSH config.

Push the initial commit to the GitHub repository:

git add .
git commit -m "Initial commit"
git push -u origin master

if this article was helpful please share and comment your thoughts on it.

Reference from Bivil M Jacob from his freecodecamp post, and Jonas Schmedtmann from his complete javascript repo