DEV Community: Somadina

#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.

Best markup to use in GitHub as a writer based on work-flow

Somadina — Wed, 10 Sep 2025 20:34:53 +0000

Which Markup Is Better if You Are a Writer Who Contributes and Publishes Content on GitHub

If you’re a writer hosting your portfolio, tutorials, and writing samples on GitHub, the choice between Markdown and HTML depends on your goals, workflow, and audience. Let’s look at their advantages and disadvantages to help you make the best choice:

Markdown

✅ Pros

Native to GitHub → GitHub automatically renders .md files beautifully. Your README, portfolio pages, and tutorials will look clean without extra effort.
Lightweight & simple → Easier and faster to write than HTML.
Readable in raw form → Even if someone views your repo as plain text, Markdown looks clean.
Supports extensions → GitHub Flavored Markdown (GFM) adds tables, task lists, code syntax highlighting, footnotes, etc. — great for tutorials.

Note: GitHub Flavored Markdown (GFM) should not confuse you. It’s just another version of Markdown that supports extra features beyond the regular syntax you use in formatting text — e.g., tables, task lists (- [ ]), automatic URL linking, and syntax highlighting for code blocks.
The good news is you don’t need to activate it — it’s already enabled by default on GitHub. The only thing you need to do is learn and apply the new syntax and features it provides.

Portable → You can convert .md into HTML, PDF, DOCX, etc., with tools like Pandoc if you need polished documents later.

⚠️ Cons

Limited styling → Custom layouts, interactive elements, or advanced formatting require HTML/CSS. Switch to HTML for advanced formatting.
Less control → You can’t design the page beyond GitHub’s rendering rules.

HTML

✅ Pros

Full control → Lets you customize typography, structure, layout, and interactivity.
Web-ready → You can host HTML files on GitHub Pages for a polished, website-like portfolio.
Scalable → Easier to integrate custom CSS/JS if you want your portfolio to look like a professional website rather than just repo docs.

⚠️ Cons

Heavier to write → Writing tutorials in raw HTML is tedious compared to Markdown.
Cluttered raw view → If someone browses your repo directly, HTML isn’t as readable as Markdown.
Overhead → Requires more effort to maintain consistency across documents.

Best Approach for a Technical Writer

👉 Use Markdown for your writing samples, tutorials, and documentation because:
It’s the industry standard for technical writing in open-source, docs, and GitHub.
It showcases your ability to write developer-friendly, accessible content.
It’s future-proof and easy to export.
👉 Use HTML (with GitHub Pages) for your portfolio site itself, because:
A portfolio benefits from visual polish (navigation, layout, branding).
You can link out to .md tutorials and samples directly in a styled site.

🔑 Recommendation

Write tutorials and samples in Markdown (.md) to demonstrate technical writing skills.

Build a portfolio landing page in HTML (or Jekyll/GitHub Pages with Markdown) for presentation.

That way, you show both clarity in technical documentation and professional presentation skills.

# Runner H on Mobile – A Real-World Breakdown from a Technical Writer's Perspective Author: Goodluck Chukwuemeka

Somadina — Mon, 07 Jul 2025 05:40:42 +0000

This is a submission for the Runner H "AI Agent Prompting" Challenge

What I Built

As a developer and technical writer, I wanted to go beyond casual experimentation and evaluate Runner H using a real-world workflow. My goal was to assess how well it could:

🔍 Find legitimate remote technical writing jobs on platforms like GitHub, DigitalOcean, etc.
📝 Draft personalized application emails using my name.
🧾 Summarize each company’s tone, target audience, and writing style in a Google Doc for review or future preparation.
🛠️ Scan GitHub repositories to identify beginner-friendly e-commerce product page projects I could practice coding with (HTML, CSS, JavaScript).
📂 Save project source code to a Google Doc for easy access and provide a breakdown of the interrelationship between HTML, CSS, and JavaScript.
📱 Execute all of the above from a mobile device.

I conducted this experiment on both desktop and mobile to compare performance.

Demo

I thought i could embed video directly here. But that didn't work pardon me.

How I Used Runner H

🖥️ Desktop vs. 📱 Mobile Testing

While I didn’t fully analyze the desktop version, I successfully created and executed a prompt before switching to mobile. Since I primarily access the internet through my phone, I was especially curious to evaluate Runner H’s mobile capabilities.

🚀 First Prompt Attempt

Here’s the initial prompt I used:

Prompt

“Search for legitimate, remote technical writing opportunities at developer-focused software companies — including U.S.-based and global platforms like DigitalOcean, GitHub, Vercel, and similar. For 3 promising roles, generate tailored application emails using my name 'Goodluck Chukwuemeka'. Save the drafts in Google Docs. Email me the link for review. Furthermore, summarize each company’s product, writing tone, and target developer audience in a Google Doc so I can prepare if they reply.”

✅ Results:

Runner H clearly broke down and marked each prompt component as “complete.”
Clicking “Open File” led to a PDF summary containing a link to the documents — but the link was unresponsive.
I had read that the app records a video of each prompt session. However, no video was generated. (Is this feature coming soon?)
Since the PDF link didn’t work, I checked manually via Google Docs and Gmail — the application drafts and company summaries were indeed created.

🔎 Note: All proposals were stored in one document, prompting concerns about whether it might accidentally send multiple proposals to the same company. To investigate further, I created a second, more specific prompt.

✍️ Second Prompt – Enhanced Specificity

This prompt tested if Runner H could generate separate, editable documents (not PDFs) and include functional links.

Prompt

“Search for 10 legitimate, remote technical writing opportunities from developer-focused software companies. Generate tailored application emails using the name ‘Goodluck Chukwuemeka’. Save the drafts in separate Google Docs — one for each company. Additionally, summarize each company’s product, writing tone, and target audience in a single overview document. Finally, create an editable summary (Word format, not PDF) of all actions taken and provide clickable links to each document, all accessible within the Runner H platform.”

✅ Results:

The system delayed response and gave no feedback on individual task completions.
It successfully crawled several websites before abruptly stopping. I had to terminate the session manually.

After reviewing the outcome:

🟡 Only 7 proposals were generated (instead of 10).
📄 One Google Doc was created containing an overview of all companies.
📎 The summary PDF again included unclickable links, making it unusable for practical review.

🔍 Insight:

To get usable results, prompts must be detailed and explicitly structured. However, Runner H currently defaults to locked PDF formats, which are not ideal for technical writing or workflow editing.

🧪 Third Prompt – Programming-Focused Test

I then tested Runner H’s technical capabilities with this development-related prompt:

Prompt

“Search for beginner projects in GitHub that I can utilize for developing e-commerce product pages. Provide the source code, explain how the HTML, CSS, and JavaScript components interrelate, describe the project’s purpose, and compile everything in a Google Doc with a shareable link.”

✅ Results:

It successfully found a GitHub project and provided the repository link.
It offered a general explanation of the HTML, CSS, and JavaScript relationship — but did not extract, explain, or provide code I could copy and use.
The Google Doc it created was empty, despite the provided link.

Use Case & Impact

📱 Mobile Experience Breakdown

1. Missing Prompt History

Runner H did not record a video or log of the mobile prompt session, meaning I had no way to trace the session or replay it — a key limitation for repeatable workflows.

2. Uneditable Output

All generated documents were locked PDFs with non-clickable links. For technical writers, this is a major issue — we need editable and interactive formats.

3. Broken or Empty Links

In the GitHub task, the app claimed the analysis would be in a Google Doc, but the link was either broken or the file didn’t exist.

4. Superficial GitHub Analysis

While Runner H located a relevant repository, it didn’t extract or explain the code in a usable way — missing the core of the prompt’s intention.

5. Integration Wasn’t the Problem

All of my Google services (Docs, Gmail) were fully authorized. The issue stemmed from Runner H itself.

✅ What Runner H Did Well

Accurately understood the general intent of complex prompts.
Successfully identified and linked real GitHub projects.
Took initiative in automating workflows.
Indicated early promise for AI-driven task chaining.

🛠️ Recommendations for the Runner H Team

Enable Prompt Video Logs on Mobile: Users should be able to trace or replay prompt sessions.
Provide Editable Output Formats: Avoid locked PDFs; default to Google Docs or editable Word files.
Fix Link Embedding and Sharing: Ensure all shared files are properly accessible and clickable.
Add a Review Step Before Email Sending: Allow users to preview and edit generated emails.
Enhance Prompt Execution for Developers: Provide real, usable code and contextual explanations — not vague overviews.

These small improvements could significantly enhance the mobile experience and build long-term user trust.

💡 Final Thoughts

I walked away from this experiment with valuable insight:

I tested Runner H under real-world conditions, applying both developer and technical writing perspectives.
I didn’t just try to make it work — I tried to break it, to understand its limits.
In doing so, I provided feedback that can directly inform platform improvements.

This wasn't about finding flaws, but about pushing boundaries and contributing to meaningful growth.

Thanks for reading.