DEV Community: Rabin Otieno

5 Surprising Developer Facts You Might Not Know

Rabin Otieno — Sun, 15 Jun 2025 08:47:43 +0000

When we think about computers and technology in general we often focus on the technical aspects. However, there are a lot of other fascinating facts that are often overlooked or that most people are not aware of. Some of these details might help us get a better understanding of the systems that we use every day. Here are some of the most surprising ones:

1. The first antivirus came right after the first virus

In 1971, the “Creeper virus” was created by Bob Thomas who was a researcher at BBN Technologies. All it did was display the message, “I’M THE CREEPER: CATCH ME IF YOU CAN”. Although considered a virus, it was simply self-replicating and not malicious. Also, the fact that it replicated across networked devices makes it more of a worm. To tackle this, the first antivirus known as “Reaper” was created. Creeper and Reaper ran on ARPANET (a precursor to the modern internet).

2. There is a programming language called Brainfuck

This was created in 1993 by Urban Muller as an experiment. The goal was to build the smallest possible compiler. It is simple as it only has 8 characters for commands yet still notoriously difficult to read and write. Here are the characters:

> < + - . , [ ]

Example: Hello, World!

++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.

Brainfuck wasn’t meant for practical use but to expound on the computational limits (and probably frustrate programmers).

3. You can write a whole backend in Google Sheets!

Although Google sheets itself is not Turing-complete, the Apps Script engine behind it is.
Using the Google Apps Script you can create forms, accept user data, run business logic and even serve JSON. This can be a fun way to quickly prototype an idea or internal tool. However, this isn’t a suitable option for production environment due to limitations in terms of performance, security, and scalability.

4. Adding logs or print statements can change the behavior of some bugs

This bizarre phenomenon is known as Heisenbug. It is named after Heisenberg’s Uncertainty Principle which implies that observing a system can alter its behavior. For instance, in a race condition between 2 threads, adding print() can slow execution thereby accidentally synchronizing the threads. This gives the illusion that the problem is fixed but once the print() is removed the bug will reappear. The actual fix would be to use synchronization solutions such as locks or mutexes.

5. The name Git is not random

It comes from British slang which refers to an unpleasant or foolish person. When BitKeeper revoked Linux’s free license, Linus Torvalds created a version control system (VCS) in just 10 days as a replacement and named it Git. He joked that he is “a git” for writing yet another VCS. Ironically, Git went on to become the most widely used version control system in the world.

What You Need To Know About JavaScript V8 Engine

Rabin Otieno — Sat, 01 Mar 2025 19:44:36 +0000

When you hear the words “V8 Engine” you probably think of the popular design for automotive engines. They are well-known for their powerful and smooth performance across the board. The JavaScript V8 engine is no different. This powerful software is unrivalled when it comes to execution of Js code. Its high versatility makes it a perfect fit for a variety of applications. Here are the details.

What is it?

The V8 engine is a software whose primary role is to translate Js code into machine code (compilation). It was created by Google for the Chrome web browser to enhance the speed and overall performance. However, due to its unique and useful features it is nowadays used on multiple fronts. For instance, it is also used by Microsoft Edge and Node.js.

Older engines used to interpret JavaScript code directly and this had an impact on speed and efficiency. Therefore, Js couldn’t be used for applications that require faster execution times. V8 engine takes a hybrid approach that includes both interpretation (to bytecode) and compilation. This makes it very efficient. In addition, the engine supports WebAssembly hence allowing execution of code written in languages such as Rust and C++.

Key Features

• Just-In-Time (JIT) Compilation
This is a technique that ensures the code is compiled at
runtime when needed. Only the frequently used parts of the code are compiled thus promoting high-speed execution. This is done using the TurboFan compiler. Before the compilation, the Ignition Interpreter first does the translation into bytecode. This hybrid approach creates a fine balance between fast startup times and high-speed execution.

• Garbage Collection
It frees up unused memory thereby preventing memory leaks. This is done based on the generations i.e. it uses quick cleanup for short-lived objects (young generation) and a more optimized cleanup for long-lived objects (old generation). Since the garbage collection is done in small steps it doesn’t stop execution thus ensuring smooth performance.

• WebAssembly Support
The fact that it can run WebAssembly code alongside JavaScript allows near-native performance for web apps. The WebAssembly code can be compiled Ahead-Of-Time (AOT). The execution is even faster than JIT-compiled JavaScript. This allows for high-performance web apps like Figma and Photoshop Web.

• Hidden Classes and Inline Caching
Instead of dynamically assigning properties which tends to be slow, it creates hidden classes behind the scenes to structure objects efficiently. If a function accesses the same property multiple times V8 remembers its location through inline caching and avoids looking it up again. Reduced lookup time translates to faster access.

• Optimization and De-optimization
It employs various techniques to optimize the code and can also de-optimize it if need be. For example, if the applied assumptions turn out to be wrong it can roll back and use the slower generic version thus ensuring that execution still happens correctly.

Conclusion

The JavaScript V8 engine is one of the fastest and most efficient engines. It offers a robust platform that combines both compilation and interpretation to provide the best performance. The ability to execute WebAssembly code and to power both browsers & sever-side applications through Node.js makes it a versatile engine. In addition, it is open-source and has cross-platform compatibility hence making it widely accessible. For more detailed information checkout the documentation.

Intel Core i3, i5, i7…. what do these really mean?

Rabin Otieno — Wed, 12 Feb 2025 17:45:22 +0000

Given a choice between a laptop with Intel® Core™ i7-6700 and another with Intel® Core™ i5-14500T, one might end up choosing the former thinking that it is more powerful. This is a subtle mistake that is easy to make if you are not conversant with Intel processors. The latter is actually more powerful. The tier number (i5, i7 etc.) alone is not enough to consider one better than the other. This article aims to help you make a more informed choice when dealing with common Intel Core Processors.

What is a core?

In simple terms, it is a single module within the processor that is capable of executing instructions independently. Most Pentium CPUs (predecessor to Intel Core series) had a single core which meant that execution had to be done sequentially, one task after the other. As you can imagine, this was slow. To improve their performance the clock speeds were bumped up. It ended up creating other issues such as excessive heating and inefficient power consumption.

This led to the shift in architecture with the multi-core processor being adopted. Rather than depending on very high clock speeds to boost performance, it implements other techniques such as multi-processing, more work per clock cycle, and better power efficiency. With years of continuous improvements this evolved into the modern day CPUs that are of various classes.

Tiers

The categorization of processors is done based on features such as number of cores, size of cache, power consumption, graphics card and clock speed. Based on these we have tiers such as:

Core i3

Can have up to 10 cores.
Small cache size, usually about 12 to 18MB (depending on the generation).
Relatively low clock speed.
Don’t support overclocking except for the Core i3-7350K.
Good for light work e.g. MS office applications.

Core i5

Can have up to 14 cores.
Moderately sized cache of about 18 to 24MB.
Moderately high clock speed.
Some support overclocking.
Good for multitasking, moderate gaming and typical everyday use cases.

Core i7

Can have up to 20 cores.
Large sized cache of about 25 to 33MB.
High clock speed.
Some support overclocking.
High end graphics.
Good for design works, gaming, and professional use cases.

Core i9

Can have up to 24 cores.
Cache size up to 36MB.
Fastest clock speed. Turbo boost up to 6.0GHz.
Some support overclocking.
High end graphics.

Core Ultra

These are some of Intel’s Latest high-performance processors, designed to suit AI workloads and advanced multitasking.

Has 12+ cores.
High turbo speeds (~5.0 GHz+).
Has new AI-focused Neural Processing Units.

As shown in the information above, the number used in the naming categories doesn’t directly reference the number of cores. So it’s wrong to assume that an i5 will have only 5 cores. Also, it is worth mentioning that the values change across generations. For instance, the core counts stated above are for the 14th Gen processors hence are different from those of a 5th Gen.

Note: As of 2024 Intel has adopted new naming techniques that excludes the “i” thus you might see a Core i9 being simply referred to as Core 9. This applies for the new high-end processors.

Generations

The tiers are further categorized by generations. The newer generations typically will have improvements that make them better than the older ones in terms of performance among other features. This is the reason why in the example that was given above, the Intel® Core™ i5-14500T is considered better than Intel® Core™ i7-6700 performance-wise.

As per Intel’s naming system, the first one or two digits after the tier typically denotes the generation, the remaining 3 show the model number, and an optional letter represents specific capabilities of the chip or show intended use.

This shows that it is a 14 generation processor and also has optimized power consumption.

Suffixes

As you might have noticed some processors have letter suffixes while others don’t. Here are the meanings of some of these letters:

T -> power optimized. These usually have lower clock speeds but are energy-efficient.
F -> No integrated graphics. These are great for gaming and high-performance uses that will require you to have external dedicated GPU.
K -> Unlocked for overclocking. These are suitable for workloads that require high clock speeds.
H -> High-performance mobile processor. Such laptops have more power and cores.
G -> High-performance Intel graphics. Great for workloads that require advanced graphics performance e.g. some design works
U -> Ultra-low power. Offer low power consumption and long battery life.
S -> Special edition or optimized performance. These are usually limited-release CPUs with better tuning.

Conclusion

There is a wide variety of Intel Core processors. i3, i5, i7, and i9 are part of the numbering system used to denote the performance tier of the specific chip. Each tier has its own key features that will influence the performance. When making a purchase, it is very important to also consider the generation of the processor and the suffix letter where applicable. Intel regularly updates their products and therefore some of these details might change over time. For more information on the topic be sure to visit the official website: www.intel.com

Are You Writing Your Git Commit Messages Properly?

Rabin Otieno — Sun, 26 May 2024 16:22:04 +0000

When it comes to version control, Git is a very effective tool. However, like any other tool you have to use it the right way to get the most out of it. There are different aspects that you need to take into consideration. This article focuses on how to write effective Git commit messages following the Conventional Commits specification. It outlines the fundamentals to help you create clear, informative, and standardized commit messages.

How does a good commit message look?

The purpose of sending a message is to communicate. For communication to be effective, the receiver has to clearly understand what the sender of the message is trying to tell them. Thus you need to provide the context and adequate information. Based on this, a good commit message should convey the following:

1. Type (mandatory)

fix: – applicable when the action is fixing a bug.
feat: – applicable when you add a new feature.
BREAKING CHANGE: - applicable when you introduce a change that might require certain aspects of the program to be updated or upgraded to avoid disruptions. For example, replacing deprecated resources with new ones might disrupt functionality if there is no backward compatibility. You can also indicate a breaking change by using the symbol '!' right after the type (or scope if available). Example; 'feat(authentication)!:'
docs: – applicable for documentation.

Others include test: , chore: , refactor: , build: , style: etc. If you are part of a team there might be a convention with customized types that you are expected to adhere to. It is therefore important to get the details beforehand.

2. Scope (optional)

Although providing the scope is optional, it is good practice to include it for clarity. The scope specifies the part of the codebase affected by the changes thus helping readers understand the context of the change. This is especially helpful in large projects with many contributors. It makes collaboration easier.

3. Description (mandatory)

This is the part where you describe what you’ve done. Keep it concise and straight to the point. Make sure that you write it in imperative form. For instance, instead of writing “Added authentication mechanism” you should write “Add authentication mechanism”. This will promote readability in automatically generated changelogs and release notes.

4. Body (optional)

Here is where you can provide more information about what you’ve implemented. Use a blank line to separate the body from the description.

5. Footer (optional)

If there is any metadata you’d like to include do so in the footer. For instance, if the change you’ve made addresses an issue that had been raised earlier you can indicate it here by citing the reference number. Example; 'fix #003'
You can also include reviewer’s name in the footer.

Remember, a scope should be followed by a colon and space before giving the description. You should also keep in mind that BREAKING CHANGE is case-sensitive when included in the footer hence should be written in uppercase.

Examples

chore(Art_func): change variable “Empty” to “empty”

Change variable name from “Empty” to “empty” for consistency with
the naming convention.

fix(database)!: modify schema

Modify schema to accommodate only structured data. Dismiss all
other types of data.

feat: add support for dark mode.

For long messages, use a text editor by running

git commit

without the -m flag. This opens an editor where you can write a detailed commit message. For shorter messages you can just include the -m flag and use the terminal instead of an editor.

git commit -m "subject" -m "body"

Using multiple -m flags helps you format the message correctly by separating the subject, body, and footer.

Conclusion

Writing a commit message should serve the intended purpose. To make it clear and informative, it is recommended that you include at least the type and description of the changes you’ve made. Follow the conventional approach to maintain a good codebase that can support collaboration and automation of various processes. For detailed information be sure to go through the Conventional Commits guidelines.