Forem: Felipe Rocha

Ensuring Consistent Node.js Versions Across Your Team

Felipe Rocha — Mon, 28 Oct 2024 21:55:17 +0000

A Comprehensive Guide to .nvmrc and package.json

In today's dynamic development landscape, managing multiple Node.js versions across various projects can often be a complex and error-prone task. Inconsistent Node.js versions can lead to many issues, from unexpected behavior to complete application failures.

Leveraging `.nvmrc` Files for Version Control

One highly effective method to maintain consistent Node.js versions within a project is by utilizing .nvmrc files. These simple text files, strategically placed at the root of your project directory, specify the precise Node.js version required.

Creating a `.nvmrc` File:

Navigate to your project's root directory and create a new file named .nvmrc witn the desired Node.js version:

echo 18.16.10 > .nvmrc

Switching to the Correct Version with nvm use

Once the .nvmrc file is in place, you can effortlessly switch to the specified Node.js version using the nvm use command. This command triggers NVM (Node Version Manager) to activate the designated version.

Using the `nvm use` Command:

Navigate to your project's root directory in your terminal and execute the following command:

nvm use

Found '/Users/**/.nvmrc' with version <v18.16.10>
Now using node v18.16.10 (npm v10.8.3)

NVM will automatically detect the .nvmrc file and switch to the specified version.

Setting the Engine Version in `package.json`

While .nvmrc files are incredibly effective, it's also advisable to explicitly declare the required Node.js version in your package.json file. This provides an additional layer of clarity and can be leveraged by various tools and services that rely on the package.json file for essential information.

Setting the Engine Version in package.json:

Open your package.json file in a text editor.
Add or modify the engines field to specify the Node.js version:

{
  "name": "your-project-name",
  "version": "1.0.0",
  "engines": {
    "node": "18.16.0"
  }
}

Best Practices for Node.js Version Management:

Centralized Version Control: Utilize a robust version control system like Git to manage .nvmrc files and ensure consistency across your entire team.
Regular Updates: Keep NVM and Node.js updated to the latest stable versions to benefit from security patches and performance enhancements.
Clear Documentation: Provide comprehensive instructions on how to set up the development environment, including Node.js version management.

Installation

The clearest instructions for installation can be found in the official nvm documentation. Let me know if you encounter any difficulties.

Conclusion

By adhering to these best practices and effectively utilizing .nvmrc files and package.json configuration, you can significantly enhance the consistency of your Node.js projects and save a precious time that would be spent.

Mastering Version Management in Node.js

Felipe Rocha — Sun, 20 Oct 2024 14:20:31 +0000

As developers, we frequently encounter projects that demand different Node.js versions. This scenario is a pitfall for both fresh and experienced developers who may not be regularly involved in Node.js projects: ensuring the correct Node.js version is used for each project.

Before installing dependencies and running a project, it's crucial to verify that your Node.js version matches or is at least compatible with the project's requirements. Failure to do so can result in a barrage of errors and warnings in your terminal, consuming valuable time in troubleshooting. Fortunately, there's a solution: version managers.

What is a Version Manager?

A version manager is a software tool that allows you to effortlessly install, switch between, and remove different versions of programming languages. Here are some popular examples for various languages:

Node.js: nvm
Ruby: rbenv, rvm, chruby
Java: jabba
PHP: phpenv, phpbrew
Python: pyenv
Multi-language: asdf (command-line tool)

The Node Version Manager

nvm, specifically designed for Node.js, allows you to seamlessly install and switch between different Node.js versions directly from your command line. It's a per-user installation and works with various POSIX-compliant shells (sh, dash, ksh, zsh, bash) on Unix-based systems, macOS, and Windows WSL.¹

Let's explore some use cases from the official nvm repository:

node -v
v16.9.1

$ nvm use 14
Now using node v14.18.0 (npm v6.14.15)

$ node -v
v14.18.0

$ nvm install 12
Now using node v12.22.6 (npm v6.14.5)

$ node -v
v12.22.6

In this example, we see how to:

Check the current Node.js version (node -v).
Switch to Node.js version 14 (nvm use 14).
Verify the switched version (node -v).
Install Node.js version 12 (nvm install 12).
Confirm the newly installed version (node -v).

In the next article, I'll provide a straightforward guide on how to install nvm and effectively define specific Node.js versions using .nvmrc files.

Conclusion

Utilizing a version manager for your projects is a critical time-saving strategy that ensures smooth development workflows. It's an essential tool for any developer's toolbox.

What's your preferred solution for handling these situations? Share your thoughts in the comments below!

References

https://github.com/nvm-sh/nvm

8 Most Valuable Lessons I Learned in 5 Years as a Software Engineer

Felipe Rocha — Mon, 09 Sep 2024 21:08:27 +0000

I recently shared an article that I found incredibly inspiring. It featured a young software engineer reflecting on the key lessons they had learned after 35 years in the profession.

Reading that piece made me ponder the lessons I might share when my time comes. But before that, I honestly wondered if my time would ever come. A 35-year career is quite a long journey, and since I started a bit later in life, at 26, I'd be over 60 by the time I reached that milestone.

Perhaps I won't make it that far, or perhaps I will and simply forget to write about it. So, I figure it's best to start putting my thoughts down now, so that my future self can simply review and refine them. It's a way to lighten the load for my future self. Let's dive in:

Life is More Than Coding

Life extends beyond coding. To be a productive developer, you need to maintain both physical and mental well-being. Over these past 5 years, I've met great engineers with diverse hobbies that help them stay healthy. Soccer players, rock climbers, weightlifters, runners, swimmers, those who play volleyball or practice jiu-jitsu. Some also frequently attend parties, music concerts, enjoy the beach, or travel to exciting destinations.

The Profession is More Than Coding

Even the profession itself encompasses much more than coding. You need to understand your company's business and your team's goals. It's crucial to understand how your work contributes to achieving these objectives. As you gain experience, you'll share your knowledge with less experienced engineers or even guide another developer through a project they've never worked before. After spending some time at the company, you'll be recognized as an engineer with deep insights into the business. People from other departments will seek your perspective as an engineering expert.

It's Not Enough to Do, You Have to Show

It's not about boasting about your accomplishments. It's about ensuring that everyone understands what you can deliver, the challenges you've overcome, and your resilience as a software engineer. Maintain clear and active communication about your tasks, both in writing and verbally. And lastly, continue to track the impact of your work after the release.

Together We Go Further

We all know that people are paid to do their jobs, but they'll do them better and faster if they like you. Build positive relationships with others, respond to them as promptly as you'd like to be responded to. Treat them the way you'd want to be treated. And lastly, work correctly. I don't know anyone who hasn't built strong professional relationships by following this principle.
In fact, I landed my current job building good relationships. A former manager of mine was hiring and knew I was seeking a new challenge. He contacted me and soon I was hired..

You Drive Your Career

Managers and more experienced engineers can provide guidance to help you reach your goals. However, they won't do the work for you. Remember, this is YOUR career, YOUR future, and it will likely unfold far away from them. So, don't leave it in someone else's hands. Develop a solid career plan and review it periodically. Within your current company or team, seek out opportunities that align with your learning objectives. If you feel stagnant, ask for feedback, re-evaluate your plan, and ensure you're actively working towards your goals. Don't hesitate to revise your plan as needed, but never blame others for your lack of progress.

Deadlines are Dangerous

Early in my career, I started estimating deadlines before I truly knew how. I vividly recall being introduced to planning poker and assigning estimates to tasks in the most random way imaginable. If you're unfamiliar with it, I strongly recommend reading the chapter on estimation in "The Pragmatic Programmer" or at least an article inspired by it. Missed deadlines are like snowballs of problems for the team.

Be a Problem Solver

I believe this is the hardest skill to master, yet it's the one that can propel you to the next level the fastest. We're paid to solve problems, not to create them. How about trying to resolve your own issues before complaining in a daily meeting? Take initiative and do what needs to be done. If you need help unblocking your tasks, ask for it as soon as possible. If you're waiting too long for a response, politely follow up with the person. Having issues with another developer? Reach out to them and align your work. No one is reviewing your pull requests? Don't wait too long; send a gentle reminder. It's all about perspective. Approach problems as challenges and savor the endorphin rush of overcoming them.

Conclusion

I'm convinced that articles like this serve as invaluable compasses, guiding us on our professional journeys. That's precisely why I'm constantly seeking out the wisdom and insights of seasoned engineers.

The most profound aspect of these lessons lies in their universality. They transcend the boundaries of software engineering, offering profound insights applicable to both our personal lives and a multitude of other professions. These lessons encapsulate timeless principles that empower us to navigate challenges, foster growth, and achieve success in all facets of our lives.

Let me know if you have any other sections you'd like me to refine or any further questions!

8 Real-Life Shell Functions to Boost Your Productivity

Felipe Rocha — Thu, 15 Aug 2024 21:35:51 +0000

Introduction

Shell functions are powerful tools that allow you to automate tasks, streamline your workflow, and boost productivity by reducing repetitive manual work.

Many developers are familiar with shell scripting, but it’s not common to see them using it to enhance their productivity. Perhaps all that's missing is a bit of creativity.

In this article, I’m sharing 8 functions that I use daily to help with my work tasks. I hope they inspire you to create your own functions and boost your productivity. For the examples below, I'm using ZSH.

1: Push in Dev Environment

It's common for me to need to test my local branch in the development environment. To switch and merge branches faster, I’m currently using the following function:

function merge_dev {
  BRANCH=$(git branch --show-current);
  git checkout dev;
  git fetch -pa;
  git reset --hard origin/dev;
  git merge $BRANCH;
  echo Done! Now, finish the merge and push the changes.
}

The git push command is intentionally left out of the merge_dev function because I often need to resolve conflicts before pushing, so I decided to keep it separate.

2: Git Rebase

Similar to Function 1, this function is useful when I need to switch branches and run another git command. To make this process faster, I created the rebase function:

function rebase {
    BRANCH=$(git branch --show-current);
    git checkout $1;
    git pull;
    git checkout $BRANCH;
    git rebase $1;
}

# usage example
rebase master

3: Shortcut for ZSH Config Files

I’m always creating new functions or updating old ones, and I never seem to remember the path to my .zshrc files 😂.

function config {
  # Check if parameter is null
  if [ -z $1 ]; then 
    code "$HOME/.zshrc"
    return
  fi

  case "$1" in
    alias )
      code "$HOME/CUSTOM_ZSH/.alias.sh"
    ;;
    func )
      code "$HOME/CUSTOM_ZSH/.functions.sh"
    ;;
    * )
      echo "$1 is not a valid parameter for config function"
    ;;
  esac
}

# usage example
config func

4: Set Upstream and Open Repo

It’s very annoying to try pushing a branch that doesn't exist in the remote repository. To save myself from this hassle, I use the gpp function to automatically add the --set-upstream flag when needed. I also open the remote repo in a browser because I usually create a PR after pushing a new branch.

function gpp {
  BRANCH=$(git branch --show-current);
  ORIGIN="origin"

  git push
  RESULT=$?

  if [[ $RESULT != 0 ]]; then
    GIT_PUSH_OUTPUT=$(git push --set-upstream $ORIGIN $BRANCH 2>&1)
    echo $GIT_PUSH_OUTPUT

    REPO_NAME=$(pwd | awk -F/ '{print $NF}')
    open "https://github.com/feliperocha93/$REPO_NAME"
  fi
}

5: Fast PR

Building on Function 4 and taking advantage of ZSH aliases, when I need to open a PR with a single commit, I save time using the fast_pr function:

function fast_pr {
  gaa;
  gcmsg "$1";
  gpp;
}

# usage example
fast_pr "chore: update zsh function"

6: Get and Export Credentials

This is probably the most complex and time-saving function in this series of 8 functions. The variables are somewhat masked since it’s not necessary to show their real names, but the example should be sufficient to explain the concept.

Basically, the application I usually run locally accesses several databases that require authentication. The application retrieves the credentials from environment variables.

To handle this, the get_credentials function authenticates me via the command line and saves the credentials as environment variables.

function get_credentials {
  # some command to get credentials
  credentials=$(foo --bar); 

  # in this example, credentials is a string like 
  # username:username password:password 
  # and awk method are extracting the value

  export USERNAME=$(echo $credentials | awk -F'username: ' '{print $2}' | tr -d '[:space:]');
  export PASSWORD=$(echo $credentials | awk -F'password: ' '{print $2}' | tr -d '[:space:]');

  export REDIS_HOST=localhost
  export REDIS_PORT=6379

  echo $USERNAME $PASSWORD
}

7: Install Dependencies

When working on a project after a long time, it's important to update the dependencies to avoid some incompatibility problems during development. So I always try to keep my local branch up to date with master branch.

function start {
  BRANCH=$(git branch --show-current);

  function update_and_install {
    git pull;
    nvm use;
    npm ci;
  }

  if [ $BRANCH != 'master' ]; then
    git checkout master;
    update_and_install;
    git checkout $BRANCH;
    return;
  fi

 update_and_install;
}

BONUS: Alias

I know aliases aren't exactly functions, but they can help you save some time. In the examples below, I use some aliases to execut frequent commands with short words.

# browse to folder
alias deployments="cd ~/Documents/deployments"
alias feliperocha="cd ~/Documents/feliperocha"

# browse to folder and list projects
alias projects="cd $HOME/Documents/projects && ls -a"

# open a specific folder
alias XPTO="cd ~/Documents/XPTO; open ."

Conclusion

Thank you for reading until the end. My intetion in sharing these functions to open your mind and spark your criativity to create your own functions and boost your daily productivy.

Leave a comment below sharing which function was your favorite or post your own.

Bests regards,

Forem: Felipe Rocha

Ensuring Consistent Node.js Versions Across Your Team

Leveraging .nvmrc Files for Version Control

Creating a .nvmrc File:

Switching to the Correct Version with nvm use

Using the nvm use Command:

Setting the Engine Version in package.json

Setting the Engine Version in package.json:

Best Practices for Node.js Version Management:

Installation

Conclusion

Mastering Version Management in Node.js

What is a Version Manager?

The Node Version Manager

Conclusion

References

8 Most Valuable Lessons I Learned in 5 Years as a Software Engineer

Life is More Than Coding

The Profession is More Than Coding

It's Not Enough to Do, You Have to Show

Together We Go Further

You Drive Your Career

Deadlines are Dangerous

Be a Problem Solver

Conclusion

8 Real-Life Shell Functions to Boost Your Productivity

Introduction

1: Push in Dev Environment

2: Git Rebase

3: Shortcut for ZSH Config Files

4: Set Upstream and Open Repo

5: Fast PR

6: Get and Export Credentials

7: Install Dependencies

BONUS: Alias

Conclusion

Leveraging `.nvmrc` Files for Version Control

Creating a `.nvmrc` File:

Using the `nvm use` Command:

Setting the Engine Version in `package.json`