DEV Community: Eduardo Donato

Transforming my Resume into an Interactive Terminal Business Card using NPM 🚀

Eduardo Donato — Sun, 08 Feb 2026 04:18:35 +0000

I decided to transform my resume and contact information into something more "dev-friendly": an interactive business card that runs directly in the terminal.

This new version is actually a complete rewrite of a similar project I developed a while back in the npx_card repository. I chose to archive the old project and start from scratch to build something more robust and organized, which resulted in the new card-tui.

The idea is simple: instead of sending a PDF or a standard portfolio link, I can just say:

"Got Node installed? Just run npx ebdonato in your terminal."

💡 The Inspiration

The project was originally inspired by anmol098/npx_card. It turned the networking experience into something playful and technical at the same time. I’m not sure if he came up with the original idea, but it’s brilliant nonetheless.

🛠️ How to use

To view the card, you don't need to install anything permanently. As long as you have Node.js installed, just run:

npx ebdonato

🏗️ What's under the hood?

To build card-tui, I used (well, the AI used) some classic Node.js CLI libraries:

Inquirer.js: To create the interactive menu.
Boxen: To create that sleek border around the information.
Chalk: To add color to the terminal and highlight links and job titles.
Marked: To render the Markdown content.
Open: To trigger and open links in the user's default browser.

🚀 Why do this?

Beyond being a creative way to introduce yourself, developing an NPM package focused on a TUI (Terminal User Interface) helps you understand:

Package publishing and versioning on the NPM registry.
Handling input and output streams in Node.js.
Design focused on constraints (the terminal is limited, which forces simplicity).

The code is open-source on my GitHub for anyone who wants to use it as a template for their own: ebdonato/card-tui.

Stop Nesting Try/Catch: How I Turned a Repetitive Pattern into an NPM Package (promise-tuple)

Eduardo Donato — Sat, 31 Jan 2026 20:14:18 +0000

Recently, I noticed that in almost every project, I was writing the same utility to handle Promises. I decided it was time to stop copy-pasting code and published a npm package: promise-tuple.

The Motivation

You know those times when you need to run several asynchronous calls in sequence, but each one requires specific error handling? The traditional try/catch pattern often results in "staircase code" or multiple variables declared with let outside the block just so they can be accessed later.

Example of the "problem":

let user;
try {
  user = await fetchUser();
} catch (err) {
  return handleUserError(err);
}

let posts;
try {
  posts = await fetchPosts(user.id);
} catch (err) {
  return handlePostError(err);
}

The Solution: The Tuple Pattern

Inspired by languages like Go, the idea is to always return a tuple (a fixed array) containing [data, error]. If an error occurs, it’s populated; otherwise, you have your data.

Using promise-tuple, the code above looks like this:

import promiseTuple from 'promise-tuple';

const [user, userErr] = await promiseTuple(fetchUser());
if (userErr) return handleUserError(userErr);

const [posts, postsErr] = await promiseTuple(fetchPosts(user.id));
if (postsErr) return handlePostError(postsErr);

Why use it?

Readability: The error flow is explicit and sits right next to the function call.
Native TypeScript: The package was built with type inference in mind, so both data and error are correctly typed.
Minimalist: Zero external dependencies and extremely lightweight.

Final Thoughts

I know there are other libraries that do similar things, but building my own allowed me to tailor it exactly to my needs and, in the process, give back to the community.

Check it out here: https://www.npmjs.com/package/promise-tuple

Bringing the Linux "touch" Command to Windows with a PowerShell Module

Eduardo Donato — Thu, 29 Jan 2026 03:52:23 +0000

If you frequently switch between Linux/macOS and Windows, or if you've recently migrated to Windows, you've likely experienced the frustration of opening PowerShell, instinctively typing touch file.txt, and being hit with a "command not found" error.

While PowerShell has the native New-Item cmdlet, its syntax isn't as fluid or intuitive for daily use as the simple touch command. To solve this and maintain my muscle memory, I developed the TouchCMD module and made it available on the PowerShell Gallery.

The Motivation

On Windows, the standard way to create an empty file via the terminal is:

New-Item -ItemType File file.txt

Even with the ni alias, it still requires more effort than it should. On Linux, touch is universal, simple, and direct. I wanted that same seamless experience in PowerShell without having to rely on WSL or Git Bash for basic file manipulations.

Inspiration

The idea gained momentum after reading this post by Cassidy Williams, where she shares a simple function to emulate this behavior. I decided to take that concept and package it into a properly structured PowerShell module, making it easier to install and ensuring it persists across terminal sessions.

How to Install

Since it is published on the PowerShell Gallery, you can install it quickly with the following command:

Install-Module -Name TouchCmd -Scope CurrentUser

Alternatively, you can clone the repository directly from GitHub.

Usage Examples

The goal is to mirror the simplicity of the original command:

Create a new file

touch C:\path\to\newfile.txt

Update the timestamp of an existing file

touch C:\path\to\existingfile.txt

Using the pipeline

"file1.txt", "file2.txt", "file3.txt" | touch

Conclusion

This is a simple project, but it removes a constant point of friction for developers working across multiple operating systems.

The code is open source, and contributions are more than welcome! If you use Windows and miss this convenience, feel free to check out the repository:

🔗 GitHub: ebdonato/touch-powershell

Translated using AI, original in Portuguese: tabnews

11 useful websites

Eduardo Donato — Tue, 25 Nov 2025 22:00:20 +0000

Here is the list of 11 useful websites:

Pairdrop

Instantly share files between your devices, no apps or sign-up required. You can connect via local network or create a public room and easily share files.

Vert

Fast, unlimited, free, and open-source file converter. Supports images, audio, video, and documents, with advanced options and privacy focus.

Enclosed

For creating self-destructing notes and sharing them with encryption. You can set password, expiration, and delete-after-read settings.

Sumo Paint

Free online image editor, with advanced features similar to Photoshop and support for PSD files directly in the browser.

Screenrec Pro

Record and edit your screen in the browser, no need to install programs. Offers live annotation tools and easy video sharing.

Poindeo

Tool for recording, editing, and exporting videos entirely online. Supports automatic subtitles and exports in various formats.

Atomic Mail

Provides secure and encrypted email, ad-free, easy to set up and maintain. The service is free, with paid aliases option.

Bento PDF

Complete toolkit for handling PDFs right in your browser, with merge, split, sign, compress, and edit. Works offline and is open-source.

DeWatermark AI

Automatically removes watermarks from photos using AI. Simply upload the image, edit if needed, and download the clean version.

Magic Eraser

Remove unwanted objects from your images with AI directly in the browser — just select and erase.

TTS Maker

Convert text to audio for free, in various languages and with customizable voices. Allows adding background music and adjusting audio speed.

These sites focus on productivity, privacy, and ease of use, many being free and open-source, as presented in this video.

Desestruturação para variáveis já existentes

Eduardo Donato — Sun, 02 Jan 2022 19:44:35 +0000

É possível utilizar desestruturação para variáveis ao invés de sempre criar novas.

Por exemplo, caso tenhamos um objeto como o a seguir:

const user = { name: "Eduardo", age: 39 };

Podemos fazer a desestruturação com a seguinte sintaxe:

const { name, age } = user;

console.log(name); // Eduardo

console.log(age); // 39

Porém se as variáveis name e age já tiverem sido declaradas no mesmo escopo, será necessário desestruturar e renomear ao mesmo tempo:

const { name: newName, age: newAge } = user;

console.log(newName); // Eduardo

console.log(newAge); // 39

Para atribuir a desestruturação para as variáveis declaradas anteriormente, utiliza-se a seguinte sintaxe (parênteses na declaração):

let name = "Fulano",
  age = 22;

({ name, age } = user);

console.log(name); // Eduardo

console.log(age); // 39

Atualização: também funciona com arrays. Inclusive, nesse caso, utilizando ; no fim das sentenças, não é necessário o parênteses.