DEV Community: Victor Jeremiah Usese

🚀 Is Learning to Code Obsolete in the Age of AI and GPT?

Victor Jeremiah Usese — Sat, 24 May 2025 14:13:49 +0000

With the rise of artificial intelligence, especially tools like ChatGPT, many people are starting to wonder:

“Is learning to code still worth it?”
“Won’t AI just write code for us?”
“Isn’t coding becoming obsolete?”

Let me be clear from the start:
Learning to code is not obsolete — it’s more relevant than ever.

In fact, the best developers of the future won’t be those who ignore AI.
They’ll be those who combine their coding skills with AI tools to work faster, smarter, and more creatively.

Let’s break down why coding still matters and how you can balance both worlds effectively.

💡 1. AI is a Tool, Not a Replacement

AI tools like ChatGPT are amazing — they can generate boilerplate code, explain syntax, and even debug.

But here’s the catch:

AI doesn’t “understand” what it’s doing — it generates based on patterns from data it has seen.
It won’t always know your app’s architecture or business logic.
It can’t reason like a human about long-term structure or product goals.
If something breaks, you still need you — the developer — to fix and optimize it.

🔧 AI is the nail gun. You still need to know how to build the house.

🧠 2. Coding Teaches Computational Thinking

Even if you never build a startup or become a full-time developer, learning to code builds valuable mental muscles:

Logical reasoning
Step-by-step thinking
Breaking down complex problems into smaller parts

These are not just coding skills — they are thinking skills.

🔐 3. AI-Generated Code Needs Human Oversight

AI can suggest code quickly, but it often:

Contains bugs or inefficiencies
Doesn’t follow best practices
Ignores security, scalability, or compliance concerns

To deliver reliable and secure products, human developers are essential. AI helps speed up the process, but real-world software still needs critical thinking, testing, and engineering.

🌱 4. Custom and Creative Solutions Still Require People

AI is trained on what already exists. If you're trying to:

Build something new
Innovate in user experience
Combine systems in creative ways

AI won’t be able to help much unless you guide it.

Humans imagine. AI assists.

🌍 5. Every Industry is Going Digital

From agriculture to fashion, logistics to education — everything is becoming programmable.

Learning to code means you can:

Build your own tools
Automate repetitive tasks
Collaborate with tech teams
Communicate effectively in the digital age

And if you also know how to use AI to assist with your code, you're now 10x more productive.

🧭 How to Balance Learning to Code and Using AI Effectively

Here’s a practical roadmap to combine the power of AI with your coding journey:

🪜 Step 1: Learn the Fundamentals

Before you lean too much on AI:

Understand variables, loops, functions, and conditionals
Learn how errors happen and how to debug manually
Practice with platforms like freeCodeCamp, Codecademy, or The Odin Project

💡 You can use GPT to explain concepts, but don’t let it write entire code for you (yet).

🧪 Step 2: Use AI as a Learning Assistant

Once you understand the basics:

Use ChatGPT to explain errors
Ask it to suggest improvements to your code
Challenge it: “What’s a better way to write this function?”

The key is active learning, not passive copying.

⚙️ Step 3: Build Projects with Light AI Assistance

As you build:

Write most of your code yourself
Use AI for stuck points, boilerplate, or optimization ideas
Ask “Why does this work?” every time GPT gives you an answer

🚀 Step 4: Upgrade to Advanced Use

As you get better:

Let GPT draft basic functions, and you fine-tune them
Use AI for documentation, testing, and code reviews
Explore building with AI APIs — like integrating GPT into your apps

You now become the director — AI is your assistant.

✍️ Final Thoughts

AI is changing the landscape of coding — no doubt. But it's not making coding obsolete. It's making bad or shallow understanding easier to spot — and deep understanding more powerful.

The future belongs to developers who:

Think clearly
Understand code deeply
Leverage AI smartly

So don’t quit learning to code — level up with AI by your side.

🙋‍♂️ Want Help Getting Started?

Drop a comment or reach out if you'd like:

A custom beginner roadmap
A list of GPT prompts to help you code better
A sample project that uses both manual coding and AI assistance

Happy coding — the smart way.

Arrow Functions vs. Regular Functions in JavaScript: A Showdown

Victor Jeremiah Usese — Thu, 29 Aug 2024 13:31:56 +0000

Welcome to the ultimate showdown between two of JavaScript's most iconic contenders: Arrow Functions 🏹 vs. Regular Functions 🧔.

In one corner, we have the sleek and modern Arrow Function, introduced in ES6 and beloved by many for its concise syntax.

In the other, we have the veteran Regular Function, a reliable workhorse that's been around since the dawn of JavaScript time.

But which one should you use? And when? Let's dive into the pros, cons, and pitfalls of each to see who comes out on top!

Round 1: Syntax—Who's More Compact?

Arrow Functions are the new kids on the block, and they come with a superpower: they let you write less code!

Example:


// Regular Function
function greet(name) {
  return `Hello, ${name}!`;
}

// Arrow Function
const greet = (name) => `Hello, ${name}!`;

With Arrow Functions, you can drop the function keyword, parentheses (when there’s only one parameter), and even the return keyword if it’s a one-liner. Less code = fewer typos = happier developer. 🎉

Regular Functions, on the other hand, stick to the old-school way, which some might find more readable, especially when you're dealing with complex logic or multiple lines of code.

Winner: Arrow Functions for brevity, but Regular Functions for clarity in more complex scenarios.

Round 2: The this Context—Who's the Boss?

In JavaScript, this can be a bit tricky, and this is where things get interesting. Regular Functions have their own this context, which is determined by how they are called. This can lead to some… let’s say “creative” bugs if you’re not careful.

Example:

const person = {
  name: 'John',
  greet: function() {
    console.log(`Hello, I'm ${this.name}`);
  }
};

person.greet(); // "Hello, I'm John"

const greet = person.greet;
greet(); // "Hello, I'm undefined" (or "Hello, I'm [global object]")

Arrow Functions, however, don't have their own this. They inherit this from the surrounding (lexical) context. This can be a lifesaver when working with callbacks or methods that change the context.

Example:

const person = {
  name: 'John',
  greet: () => {
    console.log(`Hello, I'm ${this.name}`);
  }
};

person.greet(); // "Hello, I'm undefined" (inheriting from global context)

Arrow Functions are great when you want this to behave predictably, especially in scenarios like event handlers or callbacks.

Winner: Arrow Functions for predictable this, but Regular Functions when you need control over context.

Round 3: Flexibility—Who's More Adaptable?

Regular Functions are like a Swiss Army knife. They can be constructors (used with new to create objects), they can have their this explicitly set using call, apply, or bind, and they can even be hoisted, meaning you can use them before they are defined in the code.

Example:

const Person = function(name) {
  this.name = name;
};

const john = new Person('John');
console.log(john.name); // "John"

Arrow Functions, on the other hand, are more specialized tools. They can't be constructors, don't have arguments object, and are not hoisted.

Example:

const Person = (name) => {
  this.name = name;
};

// Error: Arrow functions are not constructors
const john = new Person('John');

Winner: Regular Functions for flexibility, especially when you need constructors or this manipulation. Arrow Functions for their focused, predictable behavior.

Round 4: Performance—Who’s Faster?

When it comes to raw performance, Regular Functions have a slight edge, particularly in older environments or when used as constructors. However, for most everyday tasks, the difference is negligible. The choice between Arrow Functions and Regular Functions should be driven more by readability, maintainability, and context rather than micro-optimizations.

Winner: Regular Functions by a hair, but it's not a decisive factor in most cases.

Round 5: Readability and Maintenance—Who’s Easier to Work With?

Code is read more often than it is written, and in larger codebases, maintainability is key. Arrow Functions can make code more concise, but if overused, they can also make it harder to follow, especially for those new to JavaScript.

Regular Functions, with their more verbose syntax, can sometimes be easier to follow, especially for complex operations. They also lend themselves better to traditional OOP (Object-Oriented Programming) patterns.

Winner: It’s a tie! Choose based on your team’s familiarity and the complexity of the task at hand.

Final Verdict: When to Use Which?

Use Arrow Functions when:

You want concise, readable code.
You need a predictable this context, especially in callbacks or event handlers.
You’re writing short, single-purpose functions.

Use Regular Functions when:

You need a flexible this context or need to use the function as a constructor.
You’re writing complex functions that benefit from a more traditional syntax.
You want to take advantage of hoisting.

Wrapping Up

In the end, both Arrow Functions and Regular Functions have their place in the JavaScript ecosystem. They’re like two superheroes with different strengths—sometimes you need the speed and agility of Arrow Functions, and other times, you need the robustness and flexibility of Regular Functions. Knowing when to use each will make you a more versatile and effective developer.

So, the next time you’re deciding between these two, don’t just pick one because it looks cool—think about the context, the needs of your project, and the maintainability of your code. Happy coding! 🚀

Mastering Variables and Scope in JavaScript: A Developer's Guide

Victor Jeremiah Usese — Mon, 19 Aug 2024 21:04:53 +0000

Understanding how variables work in JavaScript is crucial for writing effective code. But it’s not just about declaring them—knowing where and how they can be accessed, a concept known as “scope,” is just as important. In this post, we'll break down variables and scope, making these fundamental concepts clear and practical for your JavaScript journey.

What Are Variables?

Variables are like containers that store data values. In JavaScript, we use three keywords to declare variables: var, let, and const. Each has its own nuances and behavior, which are closely tied to the concept of scope.

Example:

let name = 'Alice'; // Declares a variable with 'let'
const age = 30; // Declares a constant variable with 'const'
var city = 'New York'; // Declares a variable with 'var'

What is Scope?

Scope determines the visibility or accessibility of variables in different parts of your code. In JavaScript, there are four main types of scope:

Global Scope
Function Scope
Block Scope
Module Scope

Global Scope

A variable has global scope if it is declared outside of any function or block. It can be accessed from anywhere in the code.

Example:

var globalVar = 'I am global';

function showGlobalVar() {
  console.log(globalVar); // Accessible here
}

console.log(globalVar); // Accessible here too

Since globalVar is declared outside any function, it’s available throughout the entire codebase.

Function Scope

Variables declared within a function using var are function-scoped. This means they are only accessible within that function.

Example:

function greet() {
  var message = 'Hello!';
  console.log(message); // Accessible here
}

console.log(message); // Error: message is not defined

In this case, message is only available within the greet function. Trying to access it outside the function will result in an error.

Block Scope

This refers to variables declared within a block (i.e., inside {}) using let or const. They are only accessible within that block.

Example:

if (true) {
  let blockVar = 'I am block-scoped';
  console.log(blockVar); // Accessible here
}

console.log(blockVar); // Error: blockVar is not defined

Here, blockVar is only available inside the if block. It’s not accessible outside, making it safer to use in scenarios where you don’t want your variable to leak into the broader scope.

Module Scope

With the advent of ES6, JavaScript introduced modules, which allow you to encapsulate code within its own scope. Variables and functions defined within a module are not accessible outside of it unless they are explicitly exported. This helps in keeping the global namespace clean and avoiding potential conflicts.

Example:

// myModule.js
let moduleVar = 'I am module-scoped';

export function showModuleVar() {
  console.log(moduleVar);
}

In this example, moduleVar is scoped to myModule.js. It can't be accessed directly from another file unless you import it or use a function like showModuleVar to expose it.

Why Does Scope Matter?

Understanding scope is vital because it helps prevent bugs and improves the readability of your code. It allows you to:

Avoid Naming Conflicts: Different parts of your code can use the same variable name without interfering with each other, thanks to scope.

function foo() {
  let name = 'Alice';
  console.log(name); // Alice
}

function bar() {
  let name = 'Bob';
  console.log(name); // Bob
}

Control Variable Lifetime: Variables are only alive within their scope. Once the scope is exited, the variables are no longer accessible, freeing up memory and reducing the risk of unintended side effects.

function doSomething() {
  let temp = 'Temporary Data';
  // temp is used within the function
}
// temp is not accessible here, ensuring clean memory usage

Var vs. Let vs. Const: A Quick Rundown

var: Function-scoped, can be redeclared, prone to hoisting issues.
let: Block-scoped, cannot be redeclared within the same scope, more predictable than var.
const: Block-scoped, cannot be reassigned or redeclared, ensures immutability of the variable’s reference.

Example:

let count = 1;
count = 2; // This is fine

const max = 5;
max = 10; // Error: Assignment to constant variable

Wrapping Up

Variables and scope are the building blocks of any JavaScript program. Grasping these concepts helps you write more organized, efficient, and bug-free code. As you continue your journey in JavaScript, remember that managing scope effectively is key to mastering the language. By leveraging let and const, and understanding the boundaries of where your variables live, you’ll be well on your way to writing cleaner, more reliable code.

Happy coding! 🎉

Understanding Short-Circuiting in JavaScript: A Beginner's Guide

Victor Jeremiah Usese — Fri, 16 Aug 2024 04:28:12 +0000

When you first start learning JavaScript, you quickly realize that there’s more to writing code than just getting it to work. One powerful concept that often flies under the radar for beginners is "short-circuiting." It’s an important feature of logical operations in JavaScript that can make your code more efficient and readable. So, what exactly is short-circuiting, and how does it work?

What is Short-Circuiting?

Short-circuiting occurs in logical operations where the second operand is not evaluated if the first operand already determines the outcome of the operation. In simpler terms, if the result of a logical operation can be determined by the first value, JavaScript won’t even bother checking the second one.

JavaScript has two logical operators that support short-circuiting: && (AND) and || (OR).

Short-Circuiting with the && (AND) Operator

The && operator checks if both sides of the expression are true. However, if the first operand is false, there’s no need to check the second one, because the result will be false regardless.

Example:

const isLoggedIn = false;
const hasAccess = isLoggedIn && someFunction();

console.log(hasAccess); // false

In the example above, someFunction() will never be called because isLoggedIn is false. JavaScript knows the entire expression is false without evaluating the second part.

Short-Circuiting with the || (OR) Operator

The || operator checks if at least one of the sides is true. If the first operand is true, the entire expression is true, so the second operand isn’t evaluated.

Example:

const userRole = 'admin';
const role = userRole || 'guest';

console.log(role); // 'admin'

Here, userRole is already truthy ('admin'), so JavaScript doesn’t even look at 'guest'. The value of role is 'admin'.

Why is Short-Circuiting Useful?

Short-circuiting isn’t just a neat trick; it’s a practical tool for writing cleaner and more efficient code. Here are a few ways you might use it:

1. Default Values:

const name = inputName || 'Guest';

If inputName is empty or null, name will default to 'Guest'.

2. Guarding Function Calls:

user && user.sendMessage('Hello!');

This ensures sendMessage is only called if user exists.

3. Lazy Evaluation:

const result = complexCondition && performExpensiveOperation();

const result = complexCondition && performExpensiveOperation();

If complexCondition is false, the expensive operation is skipped, saving resources.

Wrapping Up

Short-circuiting might seem like a small detail, but understanding it can lead to more efficient and readable code. It’s a concept that you’ll encounter frequently in JavaScript, so getting comfortable with it early on will make you a stronger developer. Try experimenting with it in your own projects—you’ll likely find it comes in handy more often than you think!

Remember, the magic of short-circuiting lies in its simplicity. It lets JavaScript do just enough work to get the job done, no more, no less. And as a developer, learning to leverage that simplicity will serve you well. Happy coding!

innerText vs innerHtml vs textContent || Difference & When to use each best!

Victor Jeremiah Usese — Sat, 04 Feb 2023 13:33:40 +0000

In Javascript, there are three properties that can be used to set or return an HTML element's content in the DOM: innerHTML, innerTEXT, and textCONTENT.

Before we dive straight in, let's take a step back for a second;
Have you heard about DOM manipulation? Let’s see, what is the DOM you might be thinking?

'Document Object Model' (DOM) is a programming interface for HTML. Simply you can say, the structure of your HTML document. The DOM is a tree-like representation of the contents of a webpage using nodes instead of elements. These nodes represent HTML elements, and they can be manipulated and re-rendered. The DOM is hierarchical, following a logical
tree-like structure, where child nodes are contained in parent nodes.

You will see three properties while working on the DOM i.e innerText, innerHtml, textContent. You’ll need to know how to change the text or the HTML that appears on the page to make your sites more interactive. All innerText, innerHTML and textContent properties let you access and change the contents of a tag. That’s where the innerText, innerHTML and textContent HTML attributes comes in. People sometimes get confused about these three properties. It’s time to clear all the confusion and get to know where to use these properties specifically.

Having said that, and clarifying to an extent what the DOM is, let's dive straight right into the business of the day!

<a class="button" id="btn" href="#">ONLINE APPLY <span style="display: none">HERE</span> </a>

Above is the HTML block of code that we will use for example

innerHTML

The JavaScript innerHtml property sets the HTML contents of an element on a web page. innerHtml is a property of the HTML DOM and is often used to set and modify the contents of an element. innerHtml returns the content of an element and any spacing and descendants. innerHtml returns all text, including HTML tags, that is contained by an element.

const btn = document.querySelector('.button') btn.addEventListener('click', function (e) { console.log(e.target.innerHTML)

Above is the Javascript code for innerHtml

ONLINE APPLY <span style="display: none">HERE</span>:
Javascript output for innerHtml

Hence, the innerHTML property sets and returns the content of an element with new HTML content.

WHEN TO USE innerHtml?
You should use innerHtml when you want to see the HTML markup and what exactly is in your element — including any spacing, line breaks and formatting irregularities.

innerHtml ADDITIONAL NOTES
If the text inside the element includes the characters &, <, or >, innerHtml will return these characters as HTML entities “&”, “<” and “>”.

innerTEXT

The JavaScript innerText property sets the text content of an element that is visible on a web page are accessed. The hidden content cannot be retrieved. It also sets the contents of its descendants. innerText returns the text without any descendants or spacing. You would use innerText if you want to see the contents of an element in plain text. innerText returns all text and tags contained by an element and all its child elements.

btn.addEventListener('click', function (e) { console.log(e.target.innerText) })

Above is the Javascript code for innerText
ONLINE APPLY: Javascript output for innerText

Hence, the innerText property returns the content of all elements, except for script and style elements.

WHEN TO USE innerTEXT?
You should use innerText when you only need to see what’s in the element without the formatting.

innerTEXT ADDITIONAL NOTES
When using innerText it retrieves and sets the content of the tag as plain text. Whereas when you use innerHTML, it retrieves and sets the same content in HTML format.

textCONTENT

In textContent, all the text including the hidden contents can be accessed. textContent is all text contained by an element and all its children that are for formatting purposes only.

btn.addEventListener('click', function (e) { console.log(e.target.textContent) })

Above is the Javascript code for textContent

ONLINE APPLY HERE: Javascript output for textContent

Hence, The textContent property returns the raw content with styling inside of all elements, but excludes the HTML element tags. This includes script and style elements, whitespace, line breaks, and carriage returns.

WHEN TO USE textCONTENT?
You should use textContent when you want to see what’s in the element, plus any styling.

textCONTENT ADDITIONAL NOTES
While innerText is very similar to textContent, there are important differences between them. Put simply, innerText is aware of the rendered appearance of text while textContent is not

Summary: Unlike innerHTML, textContent has better performance because its value is not parsed as HTML. For that reason, using textContent can also prevent Cross-Site Scripting (XSS) attacks. Unlike innerText, textContent isn't aware of CSS styling and will not trigger a reflow. All Node objects have textContent, whereas only HTML Element objects have innerText.

If you found this useful, consider:

✅ Follow @vickyjhay for more content like this
✅ Follow me on Twitter where I share free resources on weekly basis!