DEV Community: Carlos Nah

Lost Skills We Sold for Convenience Over Commitment

Carlos Nah — Sun, 29 Mar 2026 11:49:29 +0000

In an era where AI can write your code and your essays, is struggle still a virtue? We have traded the slow, painful process of learning for the instant gratification of a prompt. But in doing so, we might be trading away our mastery. This is a reflection on the lost skills of tech: the patience to sit with a bug, the grit to research deeply, and the commitment required to truly own your work.

TL;DR

Efficiency vs. Expertise: We have optimized for speed, but we have stopped optimizing for understanding.
Desirable Difficulty: True learning requires a level of struggle that convenience tools often remove.
The Mission: Tech is about more than code. It is about solving problems, teaching others, and making an impact.

How are we even supposed to write a piece like this in this day and age?

We live in an age where we have slowly lost the touch of technical writing and the ability to truly pour out our thoughts. It has reached a point where those who can still do this effortlessly are labeled as "gurus" or "subject matter experts."

But were they always that rare, or did we just stop trying?

Nowadays, a few prompts can get you dangerously close to an expert level with little to no effort. We have entered an era where it is becoming harder to tell who is who anymore. The lines are blurred. Authenticity is fading. That is the scary part.

There was a time when writing something meaningful took hours or even days. Drafts, edits, re-edits, and starting over. That process was not just about producing content. It was about becoming a better thinker. Today, tools like ChatGPT and GitHub Copilot have changed the game. They are powerful. They accelerate learning and reduce friction.

But here is the uncomfortable truth: convenience is quietly replacing commitment. When that happens, depth starts to suffer.

The Early Spark

I come from an era where curiosity was the key ingredient that fueled passion. Even though learning happened in classrooms, real growth came from intentional research. We filled knowledge gaps on our own with the hope of becoming better quizzers and worthy opponents. It was not just about answering questions. It was about the reputation you built and the value that came with it.

Even though my school failed me in many ways, it was never enough to stop me from wanting to be better. There was pride in being called a quizzer or a historian. I cannot even begin to emphasize the volume of books I went through: world history, regional events, and stacks of current affairs.

You had to know things.

You had to memorize capitals and presidents so that when a moderator said, "In China, Mao Zedong..." the bells were already ringing. Everyone was racing to complete the question. That moment of tension and readiness meant something. It speaks to the challenging nature of the human spirit. We were wired to seek, to struggle, and to earn our knowledge.

Now, that skill is slowly fading. I no longer have to search for a geography book or sit with the material long enough to truly understand it. Back then, the process taught you things you would never forget. Those discoveries felt personal. They were secrets earned only by those who put in the time.

Today, everything is handed to you instantly. No retention. No struggle. No deep attachment to the skills once respected among scholars. Maybe that is what we have really lost.

My Journey Into Tech

My journey into tech was never just about the code. It was driven by a deeper desire to solve problems, to teach what I had discovered, and to make a tangible impact. Bringing ideas to life through syntax was simply the medium. I wanted to build things that mattered and help others navigate the same complexities I was facing.

And yes, sometimes it would break. Badly.

There were moments when a bug would take hours or even days to figure out. You would reach those pauses where you were not even coding anymore. You were just living life. You would be talking to a friend or standing in the shower when it finally hit you: "I just needed to remove that curly bracket from line 54."

That moment. That spark. That click.

You do not forget it because you earned the solution. We did not just get attached to the ideas. We got attached to the process. With that came accountability. There is a certain pride in saying, "I figured out the bug we were struggling with." It is about the fact that you stayed with the problem long enough for it to reveal itself to you.

That patience is fading. We are moving toward a world where the "human debugger" is becoming less relevant. Instead of thinking through problems, we throw our styles and patterns into an AI and wait for something usable to come back.

Convenience over craftsmanship.

We no longer sit with the problem. We no longer struggle. You can simply pay for high-tier tools, prompt your way through a few iterations, and get something that works.

The Shift We Do Not Talk About Enough

I remember how many times I thought about being published by freeCodeCamp. My growth as a developer started there. It was not just a platform. It was a proving ground. I wanted to contribute and say, "I have learned something, and here is my voice."

But every time I had an idea, I would find that someone had already written about it. That stalled me. Looking back, I realize that hesitation was part of the journey. It forced me to think deeper. It demanded originality.

While not everything published back then was perfect, there was a level of rigor involved. There was weight to putting your name on something. It felt even harder coming from a place and a country that is not always recognized in these global spaces. You had to earn your voice.

Now, success is becoming about who has access to better tools and more tokens. Blocks of code appear instantly, but they often carry no real connection to the person using them. No struggle. No story. No depth.

This raises a question we are not asking enough: If everything is easier to produce, what becomes harder to prove?

What We Might Be Losing

This is not an attack on technology. Tools have always evolved. From calculators to IDEs and from Stack Overflow to AI assistants, we have always built things to make life easier. But there is a difference between using tools and losing yourself to them.

Psychologists often discuss "desirable difficulty," a concept popularized by Robert A. Bjork. The idea is simple: some level of struggle is necessary for deep learning. If you remove that struggle entirely, you may gain speed, but you lose mastery.

That is where we are now. We have optimized for speed and output. Somewhere along the way, we stopped optimizing for understanding.

Closing Thought

Perhaps this feels reflective or even uncomfortable. That is good. Not everything should be easy. Not everything should be instant.

We have gained power through tools like ChatGPT and Claude, but we are trading away something quieter: patience, depth, and ownership. The part of us that sits with a problem and refuses to quit is where mastery lives.

The question is not whether these tools are good or bad. The question is what kind of builder, thinker, or writer you choose to be in a world where everything can be done for you.

Convenience will get you results. Commitment is what makes the work yours.

Simplifying Data Table Management with EzyTables

Carlos Nah — Wed, 18 Oct 2023 00:06:53 +0000

Data tables are a fundamental component of many web applications. They help organize, display, and manage tabular data efficiently. Regardless of the framework or library you're using, managing data tables can sometimes be a challenging task. To address these challenges and simplify data table management, we introduce EzyTables, a minimalist JavaScript library.

In this blog post, we'll explore the benefits of using EzyTables and demonstrate how it can enhance data table handling in a framework-agnostic context.

The Challenges of Data Table Management

Managing data tables in web applications comes with a set of common challenges:

Reactivity: Ensuring that your data table updates and reflects changes promptly, such as sorting, filtering, or searching.
Complexity: Writing and maintaining custom code for data table functionality can quickly become complex and hard to manage.
Performance: As your dataset grows, handling rendering, sorting, and filtering efficiently can be a performance bottleneck.
Data Fetching: When working with remote data sources, fetching data from a server and integrating it into your data table can be a significant challenge.

Meet EzyTables

EzyTables is a lightweight, framework-agnostic JavaScript library that simplifies data table management. It offers several key features:

Reactivity: EzyTables leverages the reactivity system to ensure that your data table automatically updates when data changes. Whether it's sorting, searching, or filtering, your table stays up-to-date.
Simplicity: Creating and managing data tables becomes effortless with EzyTables. It eliminates the need for intricate custom code, allowing you to set up a data table with minimal effort.
Customization: While EzyTables provides essential data table functionality, it also allows for customization. You can define your rendering logic, ensuring that your data table looks and behaves exactly as you want.
Pagination: EzyTables includes built-in support for pagination. This makes it easy to handle large datasets while maintaining optimal performance.
Server-Side Data Fetching: If your application requires data from a server, EzyTables can handle server-side data fetching efficiently, while still providing a smooth user experience.

Using EzyTables in a Framework-Agnostic Context

EzyTables is designed to be framework-agnostic, which means you can use it with any web framework or even without one. Let's take a look at a simple example of using EzyTables in a framework-agnostic context:

<!DOCTYPE html>
<html>
  <head>
    <title>EzyTables Example</title>
  </head>
  <body>
    <div class="table-controls">
      <label for="limitSelect">Show</label>
      <select id="limitSelect">
        <option value="10">10</option>
        <option value="20">20</option>
        <option value="50">50</option>
      </select>
      <label for="searchInput">Search</label>
      <input id="searchInput" placeholder="Search..." />
    </div>
    <table id="myTable">
      <thead>
        <tr>
          <th>Name</th>
          <th>Description</th>
          <th>Status</th>
          <th>Date</th>
        </tr>
      </thead>
      <tbody></tbody>
    </table>
    <div class="pagination">
      <button id="prevButton">Prev</button>
      <button id="nextButton">Next</button>
    </div>
    <p id="paginationInfo"></p>

    <script type="module">
       import { EzyTables } from 'https://esm.run/ezytables';
    </script>
    <script>
      const data = [
        {
          name: "John Brown",
          description:
            "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec auctor, nisl eget ultricies aliquam, nunc nisl aliquet nunc, vitae aliquam nisl nunc eu nisi. Sed vitae nisl eget nisl aliquam aliquet. Sed vitae nisl eget nisl aliquam aliquet.",
          status: "Active",
          date: "2020-01-01",
        },
        {
          name: "Jane Abram",
          description:
            "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec auctor, nisl eget ultricies aliquam, nunc nisl aliquet nunc, vitae aliquam nisl nunc eu nisi. Sed vitae nisl eget nisl aliquam aliquet. Sed vitae nisl eget nisl aliquam aliquet.",
          status: "Active",
          date: "2020-01-01",
        },
        {
          name: "Sam Smith",
          description:
            "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec auctor, nisl eget ultricies aliquam, nunc nisl aliquet nunc, vitae aliquam nisl nunc eu nisi. Sed vitae nisl eget nisl aliquam aliquet. Sed vitae nisl eget nisl aliquam aliquet.",
          status: "Active",
          date: "2020-01-01",
        },
        {
          name: "Ekaterina Tankova",
          description:
            "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec auctor, nisl eget ultricies aliquam, nunc nisl aliquet nunc, vitae aliquam nisl nunc eu nisi. Sed vitae nisl eget nisl aliquam aliquet. Sed vitae nisl eget nisl aliquam aliquet.",
          status: "Active",
          date: "2020-01-01",
        },
        {
          name: "Tom Winter",
          description:
            "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec auctor, nisl eget ultricies aliquam, nunc nisl aliquet nunc, vitae aliquam nisl nunc eu nisi. Sed vitae nisl eget nisl aliquam aliquet. Sed vitae nisl eget nisl aliquam aliquet.",
          status: "Active",
          date: "2020-01-01",
        },
        {
          name: "Sandra Jones",
          description:
            "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec auctor, nisl eget ultricies aliquam, nunc nisl aliquet nunc, vitae aliquam nisl nunc eu nisi. Sed vitae nisl eget nisl aliquam aliquet. Sed vitae nisl eget nisl aliquam aliquet.",
          status: "Active",
          date: "2020-01-01",
        },
        {
          name: "Molly Summer",
          description:
            "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec auctor, nisl eget ultricies aliquam, nunc nisl aliquet nunc, vitae aliquam nisl nunc eu nisi. Sed vitae nisl eget nisl aliquam aliquet. Sed vitae nisl eget nisl aliquam aliquet.",
          status: "Active",
          date: "2020-01-01",
        },
        {
          name: "Mark Winter",
          description:
            "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec auctor, nisl eget ultricies aliquam, nunc nisl aliquet nunc, vitae aliquam nisl nunc eu nisi. Sed vitae nisl eget nisl aliquam aliquet. Sed vitae nisl eget nisl aliquam aliquet.",
          status: "Active",
          date: "2020-01-01",
        },
        {
          name: "Cindy Jones",
          description:
            "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec auctor, nisl eget ultricies aliquam, nunc nisl aliquet nunc, vitae aliquam nisl nunc eu nisi. Sed vitae nisl eget nisl aliquam aliquet. Sed vitae nisl eget nisl aliquam aliquet.",
          status: "Active",
          date: "2020-01-01",
        },
      ];

      const customRender = (data) => {
        // Replace this with your custom rendering logic
        const tableBody = document.querySelector("#myTable tbody");
        tableBody.innerHTML = "";
        data.forEach((item) => {
          const row = document.createElement("tr");
          row.innerHTML = `
            <td>${item.name}</td>
            <td>${item.description}</td>
            <td>${item.status}</td>
            <td>${item.date}</td>
          `;
          tableBody.appendChild(row);
        });

        // Display pagination info
        const pageInfo = document.querySelector("#paginationInfo");
        pageInfo.textContent = `${easyTable.getShowingInfo()}`;
      };


      const easyTable = new EzyTables({
        data,
        perPage: 3,
        renderFunction: customRender,
        clientEnabled: true,
        client: {
            perPage: 3,
        }
      });

      const searchInput = document.querySelector("#searchInput");
      searchInput.addEventListener("input", () => {
        easyTable.setSearchDebounced(searchInput.value);
      });

      const prevButton = document.querySelector("#prevButton");
        prevButton.addEventListener("click", () => {
            easyTable.prevPage();
        });

        const nextButton = document.querySelector("#nextButton");
        nextButton.addEventListener("click", () => {
            easyTable.nextPage();
        });
    </script>
  </body>
</html>

In this example, EzyTables is included as a JavaScript file, and an instance of EzyTables is created to manage the data table. The HTML structure is simple, and the logic is kept minimal, showcasing the ease of integrating EzyTables into a framework-agnostic context.

Conclusion

Data table management in web applications can be simplified and made more efficient with EzyTables. Its reactivity, simplicity, and customization options make it a valuable addition to your web development toolkit, regardless of the framework or library you're using. Give it a try, and you'll find that handling data tables has never been easier. EzyTables opens up new possibilities for efficient and elegant data table solutions in your web applications.

Head over to their documentation for more information and example here.

My new npm package RademeJs

Carlos Nah — Wed, 06 May 2020 11:29:13 +0000

Howdy world, today I am excited to recommend you to this wonderful npm package called rademe-js.

I created this package to help professional developers and beginners as well to stop repetitive tasks and use each features of the language wisely.

Problems

Many at times you will want to loop through an array or an object, it may also be a way to check the type of each data types or maybe to create a html element or some cool helper methods that you keep on repeating yourselves.

These things have happened to me at my job and I decided that why not make each helper methods into a reusable code or function that I can use in whatever project I am doing and this started to get great and I enjoyed those moments.

Now I have decided to make these simple helper methods available to every one and am open to contributions.

There are some cool helper methods you find in this package that you will add to your project for fast development.

I will love to hear what you think about this project and what new features should be added or if you find a bug my DM is always open or contact me through my mail cnah27@gmail.com

Happy Coding,
Have an awesome day

Comparing Arrays using isArrayEquals() method

Carlos Nah — Tue, 21 Jan 2020 22:56:58 +0000

JavaScript is a great language that has endured a long struggle over the years. Yet it continues to shine despite all the criticisms.

In this regard, I have decided to compare two arrays and see if they are equal. Equal in the sense of length and element within the array. In so doing I also take into consideration that the order of the elements doesn't matter.

Here is my code below:

 const isArrayEquals = (arr1, arr2) => {
     let count = 0;
     for(let i = 0; i < arr1.length; i++) {
        for(let j = 0; j < arr2.length; j++) {
           if(arr1[i] == arr2[j]) {
                count++
           }
     }   
 }

 return  arr1.length == arr2.length && count == arr1.length ? true : false;
}


console.log(isArrayEquals([1, 2, 3, 4, 5], [1, 2, 5, 3, 4])) // true
console.log(isArrayEquals(["me", "you", "us"], ["us", "me"])) // false
console.log(isArrayEquals([], [])) // true

Well this might not be the best way to implement this but I think it will help in the process.

I've also implemented this and some other helper methods into a npm package called rademe-js.

Hope it helps and someday we might have Array.equals implemented into ECMA TC39 specification.

Year In Review 2019

Carlos Nah — Fri, 20 Dec 2019 01:19:10 +0000

Howdy, everyone, it has been a while since I last wrote an article to share my experiences with this wonderful community.
This year marked a remarkable memory in my life and I am so much excited to have made it through to this day.

As the title of this article implies I am going to be asking this awesome community a few questions but mainly I will like for us to follow this format below and answer each question accordingly.

What was your resolution for this year 2019?
Did you reach or exceed your goals
What are those things you were able to complete?
What are those things you weren't able to complete?
Did you actually follow all of these goals you've written down from the start of the year 2019?
What lesson did you learn from this year?
How can you prepare for the next year 2020?
What held you back from no achieving all of your goals?
Do you think you can do better next year?
I know is a bit soon but can you briefly explain your resolution for the year 2020?

Well, these questions above are all important and I've used them to plan for the next year 2020.
I hope you guys will share your answers below and who knows if this might inspire others to plan well and learned from someone's mistakes and that person might just be you.
Merry Xmass in advance devs.

#100DaysofTeachMeAnything challenge

Carlos Nah — Thu, 01 Aug 2019 13:14:48 +0000

Howdy world, it gives me joy today announcing to everyone reading right now the #100DaysOfTeachMeAnything.
I have searched and haven't see such like this or any challenge like this so I decided to make one, it has been the way in which I learned many new things or how to code and today I want you to do the same.

Who can participate in this challenge?

Anyone and everyone ranging from techies, professionals, diplomats or anybody who wants to learn something new and have confidence doing it.

Well the methodologies use here are very different from many challenges or somewhat similar.
First reason of the #100DaysOfTeachMeAnything challenge is to give anybody or everybody who finds it difficult to learn a certain thing in a certain amount of time but failed a chance to do better.
Don't worry stay with me as we sort this out.
I have heard from many professionals in my field that the best way to learn something is to either teach it or blog about the part you aren't understanding and by doing it have helped me overcame many common mistakes I made in my learning endeavors.
Many learners take it lightly and spend hours watching or reading tutorials just to realized it didn't stalk in.
It can be very frustrating but hey! who told you that it isn't possible?Join the challenge today and be a part of something meaningful by teaching what you don't understand to another person who wants to learn it desperately. I am done with the talking let get into how this us possible.

How this is possible?

This is possible because you're willing to commit your time and efforts in teaching something to someone and at the same time learning what you're teaching.
All you need to do is firstly, tweet about it by copying the below paragraph or statement.

 I [your name], do hereby commit to the #100DaysOfTeachMeAnything challenge to teach [course name] through blogs and articles until the 100 days elapse as a way to build up my skills in the said course or field.
@CarlosNah8 #100DaysOfTeachMeAnything

After you're done with the tweet you can use the below resources to start your journey.

Note: For now I will give resources base on my field and if you have a good resources base on another field please leave it in the comments below.

Web development
Quincy Larson and his team of contributors have compile together many resources ranging from frontend backend and fullstack web development. I urge you to follow the link below and try them out if what you want to learn is web development. https://freecodecamp.org
There are also many good sites that teaches many web development courses like http://theodinproject.com, https://developer.mozilla.org/en-US/.

After you have chosen the course you want to learn, each day write a blog post or an article summary of the topic you have learned and the best practices that follows.
I will encourage you to use https://dev.to to post your daily work and tweet about it on twitter with the hash tag.
I will retweet and follow you guys, this is just one of my many posts and you should expect more guidelines and updates.

Lastly, I have tried to put almost everything in place but life has a way of dealing with us and my one will not be sufficient to make this challenge a success, I am now using this medium to ask for contributors and professionals to please help me either by sharing the word using the hash tag or producing more guidelines, contents or much more.
Any interested individual can kindly reach me through twitter or cnah27@gmail.com

Thanks for reading through and you can leave your suggestions in the comment below.

Handling CSS3 Specificity

Carlos Nah — Wed, 19 Jun 2019 22:52:03 +0000

I know it may sound strange but a lot of developers and engineers still find it difficult to get their way around CSS3 Specificity. If you have doubts of why this color isn't working or why your font isn't responding to your defined styles set then you have no more reason for doubts, join me as we unveil the secret recipes to handling css3 specificity.

What is CSS Specificity?

According to MDN

Specificity is the means by which browsers decide which CSS property values are the most relevant to an element and, therefore, will be applied. Specificity is based on the matching rules which are composed of different sorts of CSS selectors

In other words it is just a rule-set that web browsers uses to decide which css property with higher priority to add on a given element or selectors that matched it.

How can one calculate specificity?

There are many ways to calculate specificity but I will be showing you the easiest method, it is called the ABCD method.

A represent style attribute or inline style, which carries the highest priority

B represent the id selector that carries the second highest priority when applied on an element

C represent classes, pseudo elements and attribute

D represent elements

From the above description you will understand that A have the value of 1000, while B have the value of 100, also C have the value of 10, and D have the value of 1.

If only A is applied on an element, it will look like this:

 A = 1
 B = 0
 C = 0
 D = 0

And if B is applied on an element, it will look like this:

 A = 0
 B = 1
 C = 0
 D = 0

If C is also applied on an element, it will look like this:

 A = 0
 B = 0
 C = 1
 D = 0

And if D is applied on an element. it will look like this:

 A = 0
 B = 0
 C = 0
 D = 1

Right now looking at the diagram above, I think you have grasp the concept and if you continue practicing and adding each method together open up your mind to endless possibility or understanding.

Let me know what you think by leaving a comment.