DEV Community: Vinod Mathew Sebastian

AI for Everyone: A Beginner's Guide to Machine Learning

Vinod Mathew Sebastian — Fri, 06 Dec 2024 16:17:40 +0000

With the advent of chatbots like ChatGPT, Artificial Intelligence (AI) has entered mainstream.

ChatGPT is a transformer, which is a neural network architecture that is primarily designed for sequence-to-sequence tasks, such as machine translation, text summarization, and chatbots. The Transformer's key innovation is its self-attention mechanism, which allows the model to weigh the importance of different input elements relative to each other.

But a Transformer is not the only language model around. Another model, BERT (Bidirectional Encoder Representations from Transformers) is built on top of the Transformer architecture and is specifically designed for natural language understanding tasks, such as sentiment analysis, question answering, and text classification.

The Transformer is a sequence-to-sequence model with an encoder-decoder structure, while BERT is a single encoder-only model that uses a bidirectional Transformer encoder. Both models are based on the Transformer architecture. BERT is a pre-trained language model that's specifically designed for natural language understanding tasks, whereas the Transformer is a more general-purpose sequence-to-sequence model.

In this article, I’m trying to give a gentle introduction to the topics of artificial intelligence, machine learning and deep learning.

What is artificial intelligence?

Artificial Intelligence (AI) is a broad field that encompasses a range of disciplines and techniques. Here's a breakdown of the key areas that constitute AI:

Machine Learning (ML)
Machine learning is a subset of AI that involves training algorithms to learn from data and make predictions or decisions. ML includes:

• Supervised learning
• Unsupervised learning
• Reinforcement learning
• Deep learning
Natural Language Processing (NLP)
NLP deals with the interaction between computers and humans in natural language. It includes:

• Text processing
• Sentiment analysis
• Language translation
• Speech recognition
Computer Vision
Computer vision involves enabling computers to interpret and understand visual data from images and videos. It includes:

• Image processing
• Object detection
• Facial recognition
• Image segmentation
Robotics
Robotics involves the design, construction, and operation of robots that can perform tasks autonomously or with human guidance.
Expert Systems
Expert systems are AI programs that mimic the decision-making abilities of a human expert in a particular domain. They include:

• Knowledge representation
• Reasoning and inference
• Decision support systems
Planning and Scheduling
Planning and scheduling involve using AI to optimize and manage complex tasks, such as:

• Resource allocation
• Scheduling
• Planning and decision-making
Knowledge Representation and Reasoning
Knowledge representation and reasoning involve creating and manipulating knowledge graphs, ontologies, and logical rules to reason about the world.
Human-Computer Interaction (HCI)
HCI involves designing and developing interfaces that enable humans to interact with computers and other devices in a natural and intuitive way.
Cognitive Computing
Cognitive computing involves creating AI systems that can simulate human thought processes, such as:

• Pattern recognition
• Learning and memory
• Problem-solving and decision-making

These areas are not mutually exclusive, and many AI applications involve combining multiple disciplines to achieve a specific goal.

What is Machine Learning?

Machine learning is a subset of artificial intelligence (AI) that involves training algorithms to learn from data and make predictions, decisions, or recommendations without being explicitly programmed.

How Machine Learning Works?

Machine learning involves the following steps:

Data Collection: Gathering data relevant to the problem you want to solve.
Data Preprocessing: Cleaning, transforming, and preparing the data for training.
Model Selection: Choosing a suitable machine learning algorithm for the problem.
Training: Training the model using the prepared data.
Evaluation: Evaluating the performance of the trained model.
Deployment: Deploying the trained model in a production-ready environment.

Types of Machine Learning

There are three primary types of machine learning:

Supervised Learning: The algorithm is trained on labeled data to learn the relationship between inputs and outputs.
Unsupervised Learning: The algorithm is trained on unlabeled data to discover patterns, relationships, or groupings.
Reinforcement Learning: The algorithm learns through trial and error by interacting with an environment and receiving feedback in the form of rewards or penalties.

What are the applications of Machine Learning?

Machine learning has numerous applications across various industries, including:

Image and Speech Recognition: Self-driving cars, facial recognition systems, and voice assistants.
Natural Language Processing: Sentiment analysis, language translation, and text summarization.
Predictive Analytics: Forecasting sales, predicting customer churn, and identifying potential risks.
Recommendation Systems: Personalized product recommendations, content suggestions, and job matching.

Machine learning is a rapidly evolving field, and its applications continue to expand into new areas, transforming industries and revolutionizing the way we live and work.

What is Deep Learning?

Deep learning is a subset of machine learning that involves the use of artificial neural networks to analyze and interpret data. Inspired by the structure and function of the human brain, deep learning algorithms are designed to learn and improve on their own by automatically adjusting the connections between nodes or "neurons" in the network.

Key Characteristics of Deep Learning

Artificial Neural Networks: Deep learning uses artificial neural networks with multiple layers, allowing the algorithm to learn complex patterns and relationships in the data.
Large Amounts of Data: Deep learning requires large amounts of data to train the network, often in the order of tens of thousands to millions of examples.
Automatic Feature Learning: Deep learning algorithms can automatically learn relevant features from the data, eliminating the need for manual feature engineering.
Multiple Layers: Deep learning networks typically consist of multiple layers, each of which processes the input data in a different way.

Types of Deep Learning Networks

Convolutional Neural Networks (CNNs): Designed for image and video analysis, CNNs use convolutional and pooling layers to extract features.
Recurrent Neural Networks (RNNs): Suitable for sequential data such as text, speech, or time series data, RNNs use recurrent connections to capture temporal relationships.
Generative Adversarial Networks (GANs): Comprising two neural networks that compete with each other, GANs are used for generative modeling tasks such as image synthesis.

Applications of Deep Learning

Computer Vision: Image classification, object detection, segmentation, and generation.
Natural Language Processing: Language translation, sentiment analysis, text summarization, and chatbots.
Speech Recognition: Voice assistants, speech-to-text systems, and voice biometrics.
Robotics and Control: Control systems, robotics, and autonomous vehicles.

Deep learning has revolutionized numerous fields by enabling machines to learn from data and make accurate predictions or decisions. Its applications continue to expand, transforming industries and improving lives.

Conclusion:

In current practice, more than three-quarters of the models uses supervised learning while there is growing interest in unsupervised learning, reinforcement learning, and other areas, as researchers and practitioners continue to explore new problems and applications.

If the data available is highly structured, like financial data formatted in a spreadsheet, a machine learning algorithm would be sufficient to infer patterns from the data. But if the data is unstructured like images, audio or text documents, then a deep learning model becomes necessary.

If there is a simple rule-based system we can program, then there is no need for machine learning.

But as the data we explore gets complex and the relationships between them need a lot of rules even to make sense of, then it is better suited to leave it to a machine to understand and decipher meaningful relationships between them.

Welcome to the world of machine learning!

How I run Android Studio on Old Hardware

Vinod Mathew Sebastian — Sat, 06 Jan 2024 06:35:20 +0000

Android Studio's system requirements say that you need at least a second-generation Intel Core processor or equivalent to run Android Studio.

I had overheating issues with my Core i5 first-generation laptop. During the initial scanning and indexing phase itself, the laptop would shut down due to CPU overheating.

I managed to solve the problem. I thought I write a blog so that other people who bump into the same issue may be able to fix it.

The first thing I did was a hardware fix. I cleaned the fan and the CPU heatsink, and applied a new thermal paste between the heatsink and the CPU.

This is important - thermal paste facilitates efficient heat transfer between the CPU's surface and the heat sink, enabling faster cooling. After a while, the thermal paste's efficiency decreases, thereby overheating.

Then on Android Studio, I toggled on the Power Save mode. File > Power Save Mode

On Linux, I also actively started to monitor CPU temperatures.

watch sensors

During indexing, whenever the CPU temp reaches about 100 degrees I would press 'pause'. Only after a while when the CPU cools down a little bit, then would I again press 'resume'.

This fixed the initial problems. But again, when I would later go on to run Gradle build, the system would shut down due to overheating issues.

I then increased Android Studio's heap memory size from the default 2GB to 3GB. Help > Change Memory Settings

Also, I opened the gradle.properties file in the root of my project folder.

I added these lines:


org.gradle.daemon=true

org.gradle.configuration-cache=true

org.gradle.caching=true

Still, this is a pain to build for the first time. I have to cancel the build due to overheating, but since I have enabled caching, I can start from where I have left off.

This is cumbersome, but it still gets the job done - Develop a modern android app and install it into a physical device.

Happy Developing!

Base64 Encoding Explained for Security Professionals

Vinod Mathew Sebastian — Fri, 27 Oct 2023 12:23:43 +0000

Hashes (which are one-way operations that convert a block of data into another block of data) are usually encoded in base64.

Base64 is also used in encoding cryptographic keys.

It is even used in databases.

To learn about base64 encoding, we start with binary encoding.

Binary (literally means consisting only two) is the language of digital electronics. There can only be two states. A 'high' or 'on' state or a sufficiently 'low' or 'off' state. This can easily be represented in binary using 0s and 1s. There is Boolean algebra which is a whole branch of algebra that deals with binary states.

Inside a computer, data is usually encoded in binary. The binary number system (base 2) is the basis for all binary encoding.

text = "user"

# This is the binary representation of "user":

# 01110101 01110011 01100101 01110010

Binary data strings can be very long and cumbersome to deal with. So another number system, the hexadecimal system which has the number 16 as the base is used.

Every digit in binary data represents a power of 2.

If there are 4 binary digits, it can be replaced with 2^4 ie 16 (the hexadecimal system or 'hex' in short).

The beauty of hexadecimal is that every four digits of binary data can be represented with one hexadecimal number. So one byte (which is 8 bits long) can be represented with two hexadecimal numbers. It easily became the shorthand system for computer data.

text = "user"

# This is the binary representation of "user": 

# 01110101 01110011 01100101 01110010 

# This is the hexadecimal representation of "user":

# 75736572

It is so easy to map binary to hexadecimal. A byte (which is the smallest unit of physical memory in a computer that programmers can directly access) can be represented with two hex numbers. Just take the first four binary digits and map it to the corresponding hex, then take the next four bits and replace it with one hex, and so on. We have a shorthand notation.

However, when transmitted over the internet, large amounts of data in binary form can be subject to data modification and data loss. That is why we encode binary data into another format. But if we try to encode a binary file into hexadecimal, it will take double the amount of space. (One byte will become two bytes) To send large amounts of data across the internet, there has to be a form of encoding other than binary, or hexadecimal.

Hence base64 was invented.

In base64 encoding which is 2^6 (64) (3 binary digits are taken (3*8 = 24 bits) and it is represented by 4 bytes of base64 data (6*4 = 24 bits).

So every 3 bytes become 4 bytes in base64 encoding.

text = "user"

# This is the binary representation of "user": 

# 01110101 01110011 01100101 01110010 

# This is the hexadecimal representation of "user":

# 75736572

# This is the base64 encoding of "user":

# dXNlcg==

I was wondering if there would be a base32 encoding. 2^5 is base32 and we take 5 binary digits as a unit and use it as a base to encode 8 bytes of binary data (5*8 = 40 bits). Every 8 bytes shall be encoded with 5 base32 numbers (8*5 = 40 bits)

In fact, there is one base32 number system. But it is not widely used since it is not as efficient as base64. Base32 encoding will increase the file size by 60 percent.

Base64 increases it to only 33.33 percent (3 bytes becomes 4 bytes).

Hex is most suitable for representing binary data, but for encoding, base64 is the most widely used system.

Happy programming!

How to Save Time and Improve Workflow by Automating with Bash Scripts

Vinod Mathew Sebastian — Fri, 11 Aug 2023 20:51:14 +0000

The command line is the fastest, easiest, and sometimes the only way to work with a computer. Ask to substitute spaces with underscores from filenames - a few hundred of them in a folder - and you know what I mean.

Even better, we can write bash scripts and use them. We can reuse them for repetitive tasks. And save a lot of time and improve workflow in the process.

Here, I am going to write three scripts that automate regular tasks.

A custom command to control the brightness of the screen
A script to open any file in any folder by typing only a part of the filename, and
Another script to replace spaces in filenames with underscores.

Prepping

We need a folder to save our scripts. In the home directory, make a new folder.

:~$ mkdir automation_scripts

This is the directory we save all our scripts. We need to add this to the $PATH variable to make our scripts executable from any location on this computer. And they become commands.

Locate the .bashrc file and open it with a text editor. Append this line to the end of the .bashrc file

export PATH="$PATH:$HOME/automation_scripts:$PATH"

Run the command source $HOME/.bashrc for the changes to take effect.

If we do this, there is no need to restart the system.

Now we shall write and save scripts inside this folder.

Change the display brightness with a custom command

We can use the xrandr command for changing brightness.

From the man pages:

It is used to set the size, orientation and/or reflection of the outputs for a screen. It can also set the screen size.

The syntax is:

xrandr --output value --brightness value

Firstly, we have to find the --output for our use case.

Type xrandr --q on the command line and press ENTER.

We get something like this:

Screen 0: minimum 320 x 200, current 1366 x 768, maximum 8192 x 8192
eDP-1 connected primary 1366x768+0+0 (normal left inverted right x axis y axis)

Another command is xrandr --listmonitors

See the line eDP-1 connected primary --

So here --output shall be supplemented with eDP-1.

Just be sure to replace it with whatever you get from your screen.

The brightness value can be anything between 0.1 and 1.

While 1 is the normal display brightness, anything below 0.5 shall be pretty dark. So use it with caution.

Now we create a file called brightness inside automation_scripts and add the following lines.

#1 /bin/bash
# A simple script to control brightness of the screen.

param=$1

xrandr --output eDP-1 --brightness ${param:-0.8}

Let me explain the code a little bit.

I'm using the positional parameter $1 inside the script. It takes the value we give when we invoke it. With ${param:-0.8} we set a default value of 0.8 for --brightness.

Enter the following command to make it executable:

:~$ chmod +x ~/automation_scripts/brightness

Now, type in the command

:~$ brightness

and press ENTER.

Open Sesame! The screen dims.

When we ENTER,

:~$ brightness 1

It becomes brighter again.

From now onward, every time we need to change the brightness, no need to type

xrandr --output value --brightness --value

Simply type brightness and a value between 0.1 and 1.

Usage:

brightness <value>
#A value between 1 and 0.1

If we don't enter anything, brightness assumes the default value of 0.8.

This is cool. Isn't it?

Open any file using a script

Commands like open and xdg-open opens any file with the default application. But only if we know the filename. What if we only know only a part of the filename?

For this, we can make a script called fileopen inside the folder automation_scripts.

#! /bin/bash
#Open any file from anywhere on the computer by partly typing the file name.

path=$3

app=$2

ls $3 | grep -E "$1" |  xargs -I {} "${app}" "{}" &

Code Explanation: The ls command lists folder contents, and it is piped into grep which searches for the pattern supplied by us at invocation. The xargs command then makes it the argument for the app we specify to open it with.

The syntax is:

fileopen <filename> <appname> <path/to/file/(optional)>

If we know that there is a song with 'my_heart' somewhere in the filename, we can simply type fileopen my_heart vlc assuming that we are in the same directory and VLC media player has been installed.

Another example: fileopen "some_text_file" xed or

fileopen "some_pdf" xviewer $HOME/pdf/

Substituting spaces in filenames with underscores

In the introduction, I have talked about substituting the spaces in the filenames with underscores. Because when you download something from the internet, say, YouTube videos, the filename might contain spaces. If the filename contains spaces, we can't open it with a script like fileopen from the previous example.

Firstly, we need to remove the spaces from the filename.

So, we make another script called remove_spaces.

#! /bin/bash

dir=$1

for file in "$dir"/*.* ; do

temp=${file//" "/_}

mv "$file" "$temp"

done

Code Explanation: This script loops through every item inside the folder, replaces spaces with underscores in the filename, and saves it to a variable called temp. Then the original file is renamed with the temp variable.

Usage:

remove_spaces </path/to/directory>

The spaces inside the filenames shall all be replaced with underscores.

Closing Thoughts

I have created three commands above: brightness fileopen and remove_spaces with their syntax. Likewise, we can write scripts for automating anything that we regularly do. I hope the examples illustrated above inspire you to write bash scripts for your use cases, save valuable time and improve your workflow.

Happy Automating!

How I unsuccessfully tried to recover my lost password

Vinod Mathew Sebastian — Thu, 03 Aug 2023 18:57:58 +0000

Among other things, I am a typist.

I am comfortable with typing to the point that a long time ago I started to enter passwords by typing - without even looking at the keyboard.

Earlier I had some data which I compressed, encrypted, and password-protected with the popular compression utility - 7z.

I then chose an eight-letter password. It is weak by today's standards.

The aim was to protect it from the prying eyes of other people who use the computer - nothing too serious.

I compressed a few files and folders with 7z and deleted the original ones.

But when I tried to open them later, some of them simply would not open.

The passwords I thought I used were not the passwords 7z used to encrypt them.

That was when I started to think about the ways to recover them.

I started with rarcrack - an open source 51 kb tool for brute-forcing 7z files.

This program would try to generate all types of combinations with the 8 letters we give - not in any particular order. Then it tries to brute-force it open with the passwords it generates.

But after some time I found the process too slow.

I felt that it would take an eternity before I get my files back.

I hit ctrl + c.

The next option was John the Ripper.

Programs like 7z hash the password.

Once hashed, no one - no program can find the original string.

Hashing - the process is irreversible.

So what does John the Ripper do?

John breaks passwords by comparing the hash value of the password it generates with the original hash.

Once it finds a match, John knows the password.

Another hugely popular option is Hashcat.

Again, I thought these would be overkill for a job like this.

I did a little math.

It is an 8-letter password.

Every key has only two characters.

This is a binary choice scenario.

So, there would only be 256 possible password combinations.

2^8 = 256

If we know the password, we have this bash one-liner to execute on the command line.

password=<password> ; 7z x -p$password name_of_the_file.7z

I tried to automate the process.

I generated all the possible 256 matches with this Python script.

first_letter = ['r', 'R']
second_letter = ['o', 'O']
third_letter = ['c', 'C']
fourth_letter = ['k', 'K']
fifth_letter = ['s', 'S']
sixth_letter = ['t', 'T']
seventh_letter = ['a', 'A']
eighth_letter = ['5', '%']
password_string = '\"'

for x in range (0,2):
    for y in range (0,2):
        for z in range (0,2):
            for a in range (0,2):
                for b in range (0,2):
                    for c in range (0,2):
                        for d in range (0,2):
                            for e in range (0,2):
                                password_string = password_string + first_letter[x]+ second_letter[y] + third_letter[z] + fourth_letter[a] + fifth_letter[b] + sixth_letter[c] + seventh_letter[d] + eighth_letter[e] + '\", \"'

print(password_string)

Then another script to generate the bash file.


passwd_array = [ "rocksta5", "rocksta%", "rockstA5", "rockstA%", "rocksTa5", "rocksTa%", "rocksTA5", "rocksTA%", "rockSta5", "rockSta%", "rockStA5", "rockStA%", "rockSTa5", "rockSTa%", "rockSTA5", "rockSTA%", "rocKsta5", "rocKsta%", "rocKstA5", "rocKstA%", "rocKsTa5", "rocKsTa%", "rocKsTA5", "rocKsTA%", "rocKSta5", "rocKSta%", "rocKStA5", "rocKStA%", "rocKSTa5", "rocKSTa%", "rocKSTA5", "rocKSTA%", "roCksta5", "roCksta%", "roCkstA5", "roCkstA%", "roCksTa5", "roCksTa%", "roCksTA5", "roCksTA%", "roCkSta5", "roCkSta%", "roCkStA5", "roCkStA%", "roCkSTa5", "roCkSTa%", "roCkSTA5", "roCkSTA%", "roCKsta5", "roCKsta%", "roCKstA5", "roCKstA%", "roCKsTa5", "roCKsTa%", "roCKsTA5", "roCKsTA%", "roCKSta5", "roCKSta%", "roCKStA5", "roCKStA%", "roCKSTa5", "roCKSTa%", "roCKSTA5", "roCKSTA%", "rOcksta5", "rOcksta%", "rOckstA5", "rOckstA%", "rOcksTa5", "rOcksTa%", "rOcksTA5", "rOcksTA%", "rOckSta5", "rOckSta%", "rOckStA5", "rOckStA%", "rOckSTa5", "rOckSTa%", "rOckSTA5", "rOckSTA%", "rOcKsta5", "rOcKsta%", "rOcKstA5", "rOcKstA%", "rOcKsTa5", "rOcKsTa%", "rOcKsTA5", "rOcKsTA%", "rOcKSta5", "rOcKSta%", "rOcKStA5", "rOcKStA%", "rOcKSTa5", "rOcKSTa%", "rOcKSTA5", "rOcKSTA%", "rOCksta5", "rOCksta%", "rOCkstA5", "rOCkstA%", "rOCksTa5", "rOCksTa%", "rOCksTA5", "rOCksTA%", "rOCkSta5", "rOCkSta%", "rOCkStA5", "rOCkStA%", "rOCkSTa5", "rOCkSTa%", "rOCkSTA5", "rOCkSTA%", "rOCKsta5", "rOCKsta%", "rOCKstA5", "rOCKstA%", "rOCKsTa5", "rOCKsTa%", "rOCKsTA5", "rOCKsTA%", "rOCKSta5", "rOCKSta%", "rOCKStA5", "rOCKStA%", "rOCKSTa5", "rOCKSTa%", "rOCKSTA5", "rOCKSTA%", "Rocksta5", "Rocksta%", "RockstA5", "RockstA%", "RocksTa5", "RocksTa%", "RocksTA5", "RocksTA%", "RockSta5", "RockSta%", "RockStA5", "RockStA%", "RockSTa5", "RockSTa%", "RockSTA5", "RockSTA%", "RocKsta5", "RocKsta%", "RocKstA5", "RocKstA%", "RocKsTa5", "RocKsTa%", "RocKsTA5", "RocKsTA%", "RocKSta5", "RocKSta%", "RocKStA5", "RocKStA%", "RocKSTa5", "RocKSTa%", "RocKSTA5", "RocKSTA%", "RoCksta5", "RoCksta%", "RoCkstA5", "RoCkstA%", "RoCksTa5", "RoCksTa%", "RoCksTA5", "RoCksTA%", "RoCkSta5", "RoCkSta%", "RoCkStA5", "RoCkStA%", "RoCkSTa5", "RoCkSTa%", "RoCkSTA5", "RoCkSTA%", "RoCKsta5", "RoCKsta%", "RoCKstA5", "RoCKstA%", "RoCKsTa5", "RoCKsTa%", "RoCKsTA5", "RoCKsTA%", "RoCKSta5", "RoCKSta%", "RoCKStA5", "RoCKStA%", "RoCKSTa5", "RoCKSTa%", "RoCKSTA5", "RoCKSTA%", "ROcksta5", "ROcksta%", "ROckstA5", "ROckstA%", "ROcksTa5", "ROcksTa%", "ROcksTA5", "ROcksTA%", "ROckSta5", "ROckSta%", "ROckStA5", "ROckStA%", "ROckSTa5", "ROckSTa%", "ROckSTA5", "ROckSTA%", "ROcKsta5", "ROcKsta%", "ROcKstA5", "ROcKstA%", "ROcKsTa5", "ROcKsTa%", "ROcKsTA5", "ROcKsTA%", "ROcKSta5", "ROcKSta%", "ROcKStA5", "ROcKStA%", "ROcKSTa5", "ROcKSTa%", "ROcKSTA5", "ROcKSTA%", "ROCksta5", "ROCksta%", "ROCkstA5", "ROCkstA%", "ROCksTa5", "ROCksTa%", "ROCksTA5", "ROCksTA%", "ROCkSta5", "ROCkSta%", "ROCkStA5", "ROCkStA%", "ROCkSTa5", "ROCkSTa%", "ROCkSTA5", "ROCkSTA%", "ROCKsta5", "ROCKsta%", "ROCKstA5", "ROCKstA%", "ROCKsTa5", "ROCKsTa%", "ROCKsTA5", "ROCKsTA%", "ROCKSta5", "ROCKSta%", "ROCKStA5", "ROCKStA%", "ROCKSTa5", "ROCKSTa%", "ROCKSTA5", "ROCKSTA%" ]

for passwd in passwd_array:

    print(f'password={passwd} ; 7z x -p$password archive8.7z ')

Simple enough, I saved the bash script with the name brute_forcing.sh


#! /bin/bash
# Brute-forcing by vms

password=rocksta5 ; 7z x -p$password archive8.7z 
password=rocksta% ; 7z x -p$password archive8.7z 
password=rockstA5 ; 7z x -p$password archive8.7z 
password=rockstA% ; 7z x -p$password archive8.7z 
password=rocksTa5 ; 7z x -p$password archive8.7z 
password=rocksTa% ; 7z x -p$password archive8.7z 
password=rocksTA5 ; 7z x -p$password archive8.7z 
password=rocksTA% ; 7z x -p$password archive8.7z 
password=rockSta5 ; 7z x -p$password archive8.7z 
password=rockSta% ; 7z x -p$password archive8.7z 
password=rockStA5 ; 7z x -p$password archive8.7z 
password=rockStA% ; 7z x -p$password archive8.7z 
password=rockSTa5 ; 7z x -p$password archive8.7z 
password=rockSTa% ; 7z x -p$password archive8.7z 
password=rockSTA5 ; 7z x -p$password archive8.7z 
password=rockSTA% ; 7z x -p$password archive8.7z 
password=rocKsta5 ; 7z x -p$password archive8.7z 
password=rocKsta% ; 7z x -p$password archive8.7z 
password=rocKstA5 ; 7z x -p$password archive8.7z 
password=rocKstA% ; 7z x -p$password archive8.7z 
password=rocKsTa5 ; 7z x -p$password archive8.7z 
password=rocKsTa% ; 7z x -p$password archive8.7z 
password=rocKsTA5 ; 7z x -p$password archive8.7z 
password=rocKsTA% ; 7z x -p$password archive8.7z 
password=rocKSta5 ; 7z x -p$password archive8.7z 
password=rocKSta% ; 7z x -p$password archive8.7z 
password=rocKStA5 ; 7z x -p$password archive8.7z 
password=rocKStA% ; 7z x -p$password archive8.7z 
password=rocKSTa5 ; 7z x -p$password archive8.7z 
password=rocKSTa% ; 7z x -p$password archive8.7z 
password=rocKSTA5 ; 7z x -p$password archive8.7z 
password=rocKSTA% ; 7z x -p$password archive8.7z 
password=roCksta5 ; 7z x -p$password archive8.7z 
password=roCksta% ; 7z x -p$password archive8.7z 
password=roCkstA5 ; 7z x -p$password archive8.7z 
password=roCkstA% ; 7z x -p$password archive8.7z 
password=roCksTa5 ; 7z x -p$password archive8.7z 
password=roCksTa% ; 7z x -p$password archive8.7z 
password=roCksTA5 ; 7z x -p$password archive8.7z 
password=roCksTA% ; 7z x -p$password archive8.7z 
password=roCkSta5 ; 7z x -p$password archive8.7z 
password=roCkSta% ; 7z x -p$password archive8.7z 
password=roCkStA5 ; 7z x -p$password archive8.7z 
password=roCkStA% ; 7z x -p$password archive8.7z 
password=roCkSTa5 ; 7z x -p$password archive8.7z 
password=roCkSTa% ; 7z x -p$password archive8.7z 
password=roCkSTA5 ; 7z x -p$password archive8.7z 
password=roCkSTA% ; 7z x -p$password archive8.7z 
password=roCKsta5 ; 7z x -p$password archive8.7z 
password=roCKsta% ; 7z x -p$password archive8.7z 
password=roCKstA5 ; 7z x -p$password archive8.7z 
password=roCKstA% ; 7z x -p$password archive8.7z 
password=roCKsTa5 ; 7z x -p$password archive8.7z 
password=roCKsTa% ; 7z x -p$password archive8.7z 
password=roCKsTA5 ; 7z x -p$password archive8.7z 
password=roCKsTA% ; 7z x -p$password archive8.7z 
password=roCKSta5 ; 7z x -p$password archive8.7z 
password=roCKSta% ; 7z x -p$password archive8.7z 
password=roCKStA5 ; 7z x -p$password archive8.7z 
password=roCKStA% ; 7z x -p$password archive8.7z 
password=roCKSTa5 ; 7z x -p$password archive8.7z 
password=roCKSTa% ; 7z x -p$password archive8.7z 
password=roCKSTA5 ; 7z x -p$password archive8.7z 
password=roCKSTA% ; 7z x -p$password archive8.7z 
password=rOcksta5 ; 7z x -p$password archive8.7z 
password=rOcksta% ; 7z x -p$password archive8.7z 
password=rOckstA5 ; 7z x -p$password archive8.7z 
password=rOckstA% ; 7z x -p$password archive8.7z 
password=rOcksTa5 ; 7z x -p$password archive8.7z 
password=rOcksTa% ; 7z x -p$password archive8.7z 
password=rOcksTA5 ; 7z x -p$password archive8.7z 
password=rOcksTA% ; 7z x -p$password archive8.7z 
password=rOckSta5 ; 7z x -p$password archive8.7z 
password=rOckSta% ; 7z x -p$password archive8.7z 
password=rOckStA5 ; 7z x -p$password archive8.7z 
password=rOckStA% ; 7z x -p$password archive8.7z 
password=rOckSTa5 ; 7z x -p$password archive8.7z 
password=rOckSTa% ; 7z x -p$password archive8.7z 
password=rOckSTA5 ; 7z x -p$password archive8.7z 
password=rOckSTA% ; 7z x -p$password archive8.7z 
password=rOcKsta5 ; 7z x -p$password archive8.7z 
password=rOcKsta% ; 7z x -p$password archive8.7z 
password=rOcKstA5 ; 7z x -p$password archive8.7z 
password=rOcKstA% ; 7z x -p$password archive8.7z 
password=rOcKsTa5 ; 7z x -p$password archive8.7z 
password=rOcKsTa% ; 7z x -p$password archive8.7z 
password=rOcKsTA5 ; 7z x -p$password archive8.7z 
password=rOcKsTA% ; 7z x -p$password archive8.7z 
password=rOcKSta5 ; 7z x -p$password archive8.7z 
password=rOcKSta% ; 7z x -p$password archive8.7z 
password=rOcKStA5 ; 7z x -p$password archive8.7z 
password=rOcKStA% ; 7z x -p$password archive8.7z 
password=rOcKSTa5 ; 7z x -p$password archive8.7z 
password=rOcKSTa% ; 7z x -p$password archive8.7z 
password=rOcKSTA5 ; 7z x -p$password archive8.7z 
password=rOcKSTA% ; 7z x -p$password archive8.7z 
password=rOCksta5 ; 7z x -p$password archive8.7z 
password=rOCksta% ; 7z x -p$password archive8.7z 
password=rOCkstA5 ; 7z x -p$password archive8.7z 
password=rOCkstA% ; 7z x -p$password archive8.7z 
password=rOCksTa5 ; 7z x -p$password archive8.7z 
password=rOCksTa% ; 7z x -p$password archive8.7z 
password=rOCksTA5 ; 7z x -p$password archive8.7z 
password=rOCksTA% ; 7z x -p$password archive8.7z 
password=rOCkSta5 ; 7z x -p$password archive8.7z 
password=rOCkSta% ; 7z x -p$password archive8.7z 
password=rOCkStA5 ; 7z x -p$password archive8.7z 
password=rOCkStA% ; 7z x -p$password archive8.7z 
password=rOCkSTa5 ; 7z x -p$password archive8.7z 
password=rOCkSTa% ; 7z x -p$password archive8.7z 
password=rOCkSTA5 ; 7z x -p$password archive8.7z 
password=rOCkSTA% ; 7z x -p$password archive8.7z 
password=rOCKsta5 ; 7z x -p$password archive8.7z 
password=rOCKsta% ; 7z x -p$password archive8.7z 
password=rOCKstA5 ; 7z x -p$password archive8.7z 
password=rOCKstA% ; 7z x -p$password archive8.7z 
password=rOCKsTa5 ; 7z x -p$password archive8.7z 
password=rOCKsTa% ; 7z x -p$password archive8.7z 
password=rOCKsTA5 ; 7z x -p$password archive8.7z 
password=rOCKsTA% ; 7z x -p$password archive8.7z 
password=rOCKSta5 ; 7z x -p$password archive8.7z 
password=rOCKSta% ; 7z x -p$password archive8.7z 
password=rOCKStA5 ; 7z x -p$password archive8.7z 
password=rOCKStA% ; 7z x -p$password archive8.7z 
password=rOCKSTa5 ; 7z x -p$password archive8.7z 
password=rOCKSTa% ; 7z x -p$password archive8.7z 
password=rOCKSTA5 ; 7z x -p$password archive8.7z 
password=rOCKSTA% ; 7z x -p$password archive8.7z 
password=Rocksta5 ; 7z x -p$password archive8.7z 
password=Rocksta% ; 7z x -p$password archive8.7z 
password=RockstA5 ; 7z x -p$password archive8.7z 
password=RockstA% ; 7z x -p$password archive8.7z 
password=RocksTa5 ; 7z x -p$password archive8.7z 
password=RocksTa% ; 7z x -p$password archive8.7z 
password=RocksTA5 ; 7z x -p$password archive8.7z 
password=RocksTA% ; 7z x -p$password archive8.7z 
password=RockSta5 ; 7z x -p$password archive8.7z 
password=RockSta% ; 7z x -p$password archive8.7z 
password=RockStA5 ; 7z x -p$password archive8.7z 
password=RockStA% ; 7z x -p$password archive8.7z 
password=RockSTa5 ; 7z x -p$password archive8.7z 
password=RockSTa% ; 7z x -p$password archive8.7z 
password=RockSTA5 ; 7z x -p$password archive8.7z 
password=RockSTA% ; 7z x -p$password archive8.7z 
password=RocKsta5 ; 7z x -p$password archive8.7z 
password=RocKsta% ; 7z x -p$password archive8.7z 
password=RocKstA5 ; 7z x -p$password archive8.7z 
password=RocKstA% ; 7z x -p$password archive8.7z 
password=RocKsTa5 ; 7z x -p$password archive8.7z 
password=RocKsTa% ; 7z x -p$password archive8.7z 
password=RocKsTA5 ; 7z x -p$password archive8.7z 
password=RocKsTA% ; 7z x -p$password archive8.7z 
password=RocKSta5 ; 7z x -p$password archive8.7z 
password=RocKSta% ; 7z x -p$password archive8.7z 
password=RocKStA5 ; 7z x -p$password archive8.7z 
password=RocKStA% ; 7z x -p$password archive8.7z 
password=RocKSTa5 ; 7z x -p$password archive8.7z 
password=RocKSTa% ; 7z x -p$password archive8.7z 
password=RocKSTA5 ; 7z x -p$password archive8.7z 
password=RocKSTA% ; 7z x -p$password archive8.7z 
password=RoCksta5 ; 7z x -p$password archive8.7z 
password=RoCksta% ; 7z x -p$password archive8.7z 
password=RoCkstA5 ; 7z x -p$password archive8.7z 
password=RoCkstA% ; 7z x -p$password archive8.7z 
password=RoCksTa5 ; 7z x -p$password archive8.7z 
password=RoCksTa% ; 7z x -p$password archive8.7z 
password=RoCksTA5 ; 7z x -p$password archive8.7z 
password=RoCksTA% ; 7z x -p$password archive8.7z 
password=RoCkSta5 ; 7z x -p$password archive8.7z 
password=RoCkSta% ; 7z x -p$password archive8.7z 
password=RoCkStA5 ; 7z x -p$password archive8.7z 
password=RoCkStA% ; 7z x -p$password archive8.7z 
password=RoCkSTa5 ; 7z x -p$password archive8.7z 
password=RoCkSTa% ; 7z x -p$password archive8.7z 
password=RoCkSTA5 ; 7z x -p$password archive8.7z 
password=RoCkSTA% ; 7z x -p$password archive8.7z 
password=RoCKsta5 ; 7z x -p$password archive8.7z 
password=RoCKsta% ; 7z x -p$password archive8.7z 
password=RoCKstA5 ; 7z x -p$password archive8.7z 
password=RoCKstA% ; 7z x -p$password archive8.7z 
password=RoCKsTa5 ; 7z x -p$password archive8.7z 
password=RoCKsTa% ; 7z x -p$password archive8.7z 
password=RoCKsTA5 ; 7z x -p$password archive8.7z 
password=RoCKsTA% ; 7z x -p$password archive8.7z 
password=RoCKSta5 ; 7z x -p$password archive8.7z 
password=RoCKSta% ; 7z x -p$password archive8.7z 
password=RoCKStA5 ; 7z x -p$password archive8.7z 
password=RoCKStA% ; 7z x -p$password archive8.7z 
password=RoCKSTa5 ; 7z x -p$password archive8.7z 
password=RoCKSTa% ; 7z x -p$password archive8.7z 
password=RoCKSTA5 ; 7z x -p$password archive8.7z 
password=RoCKSTA% ; 7z x -p$password archive8.7z 
password=ROcksta5 ; 7z x -p$password archive8.7z 
password=ROcksta% ; 7z x -p$password archive8.7z 
password=ROckstA5 ; 7z x -p$password archive8.7z 
password=ROckstA% ; 7z x -p$password archive8.7z 
password=ROcksTa5 ; 7z x -p$password archive8.7z 
password=ROcksTa% ; 7z x -p$password archive8.7z 
password=ROcksTA5 ; 7z x -p$password archive8.7z 
password=ROcksTA% ; 7z x -p$password archive8.7z 
password=ROckSta5 ; 7z x -p$password archive8.7z 
password=ROckSta% ; 7z x -p$password archive8.7z 
password=ROckStA5 ; 7z x -p$password archive8.7z 
password=ROckStA% ; 7z x -p$password archive8.7z 
password=ROckSTa5 ; 7z x -p$password archive8.7z 
password=ROckSTa% ; 7z x -p$password archive8.7z 
password=ROckSTA5 ; 7z x -p$password archive8.7z 
password=ROckSTA% ; 7z x -p$password archive8.7z 
password=ROcKsta5 ; 7z x -p$password archive8.7z 
password=ROcKsta% ; 7z x -p$password archive8.7z 
password=ROcKstA5 ; 7z x -p$password archive8.7z 
password=ROcKstA% ; 7z x -p$password archive8.7z 
password=ROcKsTa5 ; 7z x -p$password archive8.7z 
password=ROcKsTa% ; 7z x -p$password archive8.7z 
password=ROcKsTA5 ; 7z x -p$password archive8.7z 
password=ROcKsTA% ; 7z x -p$password archive8.7z 
password=ROcKSta5 ; 7z x -p$password archive8.7z 
password=ROcKSta% ; 7z x -p$password archive8.7z 
password=ROcKStA5 ; 7z x -p$password archive8.7z 
password=ROcKStA% ; 7z x -p$password archive8.7z 
password=ROcKSTa5 ; 7z x -p$password archive8.7z 
password=ROcKSTa% ; 7z x -p$password archive8.7z 
password=ROcKSTA5 ; 7z x -p$password archive8.7z 
password=ROcKSTA% ; 7z x -p$password archive8.7z 
password=ROCksta5 ; 7z x -p$password archive8.7z 
password=ROCksta% ; 7z x -p$password archive8.7z 
password=ROCkstA5 ; 7z x -p$password archive8.7z 
password=ROCkstA% ; 7z x -p$password archive8.7z 
password=ROCksTa5 ; 7z x -p$password archive8.7z 
password=ROCksTa% ; 7z x -p$password archive8.7z 
password=ROCksTA5 ; 7z x -p$password archive8.7z 
password=ROCksTA% ; 7z x -p$password archive8.7z 
password=ROCkSta5 ; 7z x -p$password archive8.7z 
password=ROCkSta% ; 7z x -p$password archive8.7z 
password=ROCkStA5 ; 7z x -p$password archive8.7z 
password=ROCkStA% ; 7z x -p$password archive8.7z 
password=ROCkSTa5 ; 7z x -p$password archive8.7z 
password=ROCkSTa% ; 7z x -p$password archive8.7z 
password=ROCkSTA5 ; 7z x -p$password archive8.7z 
password=ROCkSTA% ; 7z x -p$password archive8.7z 
password=ROCKsta5 ; 7z x -p$password archive8.7z 
password=ROCKsta% ; 7z x -p$password archive8.7z 
password=ROCKstA5 ; 7z x -p$password archive8.7z 
password=ROCKstA% ; 7z x -p$password archive8.7z 
password=ROCKsTa5 ; 7z x -p$password archive8.7z 
password=ROCKsTa% ; 7z x -p$password archive8.7z 
password=ROCKsTA5 ; 7z x -p$password archive8.7z 
password=ROCKsTA% ; 7z x -p$password archive8.7z 
password=ROCKSta5 ; 7z x -p$password archive8.7z 
password=ROCKSta% ; 7z x -p$password archive8.7z 
password=ROCKStA5 ; 7z x -p$password archive8.7z 
password=ROCKStA% ; 7z x -p$password archive8.7z 
password=ROCKSTa5 ; 7z x -p$password archive8.7z 
password=ROCKSTa% ; 7z x -p$password archive8.7z 
password=ROCKSTA5 ; 7z x -p$password archive8.7z 
password=ROCKSTA% ; 7z x -p$password archive8.7z

Then I edited the file permissions to make it executable.

chmod +x brute_forcing.sh && ./brute_forcing.sh

It ran for a few seconds, ran all the 256 key combinations, and came to a grinding halt.

Still, the file is not open.

A bug in the code?

To test, I made a 7z container. I then added some files to the archive and took a password from the middle of the brute_forcing.sh to encrypt it.

I ran the script again.

Voila! It works. It only took two seconds.

Now, I have to expand my wordlist with keys where my fingers would have accidentally hit. For example, I could have pressed the z button instead of 'a'. It is directly beneath the 'a' key on a qwerty keyboard.

Still, there is also a chance that this might not work.

But I have not lost hope.

I shall get a machine running John or Hashcat. Again, my wordlist shall be much smaller since this is a binary choice problem.

Also, I was thinking about passwords in general. Given access to systems, hackers can easily break a lot of weak passwords in minutes, if not seconds. This is a case in point for using long complex passwords where it matters the most - at least on the login prompt.

How does the call stack work?

Vinod Mathew Sebastian — Wed, 20 Apr 2022 17:51:56 +0000

In JavaScript, or any language, whenever a function is called it is pushed onto the call stack, and whenever a function returns it is popped off the call stack.

We hear this term a lot – call stack – especially in certain contexts like recursive programming among others.

This call stack goes all the way down to computer architecture.

To understand what the call stack is, we have to understand how computer memory (RAM) is internally represented and organized.

The operating system uses some of the total memory (RAM) a computer has. But still, the vast majority is available for other programs to use.

This available memory is classified into two. The stack and the heap.

Let's write a simple declaration in JavaScript: var num = 10;

When we run this code, the memory for the variable num is allocated in the heap.

Another simple script:

function square(num){
return num*num;
}

Since this is a function, memory is allocated on the stack.

All right. For global variables, memory is allocated in the heap. For functions, and function variables, it is on the stack.

In languages like C, we can explicitly ask the compiler to allocate memory for us in runtime. C programmers can specify this memory to be in the heap or the stack.

The heap grows from a lower memory address to a higher memory address (upward), and the stack goes from a higher memory address to a lower memory address (downward).

The stack is also a data structure. Imagine a stack of books. If we put another book onto the stack, it will the first to come out of it (LIFO).

Heap is also another data structure. But, heap memory has nothing to do with the heap data structure. It usually implies a ‘heap’ of memory the programs, and low-level programmers, can use.

Coming back to the call stack, see this recursive JavaScript function to find the factorial of natural numbers:

function factorial(num) {

    if (num == 0)return 1;
    else return num * factorial(num - 1);

}
factorial(10)

When this function is first called, since the ‘base condition’ is not met, the return function is also pushed onto the stack.

So memory is allocated somewhere on top of the available memory (higher memory address).

It recursively runs for the second time, again the ‘base condition’ is not met.

Again, the return function is pushed onto the top of the stack.

This happens again and again until num is decremented down to zero (the 'base condition' here).

Afterward, a return value is generated and the functions pop one after another off the stack.

Each time a function gets pushed onto the stack, it is allocated a contiguous chunk of memory on the stack called the stack frame.

Although it is pushed ‘onto’ the stack, since the stack grows from top to the bottom, the newer stack frames will have lower memory addresses.

The heap grows toward the top and the stack grows toward the bottom.

Some compilers can decide to allocate a function’s memory in the heap. But stack-grows-toward-the-bottom and heap-grows-toward-the-top are easy to explain, understand, and widely accepted.

So looking at recursive functions, we find out that, technically, there is a limit.

Though rare in everyday usage, we may get the maximum stack frames exceeded error even with the correct code (which happens all the time when we write bad recursive functions).

Since JavaScript is made with ‘C’, and every JavaScript code is ultimately compiled down to machine code, I wrote the above recursive function in C.

#include <stdio.h>

int factorial(int num){

if(num == 0) return 1;
else return num*(factorial(num-1));

}

int main(int argc, char** argv){

int result = factorial(10);
printf("%d\n", result);
return 0;

}

I then compiled this with gcc, and used gdb to disassemble it. This is x86 assembly code in AT&T syntax.

(gdb) disassemble/m

Dump of assembler code for function factorial:
3       int factorial(int num){
=> 0x0000555555555149 <+0>:     endbr64 
   0x000055555555514d <+4>:     push   %rbp
   0x000055555555514e <+5>:     mov    %rsp,%rbp
   0x0000555555555151 <+8>:     sub    $0x10,%rsp
   0x0000555555555155 <+12>:    mov    %edi,-0x4(%rbp)
4
--Type <RET> for more, q to quit, c to continue without paging—c

5       if(num == 0) return 1;
   0x0000555555555158 <+15>:    cmpl   $0x0,-0x4(%rbp)
   0x000055555555515c <+19>:    jne    0x555555555165 <factorial+28>
   0x000055555555515e <+21>:    mov    $0x1,%eax
   0x0000555555555163 <+26>:    jmp    0x555555555176 <factorial+45>
6       else return num*(factorial(num-1));
   0x0000555555555165 <+28>:    mov    -0x4(%rbp),%eax
   0x0000555555555168 <+31>:    sub    $0x1,%eax
   0x000055555555516b <+34>:    mov    %eax,%edi
   0x000055555555516d <+36>:    callq  0x555555555149 <factorial>
   0x0000555555555172 <+41>:    imul   -0x4(%rbp),%eax
7
8       }
   0x0000555555555176 <+45>:    leaveq 
   0x0000555555555177 <+46>:    retq   

End of assembler dump.

See the start of the function: 0x000055555555514d <+4>: push %rbp The first hex number is the memory address, the number in angular brackets is the offset from the start, and then the actual instructions. The rbp is the base pointer (bp for base pointer).

At the start of the function, the base pointer is pushed, and saved, onto the stack, and by 0x000055555555514e <+5>: mov %rsp,%rbp it is then made to point to the current function’s stack frame. The rsp is the stack pointer (sp for stack pointer).

After the function returns, the base pointer is popped off the stack, and then it points toward the previous stack frame: 0x0000555555555176 <+45>: leaveq

Speaking in assembly language, whenever rbp and rsp are the same, it means that the current stack frame (it can be the only one on the stack) is empty.

Happy coding!

How to install Emmet with Vim in Termux

Vinod Mathew Sebastian — Sat, 12 Sep 2020 13:39:11 +0000

Termux is a terminal emulator and Linux environment app for Android devices which can convert your phone, or tablet, into a rather powerful web development machine.

Termux can be used for many other purposes, including data processing and hacking. You can read more about Termux on the official website.

Vim is the much-loved text editor for Linux machines. If you do not know Vim read this tutorial.

Emmet is a text-editor-plugin which greatly improves the HTML/CSS workflow. You can find the docs here.

In this tutorial, I'll show you how you can install Emmet along with Vim in Termux.

Firstly, you need to install Termux from the Google Play store.

After installation, open Termux and type:

$ apt update && apt upgrade

Then install Vim.

$ apt install vim

After Vim is installed, create a folder in the current home directory by typing

$ mkdir .vim

Navigate to that directory.

$ cd .vim

Create another folder called 'plugged' here.

$ mkdir plugged

Cd back into the home directory.

$ cd ..

There are several ways to install the 'emmet-matt' plugin. In this tutorial, I'm going to use a Vim plugin manager called vim-plug. We need to install that by typing

$ curl -fLo ~/.vim/autoload/plug.vim --create-dirs https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

After the vim-plug installation, make a .vimrc file.

$ vim .vimrc

Vim will open a new file for editing.

Press 'i' on the keyboard to toggle input mode in Vim.

Type

call plug#begin('~/.vim/plugged')
Plug 'mattn/emmet-vim'
call plug#end()

and press 'Esc'.

Then type :wq to save changes.

For installing the emmet-vim plugin, we need to install git. This is a crucial step. Without git, the plugin installation will fail and Vim will show an error.

Type

$ pkg install git

After the git installation, Type $ vim to open Vim and type

:PlugInstall

If everything goes well, we'll now have the Emmet plugin installed.

Emmet manual says to type html:5 and use the key combination Ctrl+y+, (the comma is important). But on my phone, I just typed !and the key combination; and Voila! I got the starter HTML boilerplate.


<!DOCTYPE HTML>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title></title>
</head>
<body>

</body>
</html>

Enjoy coding!

Vinod Mathew Sebastian is a Full Stack Developer

What is Abstraction in Computer Programming?

Vinod Mathew Sebastian — Tue, 10 Dec 2019 19:28:10 +0000

Modern computers work on layers of abstraction.

So what is abstraction?

Cambridge dictionary says,

the situation in which a subject is very general and not based on real situations.
an idea that develops by looking at or thinking about a number of different things

Hmm. Not very helpful.

So, in this article, I will try to explain it my way.

Computers are pretty dumb machines by themselves.

Since a CPU contains billions of transistors baked into thin wafers of silicon (so small that almost only one electron passes through each transistor), and every transistor is an electrically controlled switch (that is what transistors are: electrically controlled switches) we can implement logic gates with them.

Logic gates are as physics as computer science and I save that for another article.

The key take is that when current passes through one of these gates it is a ‘1’ and where there is no input (to these logic gates) it is a ‘0’.

So we can give instructions to these logic gates by a series of ‘0’s and ‘1’s.
That is it.

On the basic level, they pretty much natively understand a series of ‘0’s and ‘1’s.

Every CPU comes with an instruction set. It is the manual by which we input ‘0’s and ‘1’s to achieve a particular effect.

This is called machine language.

The problem with machine language is that nobody can pretty much write anything useful with it.

01001101000111100010110010011010001111000101101 ....

Game?

That is why scientists thought of a way where we could write these instructions with simpler syntax and still computers be able to understand it.

Enter the world of abstraction.

The first layer of abstraction is the assembly language for that particular CPU.

It is a human-readable form of machine language.

In Assembly, the English alphabets enter the scene.

Each alphabet and character is converted to machine language by a compiler (program) written in the machine language itself.

In assembly language, each instruction is converted only to one instruction in the machine language.

It is pretty inefficient.

So came the next level of abstraction: lower-level languages like C.

In C, every line of instruction is converted to many lines of machine code (language).

A special program called the ‘C’ compiler will convert the instructions written in C to machine code.

C is useful because it takes comparatively less memory.

Memory is another concept, just remember that all these lines and lines of code have to be held up somewhere before (and after) executing. That place is called memory (RAM).

In the past couple of decades, there has been an exponential increase generally in the memory of a computer.

RAM is in GBs now.

So we could afford the luxury to write something like this in a higher-level language.

#Python
print(“Hello World”)

Here, even though it is only one line of code, the Python interpreter (in lieu of compiler) converts this into lines and lines of machine code so that “Hello World” is displayed on the screen.

This is a pretty high level of abstraction.

I will further explain this concept by writing a simple program in JavaScript.
In JavaScript, there is a method (function) called trim().

What trim() does is that it clears the space before and after a string.

So, “ Hello World “.trim() becomes “Hello World”.

Whenever we need to trim a string, we simply need to call this function.

I try this at a lower level in abstraction and implement this myself in JavaScript.

This function customTrim(str) is same as the .trim() method is JavaScript.

See the output:

What is easier?

“ Some thing ”.trim() or the function I have written above?

Abstraction saves us by allowing us to use fewer lines of code.

I hope you have started to understand the concept. Understanding abstraction is pretty much essential in understanding computer science.

Vinod Mathew Sebastian is a Full Stack Developer