Reliability, Scalability, Maintainability, Fault-tolerance, Security, Load, Bottleneck, Performance, Throughput, Response Time, p50, p90, p95, p99, p999, SLA, SLO, Contracts, Scale-up, Scale-out, Distributed load, Stateless, Stateful, Load parameters, Operability, Health monitor, Accidental Complexity, Abstraction, Evolvability, Agility, Refactoring.

Uffff…. Orey engineeru.
Jeevitam lo eppudain veeti anniti gurinchi aalochinchav entra?

PR raise chesama. Team lead okay annada. Reviewer merge chesada.
- ide kada ammai nuvvu chesedi?

Konchem kochem chuddam

Some basics of a good system. See these as the 3 sides of a triangle. You can only call it a triangle if it has 3 sides and 3 vertices. (Kalupu… geetalu geesi vadileyka)

Reliability: Yenda vachina.. vaanochina system saavakudadu. Pani cheseyali.
Scalability: Responding to change in load should be verrrrryy reasonable
Maintainability: Pani chese prati odiki abba SaiRam anipinchali

Reliability

Continuing to work correctly, even when things go wrong.

Generally speaking, when you say a system is reliable, it usually means that it is tolerant to faults to a certain degree.

Edaina teda kottadanni fault anukunte. Teda kottina pani chesinappudu fault tolerant antam.

Indulo rakalu untai amma.

1. Infrastructure (Hardware) faults (mostly ni tappu em ledu ammai)

2. Software faults (ade.. nuvvu ninna vadilesina NULL pointer eh)

3. Human faults (debba mida debba)

Aite fault is not the same as a failure.

Fault - Oka part of the system, specification nunchi deviate ayyindi
Failure - Mottam system eh bucket tannesindi

We generally prefer tolerating faults over preventing faults… Kani security vishayam lo idi cheste fruit aipotav bidda.

Summary: Fault-tolerance can hide certain types of faults from the end user.

Scalability

Load perigite tattukuntada ni system?

Aha.. ala kaadu bhaiah nuvvu VMs add chesestav sare. But ave enduku ani doubt.

Step 1: Define what is Load in your system

Load is basically calculated on the bottleneck of the system.

Bottleneck batti cheptam asalu scalable ah? Scale cheste ela cheyyali ani.

Step 2: Then define performance

Asalu ni system ki em avasaram? What does performance mean to your system?

For instance,
Batch Processing - Throughput avasaram
Online Services - Response Time avasaram

Step 3: Coping with Load

Scale-up or Scale-out and what exactly are you scaling?

Neeku extra compute kavala? Storage kavala? Memory kavala?

Gurtu pettuko

There’s is no magic scaling sauce

So ni system ki em kavalo telusukoni adi ichey.

Summary: An architecture is designed around that system’s load parameters

Maintainability

“Telugu bhasha lo naaku nachani oke okka padam” type stuff idi

Is it maintainable ante manaki ardham avvadu kabatti. Inka divide cheddam. Single person maintain cheste avvadu ga. Chala mandi unnaru.

Operability: Operations team ki chiraku teppinchaka

Simplicity: Kotta mutyam vaste prashantata undali aadiki

Evolvability: konchem flexible ga undela cheyyu. Repu poddunne okadu vachi naaku inko feature kavali antadu

Conclusion

Okati pattukunte inkokati vadalaku.

Just like, life, career and passion. Edi vadilesina mana jeevitaniki ardham undadu.

Most importantly… ratri sariki ni system bratiki undadu.

For starters. I started taking this course from IITM Pravartak on Applied Database Systems Engineering. This series will include the learnings, thoughts and experiences from the course.

Link: https://iitmpravartak.org.in/ADSE

What went down?

A little bit of philosophy along with a whole lot of linux. While we were deep into the ocean of processes a linux system has to handle, I was enlightened by this phrase.

Everything has a priority and everyone has a preference.

That hit hard. But don't worry I'm not going to be your philosophical friend today.

So processes have both a priority and a preference. Just because a process has a higher priority doesn't mean it will get to run first. The kernel has a preference.

For instance, a process with High Computation requirement can have a higher priority but the kernel will likely choose to give CPU time to a smaller process like a print job with lower priority.

No, the printer didn’t bribe the kernel.

This is because running the print job will only take a very small time on the microprocessor and hence, the kernel (essentially the scheduler) will have one less process to take care of in the process queue.

It’s not all black or white but linux tries to be fair here.

Oh! to be very clear, when and for what time a process gets to use the microcontroller is determined by 3 values: Preference, Realtime Priority and Nice Priority.

And…

That’s all lads. That was the first class. I swear Dr. Sankaran’s class was way more fun than what you just read.

We then went on to understand what the course will offer and the details about how we are going to play around with the linux kernel and kernel modules. Oh! I might need to brush up my C language. Every ounce of code that we write in this class will be in C. Okay, I am excited!

Sure then, I’ll be back after the next class to share what I’ve learned. Until then, happy hacking.

Quick Note: some of the keywords used above may not be the actual component or field names used in the linux kernel but they should give you an idea about what exists in the kernel.

Yes, that should be the goal. Make sure it flows through the reader's mind like an Ilayaraja's symphony. Inspiring new ideas. Connecting you with the moment. And just...

Okay, enough with Raja sir's music. Back to code.

So how do we make that happen?

Here are a few things that are stuck in my mind.

1. Use names that describe what you are naming. A method? use a verb. A class? use a noun or a noun phrase. A variable? Describe what it stores.

   Believe me, I have seen a fair share of variables in my short career that requires you to be an NSA agent to decipher what it means.

2. Don't name something as A and make it do B. That's borderline evil. Why would you even think of doing something like that?

3. a1 or a2 is not a meaningful name. An alphabet followed by a number is in most cases bad naming.

   Imagine calling Ram and Bheem from RRR as a1 and a2. Yeahhh... doesn't sound so good. Does it?

   Give your variables, methods and classes some character.

4. While we are here, please for the love of Rajamouli... don't create your own acronyms. MB is not the right name for MahendraBahubali. You see how it can be interpreted in multiple ways right?

5. Also, don't bring fancy movie names here. Why are you naming that thing Dumbledore? It isn't going to shoot Avada Kedavra on your bugs anyways.

That wasn't an exhaustive list but you get the idea. Name things in code with a short yet sensible name that makes the reader of the code understand what it does.

No one is awarding you to name things like a compiler. Name them like a human and you'll probably have thank yous of many programmers who are going to read what you are writing today.

That's one chapter. Let's meet for the next one.

Although I present the contents of the book in a fun and though provoking way, I highly recommend you to read through the book once to get a sense of it. You can find the book here.

Aight, so I have a friend who tried building a platform. In terms of engineering, not a lot of complex stuff but some auth here and some DB queries there and you should be good to go.

But the project never saw the light of day. Now, out of all the bottlenecks in the world (time, money, talent and everything else), the one thing that stopped the project was over-engineering.

"Over-Engineering?" you may ask

That's right. You can over-engineer stuff. Now, how's that a bad thing?

Sit down... I got some explaining to do here.

So, take a brand new product or a service that you want to build. How many users are you targeting initially?

If you answered more than 10, that's where the mistake lies. Unless of course, you know for sure.

Now, when you start building this product you think about scale, costs, pricing, architecture, performance and all the fancy stuff. I know this stuff feels good. I've been there in the never-ending tunnel of discussions about which tech stack to use and where are we deploying our application.

Now that rabbit hole of trying to achieve engineering perfection is over-engineering.

But...

None of that matters to your first user.

What they want is an answer to the question, "What are you doing to solve my problem(s)?"

Does the user say the application is slow? Aight, fix it.

Does the user say they don't like the colours? Fine, fix it now.

Does the user say there are too many buttons? Hmm... see what can be removed.

You see where I am going with this right?

Perfection is a perceived trait.

- Sampath Balivada (That's me :P)

Is it truly perfect?

What might be perfect for you might not be the same for someone else. And in the context of a product, oh boy the user's perception of perfection is way more important that any other stakeholders. (Of course, there may be exceptions here)

So... wait until the user tells you what their definition of perfection is and then act on it.

Imagine you engineer a perfect(?) solution that can scale to lakhs of users and can generate millions of rupees in revenue with enough users.

Ahhh... with enough users.

You got no users right now. Build a solution, get users, ask them how they like it and then try to achieve perfection.

Perfection from the perspective of the user. Not the engineer.

How do you stop chasing perfection then?

Easy (although it isn't). Build what's barely necessary using whatever tools you have available at hand and deploy it on whichever platform you have access to.

The user doesn't care about this stuff anyways. All they need is a solution to their problem.

Jugaad

You might frown upon this but yeah, build something that sticks, share it with the world and then sit down to make it better. That's the only way to avoid the rabbit hole or should I say the curse of perfection for all your products and features.

Try it out here: https://sampath.dev/bezier-curve-js/

Source Code: GitHub repo

How do we draw something on a screen?

In reality, everything on the screen is a drawing. Think in terms of pixels on the screen. How would you draw a line?

Just like any line on a Graph paper. Consider any corner of the screen as (0,0) or origin and consider two points start and end to draw a line from and to. We can get the line by plotting points for each point in the locus of the linear equation of the line.

Now, how do we draw a curve?

Think about it... I'll wait.

Now, that I too thought about it, I came up with this very huge solution. Remember each point in the curve and re-plotting when necessary. Although that would work, it's a lot of storage space.

So, Pierre Bézier came up with a solution for that after being annoyed while drawing designs for the Renault automobile company. The underlying math was established by Bernstein, way before the advent of Bezier Curves but Pierre Bezier brought the math and applied it into computer graphics.

Now, the math is simple here. We need to first understand how we are plotting straight lines.

Drawing lines

Consider that we are drawing a line from (0, 0) to (100, 0). So, we are drawing a line from x = 0 to x = 100.

We need to plot a point at x = 0, x = 1, x = 2, x = 3 and up to x = 100. To get these values, we can make use of the following formula and plot all values of xi.

xi = (x2 - x1) * t + x1

where t is in the range [0, 1]

plotting the line y = 0 and x = [0, 100]

This is how we can draw a line and this process is called interpolation. Remember the t, we need it for later. Let's move on to drawing a curve.

Drawing curves

I'll try to make it as easy to understand as possible but pay close attention here. This is the crux of it.

We are interpolating here between two points start and end, (0,0) and (100,0) according to our line example. Let's add a new point control with the coordinate (50, 50). This point will now define our curve.

As usual, we will interpolate here as well, but we will perform it between the points (start and control) and (control and end).

This will give us two new points for every value of t. Refer to the Drawing lines section if you don't know what this is. Let's consider them as pA and pB.

Now, for every value of pA and pB, we now interpolate between them. So, we will find the value as stated below.

pAt -> pA for a given value t, while interpolating between start and control
pBt -> pB for a given value t, while interpolating between control and end

pCt -> pC for a given value t, while interpolating between pAt and pBt

To make it much clear, let's consider the results for t =0. 1.

var xt = (p2.x - p1.x) * t + p1.x;

pA = ((50 - 0) * 0.1 + 0, (50 - 0) * 0.1 + 0) = (5, 5)
pB = ((100 - 50) * 0.1 + 50, (0 - 50) * 0.1 + 50) = (55, 45)

pC = ((55 - 5) * 0.1 + 5, (45 - 5) * 0.1 + 5) = (10, 9)

Similarly, we can find all the values of pC for every value of t in the range [0, 1]. Plotting these values on the graph will give us the following curve.

If you are confused about any step here, go back and read through the sections again or you can also comment where you are stuck and I'll try to elaborate if I can.

Multiple control points?

This curve here has just one control point, what if you need a curve with more than one control point? We can do that as well. We do the same operations as for the above curve and do it recursively.

The one we calculated above is called a Quadratic Bezier Curve. Similarly, one with two control points is called a Cubic Bezier Curve and so on.

Does my code perform all this interpolation?

The straight answer is 'No'. The reason is mathematics. Yes, it is necessary that we understand interpolation here to get the curve but in mathematics, we also have equations for curves. If we simplify the operation we are performing here, we can get a neat equation that we can use to get the point pC for a given value t.

This is what my code does.

// Quadratic Bezier Curve
// x(t) = (1−t)^2 * x0 + 2 * t * (1−t) * x1 + t^2 * x2

function calcQuadraticBezierCurveValue(c1, c2, control, t) {
    return Math.pow(1 - t, 2) * c1 + 2 * t * (1 - t) * control + Math.pow(t, 2) * c2;
}

// Cubic Bezier Curve
// x(t) = (1−t)^3 * x0 + 3 * (1-t)^2 * t * x1 + 3 * (1 - t) * t ^ 2 * x2 + t^3 * x3

function calcCubicBezierCurveValue(c1, c2, control1, control2, t) {
    return Math.pow(1 - t, 3) * c1 + 3 * Math.pow(1 - t, 2) * t * control1 + 3 * (1 - t) * Math.pow(t, 2) * control2 + Math.pow(t, 3) * c2;
}

A list of formulae for each type of Bezier curve can be found on Wikipedia here.

That's it, that's how we draw curves on our computer screens. That's some history and deep dive into how computers work. If you have suggestions or questions, drop them in the comments and let's talk. Feel free to play with the website and explore the source code.

It's a wrap!

What they actually mean.

Keeping the terminology aside, let's think about a piece of software we use every day, the browser. We give a link to the browser, or in other senses, we tell the browser the location of a piece of code it can fetch using the internet. Once the browser fetches the code, it starts to understand (parse) and execute the instructions in the code.

On whichever device we type "amazon.com" on, the device browser fetches the same code. Maybe you are opening it on a mobile phone that runs Android and has an ARM architecture that has a RISC instruction set or you are running it on a Windows PC with an AMD/Intel processor that is executing the x86_64 instruction set, but it doesn't matter.

We have a special application here that's taking care of it all for us. The mighty browser. In a sense, a browser is a Virtual Machine. It is providing our code with a platform to run on that is entirely virtual and is independent of the underlying architecture or jargon.

This is how Modern Languages like Java, Dart, Kotlin or Python work on different machines and devices.

Everyone who took a Java course or wrote some code in Java is aware that Java first compiles to a middle language i.e. Java Byte Code which is then compiled in runtime to Machine Code (or maybe the Assembly language in this case). This is called "Just In Time" (JIT) compilation. This JIT compilation is performed by a Virtual Machine (Java Virtual Machine). This JVM is akin to the browser.

The Java Virtual Machine (JVM) and the Python Virtual Machine are stack machines. What this means is that it stores data and performs operations on these data using a stack.

Android Virtual Machine

Android apps can be written in Java, meaning the syntax is there but Android apps cannot run on the JVM because they are not compiled to Java byte code.

Android apps run on the Dalvik Virtual Machine(DVM). At least they used to (Now, it moved to Android Run Time - ART) but the soul is there. It is a less resource-intensive Virtual Machine to run Dalvik Bytecode.

But there's another catch. The JVM is a Stack Machine but the DVM is a Register Machine. Meaning it works by manipulating the registers.

A JVM code to add two numbers 3 and 4 might look like this:

push 3
push 4
add

The same may be achieved in a Register Machine this way:

LOAD 3, R1
LOAD 4, R2 
ADD R1, R2, R3

We deal directly with the memory in a Register Machine.

So that's Process Virtual Machines and how computers understand stuff while we continue to write code in High-Level Languages. It's a boon that we are able to.

I want to try out hacking the Linux Kernel in weird ways and I want to make sure I am able to build it before changing bits and parts of it and experimenting.

I don't have a spare machine to do this stuff. Neither have I worked with Qemu or other emulation platforms to know what's happening with my kernel.

I'm not brave enough (yet) to install this "god knows what bugs it has" kernel on my only working machine to test things out.

I've been using WSL2 for a while to write code and build things, but I found that it also gives me a safe way to try a new or modified kernel and an emergency switch to the stable kernel if things go wrong, all while being able to interact with my computer and write code on it. Seems legit, so let's build it.

Please note that you need WSL2 to continue with the rest of the process. More info here .

Building the Kernel

The README.md file of the WSL2-Linux-Kernel repository gives us 2 commands to build the kernel on an Ubuntu machine.

Personally, I had to jump through little hoops before I could successfully build the kernel. So, here goes nothing.

Steps to Build the Kernel

Building On:

Platform: WSL2
Distro: Ubuntu-20.04
Edition: Windows 10 Home
Build Number: 19043.1348

1. Clone the Kernel Repository

If your aim is to just build the kernel and you are not planning to hack on it yet, you can directly shallow clone the microsoft/WSL2-Linux-Kernel repository.

git clone --depth 1 https://github.com/microsoft/WSL2-Linux-Kernel.git

If you are planning to hack on the kernel yourself and do some other stuff, it would be wise to fork the repository and then clone your fork.

git clone --depth 1 https://github.com/sampathbalivada/WSL2-Linux-Kernel.git

Here, I do not wish to have the git history locally so I am choosing to shallow clone, if you want the history, you can remove the --depth option.

2. Installing Tools

Kernels don't build (in other words, compile) by themselves. They need a compiler and other tools to build. For that, the repository README asks us to run the below command, so let's run it.

sudo apt install build-essential flex bison libssl-dev libelf-dev

While building the kernel, I encountered an error that required pahole, let's look into it at a later point as our primary goal now is to build the kernel.

Upon further research, I was able to determine that pahole is a part of the dwarves package. So, let's install it as well.

sudo apt install dwarves

Now, we have all the tools needed to build the kernel.

3. Summon the Makefile

Before we initiate the build, we may want to create an identity for ourselves using the version string.

So, let's modify the version

File: WSL2-Linux-Kernel/Microsoft/config-wsl

All set. Now, let's build our own kernel for WSL2.

make KCONFIG_CONFIG=Microsoft/config-wsl -j4

-j4 creates 4 parallel tasks for building the kernel. You may choose to increase or decrease the number 4 as per your liking but the thumb rule is that you create 4 parallel tasks if your PC has 4 cores and so on.

4. Build finished. What next?

So you are done with the 10-15 minute build process and would like to move on to using this kernel that you built.

A quick ls in the WSL2-Linux-Kernel directory will reveal that we now have a new file name vmlinux. That's the kernel we just built.

Now, let's move it to a location on the Windows Machine. I moved it to C:\Users\<username>\. You may move it to any location of your liking.

Now comes the neat part. Telling WSL to use our Kernel instead of the default one. How do we do it? Through a configuration file.

WSL allows us to specify global settings for all the distros using the .wslconfig file located at %USERPROFILE%\.wslconfig.

This is how I configured my .wslconfig file.

File Name: %USERPROFILE%\.wslconfig or C:\Users\<username>\.wslconfig

[wsl2]
kernel=C:\\Users\\sampathbalivada\\vmlinux

We now need to restart the WSL Virtual Machine for it to pick up the new configuration file and also use the kernel we built.

Open a new PowerShell window and type the following command to shut down all the running WSL2 VMs. Make sure to save your work before shutting down.

wsl --shutdown

Now open a new Ubuntu or your favourite distro terminal and type in the below command.

cat /proc/version

You should be greeted with your custom version name. It indicates that WSL is now running a kernel that's built by you. Phew!

Linux version 5.10.74.3-sampathbalivada-local-WSL2+

What's next?

In future blog posts, I will try to understand and elaborate on the different subsystems in Linux and how they work in cohesion with each other. We will also see if we can change some stuff in the kernel and play with it.

Assemblers

Assemblers are simple. They turn symbolic code (assembly) into machine code (binary). We can also write everything in machine code but it's much easier for us to make a computer do it. But, it is also hard to write an assembler in machine code.

Cross Compilation

So what do we do? We use a different computer to write an assembler in a high-level language like C++, Java or Python and use it to translate our assembly code to binary code.

The assembly code is not the same for every machine as platforms might change and it's the same case with Machine code as well. As the CPU changes, the type of operations it can perform will also change.

Cross Compilation is the process of compiling a piece of code on a computer where the output is compiled to be run on a different platform than the one we are compiling on.

A perfect example of cross-compilation would be mobile apps. Desktop PCs are built on the x86_64 platform whereas mobiles are built on the ARM platform but we compile mobile apps on Desktop and run them on mobile devices.

If you want to try out the assembler that I built for the course, you can find it here.

Game Consoles

Remember those game consoles that we plugged into the TV and inserted a cartridge that said 1000000 in 1? Those were computers (well technically).

They were 16-bit (fourth generation) and 32/64-bit (fifth-generation). These word sizes are somewhat debatable (click here for more info) but the real thing is that these were more like computers and had all the parts like RAM, CPU and even ROM.

The ROM is the 1000000 in 1 cartridges that we used to buy at local stores for Rs. 50/-. So we basically swapped out ROMs whenever we wanted to and the reset button just moved the PC (Program Counter) to 0.

Those glitches and random artefacts? The PC probably messed up the count or the ROM lost a bit somewhere. It's crazy to think that I had a computer even before I thought I had one and it used a CRT TV as a monitor.

Oscillators in Modern Computers

In the course, while building the CPU, we never thought of the Oscillator that gave us the clock pulse. It was treated as an external entity that the CPU knew how to handle. In reality and in modern computers, the oscillators are a part of the CPU.

To know why it's now moved inside the CPU we have to know that in the usual sense, an oscillator would be a different entity and the pulse would be routed to all the components that need a clock cycle to work with - CPU, Memory, Registers etc. In reality, each component in the computer can run at its own speed. The RAM chip currently in your computer might be running at 2333 MHz and your CPU might be running at a speed of 2.8 GHz. That's a lot of difference and there are mechanisms to handle it.

But for the explanation as to how oscillators are implemented modern CPUs, they are a part of the CPU or whichever component they are giving a pulse to.

von Neumann architecture

Let's think from a normal standpoint where we have a single memory device that both stores the program that we need to execute and also stores the data for the program during execution. There are two cycles in this operation. Since we can only operate once on the memory per clock cycle, we have to execute an instruction in 2 cycles.

The two cycles would be:

1. Fetch Cycle: we probe the memory for the instruction we will be executing.
2. Execute Cycle: once we have the instruction, we operate on the memory to store and retrieve the data required for the instruction.

This is how von Neumann Architecture handles instruction fetching and execution - in two cycles.

Harvard Architecture

To overcome this limitation of using 2 cycles, the Harvard Mark I relay-based computer, stored instructions on punched tape (the ROM) and data in electro-mechanical counters (or in other words, the RAM).

That's where the architecture got its name from - Harvard Architecture.

Why is this better? The CPU can access both the instruction to execute and also the data required to execute the instruction in the same cycle. So, for something that needs 48 clock cycles to execute, we can finish it in 24 clock cycles. This is quite advantageous and saves time but it's costlier as we need to maintain two memory devices instead of one.

What architecture does my CPU follow?

CPUs that are currently in use implement a modified version of the Harvard Architecture, which is called as, lo and behold, Modified Harvard Architecture. The most significant modification is the use of a split-cache where we implement memory hierarchy and store the instructions in separate data and instruction memory at low levels. The modification is that, instead of having 2 address spaces, one for instructions and one for data, we use single address space.

Handling I/O

I/O in a computer is handled by the device drivers. But how? The devices, when working, put a value into a memory location, say the mouse will continuously write its change in location value to the memory at address 7345, the driver will continuously look into that location and get the value to work with and changes the location of the pointer on the screen accordingly.

The computer that I am building as a part of the course takes input from the keyboard and outputs it to a virtual screen of dimensions 512x256. So there are 512 pixels horizontally and 256 rows of those 512 pixels.

For each pixel, we store the value to be displayed in the memory using bits in memory. For a black and white screen, we can consider the pixel as black if the value is set to 1 and white if it is set to 0.

The set of bits that define the pixel values of the screen is called the Screen Memory Map or VRAM (Video RAM). In real-life computers, it is defined somewhere from 64 to 128 MB. If the computer has a dedicated Graphics Processing Unit (GPU) this number will usually be much higher.

Similar to this, the keyboard also writes to a memory location and it is called the Keyboard Memory Map. In the computer that I am building, this is a 16-bit register and is more than enough to represent the ASCII coded values on the keys and can also support Unicode values if necessary.

Machine Language

The Machine Language is the most important interface of a computer. It specifies the interaction between the hardware and the software of the computer. Wasn't this the kernel? Well theoretically yes but the Linux kernel is written in C and Assembly which is converted to Machine Language.

Machine Language is in Binary and they directly correspond to the hardware implemented in the computer. For instance, if the hardware has an implementation for Addition, there is a binary code for that operation.

Because Machine Language directly corresponds to the hardware implementation of a computer, so there are two things that can change in a Machine Language:

1. Set of operations available. (Division, Bulk Copy, etc.)
2. Data Types (Register Width, Floating Point, etc.)

Memory Hierarchy

Fast memory is expensive, large memory is slow. For this reason, we have a memory hierarchy. We arrange faster and small memory close to the CPU and slow and large memory farther from the CPU.

This solves 2 problems:

1. Need to supply long memory address
2. Getting the memory contents of the CPU

Flow Control

Computers execute commands and operations in a sequence. To control the sequence in which operations are performed or to repeat the same operations again and again, we use Conditional and Unconditional jumps.

The types are many but the ways they work are not

So, there are types of memory, Cache, RAM, ROM, Secondary Memory like Flash, etc. but all of these are fundamentally doing the same thing. At least from a logical standpoint.

What they have is a group of registers that work together. Now, what is a register you ask? That's the neatest part of a memory chip that creates an illusion of storage.

Repeat until I tell you to change it.

That's it, that's the principle behind the working of a register. Let's say you have a friend, you ask him to shout out 45 until you tell him not to. Now, did you really ask your friend to store it? Nah but you can at any point in time of the future listen, and determine that you asked him to shout out 45. You didn't store it, you just made sure it is repeated enough into the future. Neat eh? That's how a register works.

This is called the state of a register and it creates an illusion of storage. There's also another thing a register is defined with, it's the word width. In the virtual computer that I am building the word, length is 16-bit as It's a 16-bit computer that I am building.

RAM (Random Access Memory)

RAM can be thought of as a sequence of addressable registers. At any given point in time, only one register in the RAM is selected. To select we use a selection number that is of width k. Here k = log2(n) where n is the number of registers we have in the RAM. As RAM is created using a set of Registers which are built using Data Flip Flops, RAM is basically a sequential chip.

Now, where does RAM get its name from? From the ability to select any Register and know what's in the register instantaneously. Like seriously, even if you just queried the 1st register, you can immediately ask for the 3678th Register and you get it in a clock cycle. It's just a matter of selection rather than searching. Definitely a thing of beauty.

The Heart Beat

Sequential Logic is when we introduce the concept of time to computing. I see it this way, let's just say we made an AND gate to calculate the AND for a pair of binary digits. Now, when should I read the output? immediately? after eternity?

Now time is in reality, not discrete enough to say, "I'll wait a millisecond and then read it". So, the computer has its own way of calculating this. It's called a clock. So, there is a tick-tock inside the computer maintained by an oscillator, and we do something during the tick and read its value during the tock. In reality, this happens a lot of times, like a few billion times a second. That's what that Ghz is. So each GHz is 1 billion clock cycles per second. A cycle is a complete tick-tock.

So far what I did was Combinatorial Logic. Let me explain this. Consider that time is divided into integer time steps. And let us consider an instant of time to be 't'. Then we can represent combinatorial logic and sequential logic this way.

Combinatorial Logic: out[t] = function(in[t])

Sequential Logic: out[t] = function(in[t-1])

It's important to make it clear that this sequential logic is how computers remember things.

The basis of Sequential Logic in Computers

Like how NAND are the fundamental building blocks of logic, Clocked Data Flip Flops are the fundamental blocks of sequential logic. In reality, they are also built using NAND gates but this fact is generally ignored to keep the two types of logic separate and isolated.

Von Neumann Architecture

Von Neumann Architecture is the crux of any computer. Of course, the design goals and the type of designs change a lot. If you study networking then you could say that the Von Neumann Architecture is to Computer as the TCP/IP model is to networking. Not so standardized but gets you moving and helps you to understand what's going on.

Now when we talk about ALU, we may go ahead and implement every operation that we want using it, like Addition, Comparison, Subtraction, Multiplication, Division, etc. In fact, modern Microprocessors implement very specific types of things at a hardware level. For instance, SoCs like Apple Silicon M1 Pro and Max have a media engine that natively encodes and decodes the ProRes video codec. This is because the transcoder is not implemented at a software level but rather it's moved to a Hardware level.

Efficiency While Adding Numbers

Now the computer that I am building (Of course it's a virtual computer) uses a rather inefficient technique to implement an Adder. The carry bit is passed from one FullAdder to the another but in the real world, that's a lot of gates and will lead to a significant loss in time.

We have to remember that an Adder is supposedly the most fundamental part of a computer and it is necessary that we build it as efficiently as possible. Introducing a much more efficient Adding method, Carry Look Ahead.

it does exactly what it says, instead of having a carry while adding each set of bits, we prematurely calculate the carry bit as a separate set of operations to the bit addition. Here is a good explanation for it.

By the way, the Virtual Machine that I am building is a 16-bit computer. So, the word length is 16 bits. Modern computers like the phone or laptop or whatever the screen you are reading this blog on are usually 32-bit or 64-bit.

PS: For readers who speak Telugu
What is an ALU? ALU ante... ALU sir. : )
(If you know, you know)

Representing decimal in binary

A decimal can be represented as a sum of powers of 2. In this way,

99 = 64 + 32 + 2 + 1 = 1100011

A word, please.

A word is a unit of data with a fixed number of bits. It tells us, how big of a number a computer can or particularly a processor can evaluate. Now we have 0 or 1 that we can represent using just a single bit. What happens if we want to represent maybe the number 2 or 3? We use 2 bits. So, the length is varying depending on the decimal number. We don't want a computer to guess if 110 is a 12 or if it's a 6. A word defines that length. Now, if we have a 4-bit word, we represent 110 as 0100.

Creating an ALU

The most fundamental thing in an ALU is the Addition functionality.

We build the basic arithmetic this way:

Addition -> Negation -> Subtraction -> Comparision -> (Multiplication -> Division)

Multiplication and Division are implemented in software rather than in the hardware as they are easy to build that way. Multiplication is built using Addition and Division is built using Subtraction. That's the reason why Multiplication is less expensive than a Division operation. So, why is subtraction more expensive you ask. Good question, cause we subtract using a method like this.

y - x = y + (-x)

So, how do we represent Negative Numbers?

Initially, we used something called a sign bit, but it's kinda not elegant.

Usually if you don't have something elegant, it is going to bite you.

So, now we use 2's complement to do this stuff, which is elegant. In 2's complement we represent all numbers as 2^n - x.

Basically, we can use the Disjunctive Normal Form to get a Boolean function that can be later simplified to well-known gates. The crux is that we simplify our implementation process by relying on simpler things that we built in the past.

How exactly can we prove that everything can be built using NAND gates?

If we try to apply DNF to truth tables, we can deduce that every Boolean function can be represented using only AND, OR and NOT gates.

We can also derive OR using AND and NOT gates. (I am not going to tell you how. Hint: De Morgan's Law)

And by the power of combination, we have the NAND gate which can be used as an elementary gate to build every other gate and implement all Boolean functions that we want to.

What is a Chip?

A chip or a gate provides an interface for the user. It specifies a set of input wires and the output wire(s). This is defined in an HDL stub file. The chip developer/builder has a contract that they will not change this. The chip designer decides what this interface will be.

A chip has to be implemented. The black box has to be defined by someone, that someone is the builder. They now use the magic of Boolean logic and the various gates available to them to implement the chip as defined by the interface and the truth table stated by the Designer.

Before we move to other stuff, we have to also make a note that hardware construction projects for these chips are made by two kinds of people.

1. System Architect / Designer who creates the Chip API, test script, compare file for the chip interface.
2. Developers who implement the chip interface and develop the implementation for the chip defined.

More about HDL

HDL is a functional/declarative language so order doesn't matter.

Common HDLs:

• VHDL
• Verilog

These HDLs are much more complex and have advanced functions like loops to ease the chip implementation process.

So chips or what we refer to as CPUs are created as a combination of gates. Usually in billions. These gates are transistors that are etched in silicon. So, someone drew billions of transistors on a piece of metalloid (silicon) and now you are able to read this article on your device. Dammit... that's probably the most complex thing ever existed in the entire known history of humankind and the fact is that it is built on simple mathematical logic. This mathematical logic is combined and formulated as logic gates.

What is a logic gate then?

For starters, a logic gate is like a black box, that takes single or multiple inputs and produces a single output. So, if we were to imagine that in a real-world scenario, think of it like a cardboard box with copper wires going in and one wire coming out. We let electricity flow to different input wires and depending on which input wires have electricity flowing through them, something happens inside and we get electricity through the output wire or we don't.

Now, there are different types of logic gates like AND, OR, XOR, NAND, etc. Often in computer science, we say that computers are built using just one logic gate, i.e. NAND gate. This is because we can create any gate with a combination of NAND gates. We can basically chain one box's output to another box's input.

Do we really use only NAND gates in a CPU?

For a virtual computer, this can be okay but for an actual chip, it's not the most ideal way to go. For a real-world CPU, we can build a chip using different types of gates based on the different types of workloads that we run on the chip. Using multiple gates to create a new gate is not always the best way as less number of gates directly relates to speed.

So how are chips designed in real life?

Prototyping and testing chips practically in a lab is a costly affair. Fabrication is hard and very very costly. And if somehow we end up missing out on that one gate, it's more than impossible to repair something at the scale of nanometers. So we use VHSIC Hardware Description Language (VHDL or simply called HDL)

The above is my understanding of the hardware inside a computer from the perspective of a computer scientist and not a substitute for the actual learnings of a chip designer.

We are usually worried about the what of everything we come across. What should I use to get an output? The print function. What should I use to get user input? The input function, etc.

But very few times, or at least never, we do not ask the question, How?

The "what" is abstraction and the "how" is implementation.

Don't worry about the rest; just worry about what it's supposed to do and trust that someone else worried about the how.

Separating concerns is the most potent tool in computer science. We forget the implementation once it's done and only care about what it does.

This really gives us a perspective about various problem-solving techniques that we use like divide and conquer, dynamic programming, etc. where we implement a solution for a small problem and then forget what it does and only zoom out and focus on the bigger picture that we get.

I would say, it is a boon that we are able to do that and all of this is possible only because we have efficient interfaces that we can talk with.

This also highlights the importance of good naming conventions and writing function and variable names that do and store what they exactly sound like. Now, we definitely don't have to worry about how something is implemented and trust the interface to actually depict what is happening under the hood.

I also recently discovered that Apple uses seriously long names for some of its iOS APIs. (I was unable to find the most recent API but here is an example. Link). Now, maybe I can justify long names and actually write them out instead of trying to make them very short or have very weird names like "abc, "xyz" or the holy word "temp", which I suppose will definitely fail to represent what the function does.

Alright, let me confess a bit here. I'm not a fan of the frameworks. I understand the benefits they give me but given the scale at which I build stuff (literally next to none?), all those fancy frameworks like React, Angular, Vue and Flutter Web are just... you know, overkill.

I've always built my personal website and any short and small projects with plain and pure HTML, CSS and JS up until now. I've worked with a team to build a website for the Dept. of Computer Science and Engineering of my college which, lo and behold, we wrote in pure CSS and JS. Scary eh?

Yes it was, but we were the rebels we were and just hated all those bundling, transpiling, compiling and everything in the middle. And for our inexperienced eyes and hands, the document.getElementById() function was more than enough to build a website.

Of course, we completed the website and it was fast and all. It wasn't the most responsive website we ever built but hey, we were learning.

Fast forward to just an year ago, I would still prefer this plain old JS and CSS cause why not. It was getting my work done and I didn't have always tidy up everything into a bunch of folders and all. I just use a single JS file and make it as readable as possible.

I was building desktop apps with electron and building websites for a lot of purposes at the same time was building mobile apps with Flutter. I just missed the reactivity and reusability that Flutter offered. Although, I built applications with React at this point, I just knew it was overkill.

Now meet this new age framework I discovered, Svelte. Now this is a framework but it barely looked like one to me. Why? Cause it didn't change a lot of the structure of html and reactivity felt built in. Like I could just drop the document.getElementById() statements and call it a day cause it is just similar to vanilla web.

It also had an added advantage of components. So, I create a card and make it look exactly like I want it to but later when I find something annoying and have to change it, I just need to change it in a single file and the entire website will have the updated card without me copy pasting that card again and again. (I know we can achieve this in vanilla web as well but, confidence, confidence that we will never change that card again, but eventually we do)

So, I started using Svelte and discovered that a lot of things are already reactive, like do you want to reactively respond to a change in screen/window size? You can do that (without writing any additional functions). Only want to apply a CSS property to a h1 tag inside a component? That's the default way. Want to change the text color for all the text boxes? Yup, just edit everything in the global.css file. All of this while also being as close to actual vanilla web as possible. It felt like going from C to C++ rather than going from C to Java, C being vanilla web, C++ being Svelte and Java being frameworks like React JS.

So, that's it? Svelte is the framework to use for everything?

Nah! At least not yet for me. Frameworks like react, vue and angular have huge communities around them building stuff. A lot of startups choose them for the same reason. Svelte, I would say is still very young and for some things, chances are that you need to create a package and release it out on npm.

For me it currently looks like a good way to introduce people to reactivity. In an age where people start learning React and then learn HTML, CSS and JS and try to wrap their head around JSX. This framework can be a good starting point to learn the building blocks of web and also understand why we need reactivity and reusability in our applications/websites.

Svelte, is now my de facto framework for building small projects with ease. If you would like to see the kind of projects that I build with Svelte, you can take a look at podcast.cacheho.in and my landing page sampath.dev.

The opinions stated in this blog post are my own and do not represent that of my employer.