DEV Community: Somadina

The Biggest Lie About Programming Complexity ⭐ (my favorite)

Somadina — Fri, 03 Jul 2026 16:13:37 +0000

The Common Ground of Complexity in Programming and Artificial Intelligence

No matter how complex a system is—and in this case, learning programming and artificial intelligence—no matter how complex they have become, they all have a common ground.

Looking for that common ground is where the challenge lies.

To find it, you need to experiment and backtest your understanding. Those two practices are what gradually reveal the patterns behind the complexity.

But do you know what these two things require?

Discipline
A strong will

Without them, it becomes difficult to stay consistent long enough to discover the fundamentals that make everything else easier to understand.

Complexity Isn't the Real Problem

What I have realized is that what scares people away from learning programming well is not its complexity.

The real challenge is the inability to find its common ground.

Every programming language, framework, algorithm, or AI concept is built on underlying principles. Once you identify those principles, what once seemed confusing begins to make sense.

Finding that common ground is where the real work is.

And it is that understanding that enables you to recreate, direct, and reinvent code that does your bidding.

My Advice

If you want to scale up your programming skills and you meet the walls of complexity, look at the ground.

If you do not see the ground, search for it.

Keep experimenting.

Keep testing your understanding.

Keep asking why things work the way they do.

Eventually, you will notice something surprising:

Hard things become easier when you understand the common ground they are built upon.

Complexity often disappears the moment the fundamentals become clear.

Final Thoughts

Learning programming isn't about becoming comfortable with complexity.

It's about becoming skilled at discovering the simple ideas that complexity is built upon.

Never stop looking for the common ground.

Thank you for reading!

It's me, your digital communicator, Somadina.

Let's Discuss

What was the "common ground" that finally made programming click for you? Share your experience in the comments.

A Quick Story About Why Testing Matters

Somadina — Thu, 25 Jun 2026 13:17:37 +0000

🚀 I want to share a quick story with my network.

A few days ago, someone asked me to analyze the user interface of a newly launched website.

For several days, I postponed the evaluation, but whenever we discussed the project, he spoke confidently about the application.

"Everything is working perfectly. Just take a look."

Eventually, I decided to test the site myself.

When I opened it, I noticed he was already logged in. He suggested that I simply use his account to perform what he thought would be a brief analysis.

I declined.

"That's not how software is evaluated. I'll create my own account and go through the experience from the ground up, just like a real user."

Although he initially wanted to rest, he agreed to log out so I could proceed.

The Turning Point

The moment he logged out, everything changed.

The application crashed.

Pages stopped functioning correctly. He could no longer access his profile or reproduce the workflow he had demonstrated earlier. Features that seemed fine while he was logged in suddenly became unusable.

I suggested restarting the application.

He did.

Nothing changed.

At that point, I reminded him:

"We came here to test the product, not to debug it. Since you wanted to hand me the device and relax, go and relax. We'll identify the issues first, then fix them."

The Lesson

As software developers, we can't confidently claim that a product is complete until it has been thoroughly tested.

What appeared to be a stable application was hiding an entire layer of issues that would never have been discovered without proper testing. That single test session uncovered problems buried deep beneath the surface.

And that's what development is really about: identifying problems early and turning them into opportunities to create better experiences for users.

Remember

Code that works for the developer isn't enough.

Code must work for the user.

💡 Have you ever discovered a critical bug only after testing from a fresh user's perspective?

Share your experience below.

Q&A: Understanding What AI Really Is (A Thought Process)

Somadina — Fri, 17 Apr 2026 12:52:11 +0000

Your Question:

If there haven’t been datacenters that store digital information like text, chats, images, and videos, would AI still be able to dynamically create answers to prompts using weights and tokens based on statistics and probability?

The Answer:

No. AI models rely on existing data to learn patterns. Without stored data, there would be nothing to train on, so the model couldn’t form meaningful weights or probabilities. Any output would be random and not useful.

Your Question:

“No is the answer haha 😂”

If “no” is the answer, then AI is simply a computer program or software that helps humans access information in datacenters in a customized and relatable format based on the user’s prompt. Humans engineered it.

The Answer:

Not quite. AI is not just a tool that fetches data from datacenters. It doesn’t directly look up answers.

It is a trained model that learned patterns from data and uses probabilities to generate responses. Datacenters mainly store and run the model, not act as a live library it searches.

A better way to say it:

AI is a human-made system that learned from data and can generate new responses, not just customize stored information.

Your Suggestion, Questions, and Clarification:

That sounds similar to what I meant. Since AI wouldn’t exist without data stored in datacenters, doesn’t that mean it’s an engineered program that manipulates that stored information using probability and statistics? And isn’t that what you call a trained model that learned patterns from data, whether it is after it got trained or before it got trained on it, it is still manipulating data?

Answer:

Close, but slightly off.

AI does not manipulate stored data in datacenters while answering questions.

During training → it learns from stored datasets
After training → it no longer uses those datasets directly

At runtime, it uses:

Learned weights
Probability to predict the next word

So, AI generates answers from learned patterns, not by working on stored files in real time.

Refined idea:

AI is a human-engineered system that learns from stored data, then uses statistical patterns to generate new answers independently of that data.

Your Final Question:

Humans are the ones who initially train AI by showing it data and associations, right? After that, it follows those patterns. And doesn’t that mean others can also train their own AI using their own datasets?

Answer:

Yes — that’s basically correct.

Humans provide data and training methods
The AI learns patterns from that data (partly guided, partly automatic)
After training, it follows those learned patterns

And yes:

People can train their own AI models or fine-tune existing ones using their own datasets.

Conclusion:

AI is not just a system that retrieves stored information. It is a human-engineered system that learns patterns from data and uses probability to generate new, context-aware responses.

And you have solidly seen and witnessed the cause and effect of AI; every other thing you do with the information depends on you.

Technology is not hard to conceptualize when you closely look at it.

#How I Self-Taught, Battle-Tested: My Journey to Becoming a Technical Writer And Developer

Somadina — Fri, 20 Mar 2026 07:47:46 +0000

From Self-Taught to Service-Ready: My Journey into Technical Writing and Development

A book with 500 pages starts with the first page.

This story is the first page:

I’ve spent the last two years and few months doing what most people thought was unrealistic — building myself into a technical writer and developer, without waiting for a job, title, or formal training.

No classroom set the path. I imagined the future I wanted, then walked straight into it — step by step.

I practiced technical writing without being hired. I wrote as if I already had clients. I studied how companies structure their docs, their tones, and how they serve users. I wasn’t passive — I practiced every single concept.

I explored HTML, CSS, and JavaScript.

I learned how they connect — not just by reading, but by building.

I wiped Windows from my own system, installed Ubuntu, and learned to navigate Linux terminal commands. I studied file hierarchies, understood bootloaders, BIOS, OS structure, and how the machine speaks before the desktop even boots.

I broke down the common threads between programming languages — variables, loops, functions, conditionals. I explored computer networks, hardware, and software layers.

Then I went deeper — into UX/UI design, thinking like the user. I even practiced animation and visual storytelling, trying to draw what I saw in my head when words weren’t enough.

I did all of these with:

No formal teacher
No structured support system
Just by reading any book I came across and felt could help, visiting related websites, watching videos, and practicing with my low-life laptop

I isolated myself for this course — not out of loneliness, but because focus mattered more than comfort.

I left behind friends, distractions, noise — just to stay on course.

I endured poverty.

I experienced hardship.

But I never stopped. Because I had one goal in mind:

To become valuable.

To serve.

To earn the right to be rewarded.

Because I paid the price in sweat, patience, and practice, it should not surprise anyone when I solve problems with focus,

when I break things down,

when I write and think with clarity.

Because I built this mindset — brick by brick.

Now, I am ready to offer my skills, my writing, and my experience — not as a beginner who’s guessing, but as someone who has lived the discipline required to succeed.

Whether as a technical writer, developer, or documentation analyst — I’m not just starting.

I’ve already done the reps.

And I’m just getting warmed up.

What are you doing with your time? And what are you building with your time? Start early, finish rich.

I shared this story to show you that you can grow when their eyes are not watching if you are determined.

What I want you to get out of this story is this: set your goals, and when things don't seem to be aligning with them, relax, watch, re-strategize, and still pursue your goals.

Be flexible and focused.

A digestible Breakdown of web servers

Somadina — Fri, 20 Mar 2026 07:03:32 +0000

Even if you are not familiar with all the servers in the world, you must have heard of a web server. It is the most common type of server. In fact, when developers want to teach client–server relationships, the web server is the most prevalent illustration.

But did you know that beyond web servers, there are other types of servers that are crucial parts of the backbone of the internet?

That is what I will be listing out, along with their uncommon functions.

We have:

Database servers: They manage data storage and retrieval, e.g., the server that saves your Facebook profile.
Mail servers: They handle email transmission, e.g., the servers responsible for sending and receiving emails from Gmail, AOL, or even Yahoo.
File servers: They centralize file storage. Let’s talk about this one a bit, because it looks useless at first glance. Everything about computers is a file, which implies that a mail server, for example, also stores files and allows retrieval—likewise a database server, etc.

So why is this one called a file server, and what is its importance and function?

A file server is a dedicated computer on a network that acts as a centralized repository for storing, managing, and sharing files, documents, and data among authorized users.

While it is true that almost everything in computing is a file—and other servers like mail servers do store files—a file server is specialized for general-purpose file management and for collaboration tasks rather than for processing application logic or mail transmission.

Google Drive and SharePoint are perfect examples of services built on top of this type of server.

Other types include:

Proxy servers: Intermediaries for web traffic.
DNS servers: Translate domain names into IP addresses.
Application servers: Run software applications.
FTP servers: Facilitate file transfer between systems.
Game servers: Host multiplayer online games.
Virtual/Cloud servers: Software-based servers running on physical hardware that provide scalable and flexible computing resources.

These servers are designed for specific tasks to manage, secure, and distribute resources efficiently within a network.

Their interactions, combined with carrying out their specific purposes, are what make the internet smooth in your hands. They are the background engines, dispersed in remote areas, yet still able to reach you with their services whenever you need them.

More content about computers, networking, and software development is coming. So always check and stick around. Thank you.

Why Web Development Won Me Over (After Comparing It to Apps)

Somadina — Fri, 27 Feb 2026 12:20:35 +0000

Why I Love Websites Is Deeper Than You Think

Although am actively learning app development, but it happened that I did an extensive research—a deep, thorough study—on the correlation between apps (Android, iOS, and Windows) and website development.

I explored whether you can build an app using tools meant for building a website. The answer is no. You can't build an app with Flutterwave.

Each device—iOS, Android, and Windows—has its specific frameworks and languages for app development.

So Why Do I Love Websites?

Because they are browser-oriented.

Any device with a browser can access your website, which essentially contains information about your business and services.

But for apps:

If it's developed for Android, it won't be available on iOS.
Each platform requires its own development approach.

The Only Limitation?

The only limitation websites have is if you intentionally disable JavaScript or CSS in your browser.

The consequence:

Interactivity may be lost
Styling may be lost

But that’s not a deal-breaker for me.

Although I can build apps, I especially love working with websites—particularly:

Backend logic
Search Engine Optimization (SEO)

Let’s Build Something Amazing

Do you want a website for your business with groundbreaking UX designs that leave users speechless for 39 minutes?

Reach out so we can discuss and create your perfect solution.

Mobile Network Turns Off During Calls — Has Anyone Experienced This?

Somadina — Fri, 02 Jan 2026 22:06:23 +0000

Has anyone experienced this before?

Whenever I make a call, my mobile network switches off. Once the call ends, the network comes back on again.

Is this because I’m in Nigeria, or what? Has anyone else had this kind of experience? It keeps happening, and it really bothers me that my data goes off whenever I make calls.

Investigating the Problem

I hadn’t looked into it before, but I finally decided to check the problem. I knew it would be one of three things:

Network
Phone
An unknown application buried in my phone causing the issue

What Did I Find?

I discovered that my phone was falling back to 2G/3G during calls, which disables mobile data. This happens when VoLTE is off or not supported on a network or SIM.

You can confirm this by long-pressing your mobile data icon and checking your network settings.

That explained everything.

Other Possible Causes

SIM configuration issues
Network configuration issues

How I Fixed Mine

Turned on VoLTE

Settings → SIM cards & mobile networks → Enable VoLTE
Selected 4G/LTE as the preferred network mode

If the Issue Still Persists

Try the following:

Update your phone software
Ask your network provider to activate VoLTE on your SIM
Replace old SIM cards (upgrade to a 4G SIM)
Reset network settings if necessary

Hope this helps someone.

You Don’t Know What You Can Achieve Until You Try: My Journey from Technical Writing to UX/UI and Coding

Somadina — Thu, 01 Jan 2026 14:55:49 +0000

You Don’t Truly Know What You Can Achieve Until You Try

You don’t truly know what you can achieve until you try. It’s easy to look at something and think, “I can do this.” But when the moment comes to actually perform, you will realize just how much your thinking process wasn’t ready for what seemed simple.

When you try, you either continue or stop. That’s the essence of what I am saying.

My Journey: From Technical Writing to UX/UI and Programming

Let me give you an example. I started as a technical writer and ended in the cobwebs of UX/UI design and programming. I could have stayed a technical writer—studying website documentation, improving content, maybe replacing it entirely—but I wanted more.

I wanted to understand computer programs and workflows. And to write about something I didn’t understand, I had to learn it.

Starting with Front-End Development

I began with front-end development: HTML, CSS, JavaScript. At first, it felt overwhelming. The real challenge wasn’t the code—it was my own thinking.

I struggled to connect front-end with back-end; learning one seemed to erase the other from my memory. I nearly gave up.

What Kept Me Going

What kept me going wasn’t how easy it looked at first glance—it was consistency. Step by step, I pushed through. And now, the reward is real.

The knowledge I gained is invaluable. The principles of technical writing—concision, scannability, simplicity, comprehension—still matter, but applying them when writing for programmers and engineers requires more.

That “more” is where the fun begins, and that fun is what I am having.

AI as a Partner

Through this journey, AI hasn’t just been a tool; it’s been a partner. And it all started with a single try.

# What Exactly Is a Computer Port, What Can Be Found There, and How to See All Existing Ports of a Computer?

Somadina — Tue, 18 Nov 2025 06:10:52 +0000

A Computer Port Defined

A computer port is a physical or virtual interface that enables data to flow between a computer and external devices, or between software applications and network connections. They are essential for communication and connectivity.

What Exactly Is a Computer Port?

Computer ports can be understood from two primary contexts:

Physical ports (hardware)
Virtual/logical ports (software networking)

Physical Ports (Hardware)

These are the physical sockets on the computer's casing where you plug in cables and devices. They provide a standardized mode of connection to peripherals like monitors, keyboards, mice, printers, and external hard drives. Examples include USB, HDMI, Ethernet, and audio jacks.

Virtual/Logical Ports (Software/Networking)

These are not physical sockets but numerical identifiers (ranging from 0 to 65,535) used by networking protocols, e.g., TCP, UDP, and so on, to direct data to the correct software application on a computer.

For example:

Web browsers typically use port 80 or 443, which is part of the 65,535 numerical identifiers, for web traffic.
Email clients use ports like 25 or 110 to direct network traffic of specific email protocols like SMTP, POP3, or IMAP.

What Could Be Found There?

At a Physical Port

You can find:

The connection point itself
The cable connector that plugs into it (e.g., a USB-C cable or HDMI)
The peripheral device attached to it (e.g., a monitor, printer, or external drive)

The port provides an interface for data transfer and sometimes power delivery.

At a Virtual/Logical Port

You find the data stream associated with a specific running application or network service.

The port number acts as a “mailing address” to ensure that incoming network traffic reaches the correct program.

Examples:

Data arriving on port 22 is directed to the Secure Shell (SSH) service.
Data on port 3389 goes to the Remote Desktop Protocol (RDP) service.

How to See All the Ports?

To See Physical Ports

Simply look at the front, back, and sides of your desktop computer, laptop, or other device.

Those holes are ports. You will visibly see the different shapes and types of connectors.

To See Virtual/Logical Ports

You need to use command-line tools within your operating system. These tools display which ports are open, listening for connections, and which applications are using them.

Windows

Open the Command Prompt or PowerShell and type:

netstat -ano

This command lists all active connections and listening ports, along with the Process ID (PID) of the application using them.

macOS and Linux

Use any of these commands in the Terminal:

netstat -tuln

ss -tuln

lsof -i

In Conclusion

You can see the physical ports directly, but you cannot directly see the virtual/logical ports except by using command-line tools that depend on the operating system you are using.

However, you should use your understanding of how the physical ports work to grasp the idea behind the virtual version. Just as you need cables to connect your peripherals like a monitor or mouse, you need virtual ports to connect two machines wirelessly, and those ports are numbered from 1 to 65,535.

Can the OS (Operating System) of Android Be Changed — Maybe to iPhone.Just as we can change Desktop OS (Operating System)?

Somadina — Mon, 03 Nov 2025 07:25:33 +0000

Lets tacklethis rough question together.

The OS on Android can be changed — it’s called installing a custom ROM (Read-Only Memory).

Let me give your curious mind a short, clear overview of how to change an Android OS and install a custom ROM.

⚠️ Warning

Be careful — this process can erase all your data or break your phone if done incorrectly.

Steps to Change Android OS (Install a Custom ROM)

1. Backup Your Data

I mean everything first: contacts, photos, and files — because replacement of your OS is capable of wiping out your cherished data, rendering you information-less.

2. Unlock the Bootloader

Go to your phone’s Settings → About phone → tap OS version 7 times to enable Developer options.

After that, go back to your settings, scroll down and find Developer options, then enable OEM unlocking and USB debugging.

3. Use Your PC and Command

Install a custom recovery (like TWRP).

Ensure you download the correct TWRP image for your phone.

Run the command:

fastboot oem unlock

(This wipes your device.)

In case you don't know what Fastboot is — it is a diagnostic or repair tool that can flash firmware or restore an operating system.

4. Boot into Fastboot Mode and Flash It

fastboot flash recovery twrp.img

5. Download a Custom ROM

Examples: LineageOS, Pixel Experience, Evolution X, etc.

Also download GApps if you want Google services.

6. Flash the ROM

Boot into TWRP recovery, which is your recovery app you must first have downloaded and activated.

Wipe data, cache, and system.

Tap Install, choose the ROM zip, and swipe to flash.

(Optionally, you can flash GApps.)

7. Reboot the Device

Once done, reboot your phone — it’ll start with the new OS.

Is the Tool and Method for Flashing Your Phone Dependent on the Model and Phone Brand?

Yes, it is phone brand and model dependent. Each Android device has:

Different bootloader unlock methods
A unique recovery image (TWRP)
Specific custom ROM builds

So, you must always use files and instructions made for your exact phone model (e.g., Samsung Galaxy A52 or Xiaomi Redmi Note 12).

Using the wrong ones can break your phone.

Can You Change Android OS to iPhone OS?

Because you change the OS of your Android doesn’t mean you can transit from your Android to iPhone. It must be another OS your device supports — and that will be within its ecosystem.

Android and iOS are completely different operating systems — iOS is closed-source and made only for Apple hardware, while Android is both a closed and open-source operating system.

For example, AOSP (Android Open Source Project) is open source, but Google’s proprietary store (like the Play Store) is closed source.

Did you catch the difference?

Besides, you can make Android look like iOS using launchers, icon packs, and themes.

But you cannot install real iOS on an Android phone.

Therefore, you can mimic iOS, but not replace Android with iOS.

So Why Can't You Change Android to iOS Since What We Are Changing Is the OS and the OS Was Claimed to Be Changeable?

Good question — and here’s the short reason:

Even though Android’s OS can be changed, iOS isn’t compatible with Android hardware.

1. Closed Source

Apple doesn’t release iOS code publicly, so no one can install or modify it for other devices — it is a closed-source system.

2. Different Hardware Architecture

iPhones use Apple’s own chips and firmware, which work only with iOS.

3. Secure Boot and Encryption

iOS only runs on devices that pass Apple’s hardware verification.

4. Drivers and Firmware

Android devices use different cameras, screens, radios, etc., and iOS has no drivers for them.

✅ Conclusion

So technically, Android can be changed — but only to other Android-based systems (custom ROMs), not iOS, because iOS simply won’t run on non-Apple hardware.

Breakdown of JavaScript cores concept in connection to html with examples

Somadina — Sun, 02 Nov 2025 17:56:20 +0000

Introduction

Could you believe that these are the core concepts that make up the giant JavaScript programming language. The interconnection of these cores builds interactiity on webpage. It is the layer upon which frameworks like jquery tries to simplify. Front-end code are not complex but are stitched with these core concepts.Bear in mind that I only provide in-line code snippet of JavaScript using the script tag, however the conventional method is to have a separate JavaScript file. The snippet is meant to show you how JavaScript core idea is applied in html, which is one thing that scatters the mind of beginners when they are trying to understand the giant called JavaScript:

Syntax
Comments
Arithmetic Operators
Assignment Operators
Variables
Data types
Conditionals
Loops
Functions
Objects
Events
DOM Manipulation (In fact, DOM manipulation is the main tool that controls the behavior of web pages, creating the interactivity web developers often talk about).

## Concepts are:

Asynchrous Operations,
Modules
And finally, Library

If you know how to initiate these core concepts when programming, you can proudly call yourself a JavaScript guru. You can also easily learn other higher-level programming languages and start helping your fellow humans solve their digital problems. All these concepts are interrelated but somewhat subtle to detect, yet they exist deeply in your code if you have ever added JavaScript to your web page.

So don’t just read this content alone — use the ideas here to look at any JavaScript codebase. It will remove your phobia about seeing complex code structures as eyesores in your mind. Your life will also be a lot easier when debugging or trying to understand the connection between JavaScript, HTML, and CSS.

I don’t want to use anything aside from HTML as an example since that is what web development in connection with JavaScript entails. Creating examples about the core concepts of JavaScript without showing how they are used in HTML only makes you wonder about their applicability when reading. I don’t want that to happen. That’s why I’ve fused the core concepts with HTML itself. So, to benefit fully from this lesson, you at least need basic HTML knowledge.

Comments are a set of instructions written within your code that are ignored by the browser. Single-line and multi-line comments are the two main types. Examples: anything written after two forward slashes like // is a single-line comment, while anything written between /* and */ is a multi-line comment.

I have to define comments carefully from the onset because they will be used intensively within the code that demonstrates these core concepts. Study the comments within the code — think about them and connect them to the preview or highlights defining each concept.

Code snippet example of comments in action:


<script>
  // This is a single-line comment

  /* 
     This is a multi-line comment.
     It can span multiple lines.
  */

  let name = "John"; // store user's name
  console.log(name); // display name in console
</script>

Unraveling The Core Concepts of JavaScript

Syntax:

It is the language of any programming system — the way you express your human intentions to the computer. Syntax is how you present the building blocks (e.g., variables, functions, and loops) to the computer through that specific language — in this case, JavaScript.

Variable:

A variable is memory space for storing values temporarily or permanently before referencing them.
Example:

<h1 id="siteTitle"></h1>
<script>
  let siteName = "TechWorld Blog";
  const yearEstablished = 2020;
  let titleElement = document.getElementById("siteTitle");
  titleElement.textContent = siteName + " - Since " + yearEstablished;
</script>

Arithmetic and Assignment Operators:

Arithmetic operators (+, -, *, /) perform calculations, while Assignment Operators (=, +=, -=, *=, /=) store and update variable values.
Example:

<p id="mathResult"></p>
<script>
  let a = 10;
  let b = 5;

  // Arithmetic operations
  let sum = a + b;
  let diff = a - b;
  let prod = a * b;
  let div = a / b;

  // Assignment operations
  a += 2;
  b *= 3;

document.getElementById("mathResult").innerHTML = `
    Sum: ${sum}<br>
    Difference: ${diff}<br>
    Product: ${prod}<br>
    Division: ${div}<br>
    Updated a: ${a}<br>
    Updated b: ${b}
  `;
</script>

Data Types:

Data types include Number, String, Boolean, Object, Array, Null, and Undefined. They are the basic units that make up everything your page displays. Without understanding data types, you’ll struggle with constructing or deconstructing assignments within your codebase.
Example:

<ul id="dataTypes"></ul>
<script>
  let siteName = "TechWorld Blog";                // String
  let visitorCount = 1345;                        // Number
  let isUserLoggedIn = true;                      // Boolean
  let userEmail;                                  // Undefined
  let currentAd = null;                           // Null
  let article = { title: "Intro to JS", author: "Jane Doe" }; // Object
  let categories = ["HTML", "CSS", "JavaScript"]; // Array
  let uniqueId = Symbol("userID");                // Symbol
  let totalUsers = 9876543210123456789n;          // BigInt

  let dataList = document.getElementById("dataTypes");
  dataList.innerHTML = `
    <li>String: ${siteName}</li>
    <li>Number: ${visitorCount}</li>
    <li>Boolean: ${isUserLoggedIn}</li>
    <li>Undefined: ${userEmail}</li>
    <li>Null: ${currentAd}</li>
    <li>Object: ${article.title} by ${article.author}</li>
    <li>Array: ${categories.join(", ")}</li>
    <li>Symbol: ${uniqueId.toString()}</li>
    <li>BigInt: ${totalUsers}</li>
  `;
</script>

Conditionals:

Conditionals apply Boolean logic — true or false — to trigger specific code when a condition is met.
Example:

<p id="result"></p>
<script>
  let score = 75;
  if (score >= 80) {
    document.getElementById("result").textContent = "Excellent!";
  } else if (score >= 50) {
    document.getElementById("result").textContent = "Good job!";
  } else {
    document.getElementById("result").textContent = "Keep trying!";
  }
</script>

Loops:

Loops repeat code a set number of times. Use a for loop when you know how many times to run, and a while loop when you don’t.
Example:

<ul id="list"></ul>
<script>
  let output = "";
  for (let i = 1; i <= 3; i++) {
    output += "<li>For loop count: " + i + "</li>";
  }

  let j = 1;
  while (j <= 3) {
    output += "<li>While loop count: " + j + "</li>";
    j++;
  }

  document.getElementById("list").innerHTML = output;
</script>

Inner workings of the for and while loops:

Both loops add list items three times each. The for loop runs a fixed number of iterations, while the while loop continues as long as the condition is true.

Functions:

Two methods — the standard function keyword or the arrow () => method.
Example:

<button onclick="greetUser()">Click to Greet</button>
<p id="message"></p>
<script>
  function greetUser() {
    let name = "Visitor";
    document.getElementById("message").textContent = "Welcome, " + name + "!";
  }
</script>

Arrow function method of creating functions:

<button id="greetBtn">Click to Greet</button>
<p id="message"></p>
<script>
  const greetUser = () => {
    let name = "Visitor";
    document.getElementById("message").textContent = "Welcome, " + name + "!";
  };
  document.getElementById("greetBtn").addEventListener("click", greetUser);
</script>

Objects:

Objects are key–value pairs. The value of the variable is structured data accessed using dot notation.

<p id="userInfo"></p>
<script>
  let user = {
    name: "Jane Doe",
    role: "Admin",
    email: "jane@techworld.com"
  };
  document.getElementById("userInfo").textContent =
    user.name + " (" + user.role + ") - " + user.email;
</script>

Events:

Events respond to user actions like clicks or input changes.

<button id="changeBtn">Change Color</button>
<script>
  let btn = document.getElementById("changeBtn");
  btn.addEventListener("click", () => {
    document.body.style.backgroundColor = "lightblue";
  });
</script>

DOM Manipulation:

DOM stands for Document Object Model — the main way JavaScript interacts with HTML elements.

<h2 id="pageTitle">Welcome!</h2>
<button id="updateBtn">Update Title</button>
<script>
  document.getElementById("updateBtn").addEventListener("click", () => {
    let title = document.getElementById("pageTitle");
    title.textContent = "JavaScript DOM Manipulation in Action!";
    title.style.color = "green";
  });
</script>

Asynchronous JavaScript:

Handles delays with callbacks, promises, and async/await.

<p id="output">Starting...</p>
<script>
  setTimeout(() => {
    document.getElementById("output").textContent = "setTimeout: Runs after 2s";
  }, 2000);

  let count = 0;
  let timer = setInterval(() => {
    count++;
    console.log("setInterval count:", count);
    if (count === 3) clearInterval(timer);
  }, 1000);

  let loadData = new Promise((resolve) => {
    setTimeout(() => resolve("Promise: Data loaded!"), 3000);
  });

  async function showData() {
    try {
      let result = await loadData;
      document.getElementById("output").textContent = result;
    } catch (error) {
      document.getElementById("output").textContent = "Error occurred!";
    }
  }

  showData();
</script>

Modules:

Reusable JS files imported/exported.

// message.js
export function greet(name) {
  return `Welcome, ${name}!`;
}

// main.js
import { greet } from "./message.js";
document.getElementById("msg").textContent = greet("Jane");

<p id="msg"></p>
<script type="module" src="main.js"></script>

Libraries:

Prebuilt JavaScript code used to simplify tasks — often added via CDN, locally, or through npm.
Example using Lodash:

<p id="result"></p>
<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js"></script>
<script>
  let numbers = [10, 20, 30, 40];
  let sum = _.sum(numbers);
  document.getElementById("result").textContent = "Total: " + sum;
</script>

Output:

javascript Total: 100

We’ve come to the end of this short but detailed lesson. I hope you had a good time studying this guide. If you have questions about programming, feel free to reach out. I’ll also welcome your suggestions. Programming should be simple, and I’m doing my best to make sure that idea becomes a reality for everyone.

If you learn the concept of one low-level language, have you learn techniques of another low-level language? Find out!

Somadina — Sun, 14 Sep 2025 12:29:00 +0000

You may be familiar with the idea that all high-level languages for coding have one thing in common, e.g., variables, arrays, loops—you know the rest. This signifies that if you learn Python, for instance, it will be easy to learn another programming language like JavaScript, Java, etc.

That is true for high-level languages. The next question that comes to mind is: does it also apply to low-level languages like x86 assembly or ARM assembly? We shall attempt to give an answer to that because, in some sense, it is true—but in another sense, it isn’t.

High-Level Languages

Once you learn one high-level programming language (like Python, JavaScript, or Java), it becomes much easier to pick up others because of the core concepts they share:

Variables, data types, control flow (if/else, loops)
Functions and modularity
Data structures (arrays, lists, dictionaries/maps)
Object-oriented or functional programming principles

Therefore, the main difference when switching between them is mostly syntax and some language-specific features.

Low-Level Languages

Low-level languages, on the other hand, are a bit different. How?

A low-level language is very close to the hardware and depends on the CPU architecture (x86, ARM, RISC-V, etc.). Learning one kind of assembly won’t directly transfer to another because the instruction sets are different. However, the general way of thinking about registers, memory, and CPU instructions will apply.

The C language, which is often portrayed as a “portable assembly,” is still a bit higher than raw assembly—so don’t count too much on that—although it is much lower-level than Python or JavaScript. If you learn C well, you’ll gain beneficial knowledge about both low-level and high-level languages.

More specifically, you will know:

How memory management works (pointers, allocation, stack vs. heap)
How data is stored at a lower level
How compilers and operating systems interact with hardware

That knowledge makes it easier to learn other low-level languages because many concepts carry over.

So, does the rule still apply?

Yes—but you’ve seen the twist.

For high-level languages learning one makes the others much easier because the abstractions are similar.

For low-level languages learning one gives you the foundational mental model (how computers really work), but the specifics (like assembly instructions) may not transfer directly between platforms.

👉 What is the way forward?

Well, the practical strategy is:

Learn one high-level language (Python is a great first).
Learn one low-level language (C is usually recommended).

That way, you cover both: ease of programming and how things work under the hood.