DEV Community: Jonny

Command-line

Jonny — Sat, 18 Feb 2023 02:52:14 +0000

Note: This blog will only cover the command line that comes with Mac and Linux aka Bash. Windows users can also download Bash. The tutorial can be found here

Introduction

The Command Line is a text interface for the computer's operating system. It is used to manipulate the computer's file system. It is used to create, edit, delete, and more. On Mac and Linux, we access the command line through something called Bash. Windows on the other hand come with a different built-in command line.

Usage

From the Command Line, we can navigate through files and folders, just as we would with Finder for Mac or File explorer for Windows. The only difference is that the Command line is fully text-based.

The advantage of using the command line is that it can run programs, write scripts to automate common tasks, and combine simple commands to handle difficult tasks. All of these traits come together to make it an important programming tool.

Structure

When using the command line, folders as referred to as directories. Files and directories on our computer are organized into a filesystem. A filesystem organizes a computer's files and directories into a tree structure:

The first directory in the filesystem is the root directory. It is the parent of all other directories and files in the filesystem.
Each parent directory can contain more child directories and files.
Each directory can contain more files and child directories. The parent-child relationship continues as long as directories and files are nested.

Macs Finder and Windows File Explorer represent the file system as trees as well.

Commands

In the terminal, the first thing we see is the $ sign. This is called a shell prompt. It appears when the terminal is ready to accept a command.

There are several commands used in Bash(command line). Some of them are:

pwd
ls
cd
mkdir
touch
cat
cp
mv
rm & many more

ls

A command is a directive to the computer to perform a specific task. When we type ls, the command line looks at the directory we are in, and "lists" all the files and directories inside of it. Make sure to type l as n "List" and not the number 1.

pwd

pwd stands for "print working directory". It outputs the name of the directory we are currently in, called the working directory. As an example, if we are in the users downloads directory, typing pwd will out the current directory, which is downloads. Together with ls, the pwd command is useful to show where we are in the filesystem.

cd

cd stands for "change directory". Just as we would click on a folder in Finder or Windows File explorer, cd switches us into the directory we specify. cd changes the working directory.

when a directory or a file is passed into a command, it is called an argument. in this case, Users would be the argument, because that is what's being passed to the cd.

we can also use double dot (..) after cd to move up one directory.

mkdir

When creating folders/directories, we use mkdir command. The mkdir command stands for "make directory". It takes in a directory name as an argument and then creates a new directory in the current working directory.

touch

The touch command created a new file inside the working directory. It takes in a filename as an argument and then creates an empty file with that name in the current working directory.

cat

The cat command outputs the contents of a specified file.

This is a useful command for peeking at files without opening them and confirming the result of other commands that change the contents of files. We can also get output using paths to a specified file. To output the contents of blogs.txt within the home directory, we can run:

This will output the contents of blogs.txt within the Desktop directory.

cp

The cp command copies files or directories. Below, we copy blogs.txt into the blogs directory. We can see it has been successfully copied when we ls into the blogs directory.

We can also use cp to copy multiple files into a directory. We can use cp with a list of source fields as the first argument, and the destination directory as the last argument. Below, we copied the files blog.txt and blogs2.txt into the blogs directory.

mv

The mv command is very similar to cp in its usage. The main difference is that mv moves a file without making a copy. We can use mv with the source file as the first argument and the destination directory as the second argument. Below, we moved blogs.txt into the blogs directory.

mv can also be used to rename a file or directory.

rm

The rm command deletes files and directories. Keep in mind when using rm. It deletes files and directories permanently. There is not an undelete command. Once we delete a file or directory with rm, it's forever gone.

The -r (recursive) option is used to delete a directory and all its child directories followed by the directory name. When we delete a file, however, we can just use rm followed by the file name.

This illustrates how to delete a file.

This illustrates how to delete a directory with files in it.

These are a few of the many commands used in the command line. All the commands can be found here.

Other Helper Commands

There are some helper commands that are helpful in the command line.

tab can be used to autocomplete our command. However, the file or directory should exist in the first place.
The up and down arrows can be used to cycle through previous commands. The up arrow will take us through the most recent commands, and the down arrow will take us back through the recent one.
clear is used to clear the terminal. This can come in handy when the terminal is full of previous commands and outputs. It really doesn't change or undo our previous commands. It just clears it from the view.

Conclusion

The command line is an essential tool for developing projects. We can use the command line to manage all of our project files. We can move, delete, and reorganize our projects. We can have many things running at once in our command line environment. As you become a more and more advanced developer, you will find it necessary to configure the command line environment to your convenience.

Thank you!
Jonny

Big O Notation

Jonny — Sat, 11 Feb 2023 04:04:54 +0000

As a software engineer, you likely have encountered the term Big O Notation, but do you really understand what it means?

What is Big O Notation

Big O Notation is a mathematical notation used to describe the performance or complexity of an algorithm. It is used to express the upper bound on the growth rate of the running time of an algorithm as the size of the input data grows. In other words, it provides us with a way to quantify how well an algorithm scales with increasing data size.

To put it simply, Big O Notation gives us a way to compare the efficiency of algorithms and determine which is the most efficient for a particular problem. This is important because choosing the right algorithm can have a big impact on the performance of your program, especially for large data sets.

The speed and memory usage of an algorithm isn't fixed. It might change depending on the input. So How do we express the performance of an algorithm? Would we say that if the size of the input is small, the algorithm runs in less than 30 milliseconds, however, if the size of the input is large, the algorithm would run in 100 million seconds? This wouldn't really make sense. it's meaningless.

Big O Notation is used to describe the time complexity and the space complexity of an algorithm.

Complexity Analysis: is the process of measuring or determining how efficient an algorithm is. Complexity analysis involves finding the time complexity and space complexity of an algorithm.

Time complexity: is a measure of how fast an algorithm runs. it's expressed using Big O notation.

Space complexity: is a measure of how much additional/extra memory of an algorithm takes up. It's expressed using Big O notation.

Common Big O Notations

There are several common Big O Notations, including:

O(1), also known as constant time, means that the running time of an algorithm remains constant regardless of the size of the input data.

O(log n), also known as logarithmic time, means that the running time grows logarithmically with the size of the input data.

O(n), also known as linear time, means that the running time grows linearly with the size of the input data.

O(n log n), means that the running time grows as the product of the size of the input data and the logarithm of the size of the input data.

O(n^2), also known as quadratic time, means that the running time grows as the square of the size of the input data.

When designing an algorithm, the goal is to choose the one with the lowest possible time complexity. For example, consider two algorithms A and B. Algorithm A has a time complexity of O(n), while algorithm B has a time complexity of O(n^2). This means that as the size of the input data grows, the running time of algorithm A grows linearly, while the running time of algorithm B grows as the square of the size of the input data. In this scenario, algorithm A is considered more efficient than algorithm B for large data sets.

Conclusion

In conclusion, Big O Notation is a valuable tool for software engineers as it provides a way to quantify the performance of algorithms and make informed decisions about which algorithm to use for a particular problem. By understanding the basics of Big O Notation, you can design efficient algorithms that scale well with increasing data size.

Thank you!
Jonny

ChatGPT API: A blog written by ChatGPT

Jonny — Wed, 01 Feb 2023 02:52:17 +0000

ChatGPT API by OpenAI is a cutting-edge technology that is transforming the world of natural language processing (NLP). With its advanced language generation and contextual understanding capabilities, ChatGPT API is helping businesses and individuals automate and improve their content creation processes. In this blog, we'll guide you through the steps of using the ChatGPT API to its fullest potential.

Step 1: Sign up for an API key

To use the ChatGPT API, you first need to sign up for an API key from OpenAI. This will give you access to the API and allow you to start making requests. The sign-up process is simple and straightforward, and OpenAI provides excellent documentation to help you get started.

Step 2: Familiarize yourself with the API

Once you have an API key, it's important to familiarize yourself with the API and understand how it works. OpenAI provides extensive documentation on the API, including sample requests and responses, so take advantage of this resource to learn as much as you can.

Step 3: Test the API

Now that you have a basic understanding of the API, it's time to start testing it. Use the API to generate text, translate language, or create custom language models tailored to your specific needs. Start with simple queries and gradually build up to more complex tasks as you become more familiar with the API.

Step 4: Integrate the API into your workflow

Once you have tested the API and are confident in its capabilities, it's time to integrate it into your workflow. This may involve incorporating it into an existing application or creating a new one from scratch. Whatever the case, make sure to take advantage of the API's advanced language generation and contextual understanding capabilities to maximize its impact.

Step 5: Monitor and evaluate performance

It's important to monitor and evaluate the performance of the ChatGPT API to ensure that it's delivering the results you want. Use metrics such as accuracy, response time, and user satisfaction to measure its effectiveness, and make adjustments as necessary.

In conclusion, ChatGPT API by OpenAI is a powerful tool for businesses and individuals looking to automate and improve their content creation processes. With its advanced language generation and contextual understanding capabilities, the API is a valuable tool for maximizing the impact of NLP. So why wait? Get started today and unleash the power of ChatGPT API!

Thank you!
Jonny

Sorting Algorithms

Jonny — Thu, 26 Jan 2023 16:31:40 +0000

Sorting Algorithm

is an algorithm used for rearranging a given array or list in a specific manner according to a comparison operators on the elements. The comparison operator is used to decide the new order of elements in the perspective data structure.

Some of the most well-known sorting algorithms are:

Bubble Sort
Selection Sort
Insertion Sort
Merge Sort
Quick Sort
Heap Sort

Bubble Sort

is one of the simplest sorting algorithms. Bubble sort works by repeatdly swapping the adjacent elements if they are in the wrong order. This algorithm is not advised for a large data sets, because of it's high time complexity.

Selection Sort

Considering we're sorting a list/array in ascending order, selection sort sorts a list by repeatdly finding the minimum element from the unsorted part and shifting it to the beginning of the array.

Insertion Sort

Just like Bubble Sort, insertion sort is one the simplest sorting algorithms. The array of list is split into two parts. Sorted and unsorted part. The values from the unsorted are separated picked and placed at the correct position in the sorted part.

Merge Sort

A sorting algorithm that works by dividing an array into smaller subarrays. The subarrays are then sorted, and then merging the sorted subarrays back together to form the final sorted array. This process is repeated until the entire array/list is sorted. One of the main advantages of merge sort is the time complexity of O(n log n), which means it can sort large set of arrays relatively quickly and efficient.

Quick Sort

Like merge sort, quick sort picks picks an element as a pivot and partitions the given array around the picked pivot. It partitions an array and calls itself recursively twice to solve the two resulting subarrays. Quick Sort is highly efficient for large sets of data with a time complexity of O(n2).

Heap Sort

Similar to selection sort where we find the minimum element and place the minimum element at the beginning. This process is repeated until the entire array/list is sorted. Heap Sort is not very efficient sorting algorithm when working with highly complex data. It is also unstable, and might rearrange the relative order.

Conclusion

Sorting Algorithm is a set of instructions that take an array or list as an input and arrange an item into a particular order. The sorts mostly in numerical or alphabetical order, and can be in ascending or descending order.

Thank you!
Jonny

Linked Lists

Jonny — Wed, 14 Dec 2022 05:59:17 +0000

Question:
What is the data structure whose singular purpose in life is to be reversed.
Answer:
Linked list

What is a Linked List

A linked list is one of the fundamental data structure. It's a linear data structure for storing a collection of items. A linked list is very similar to an array. The main difference is how a linked list is implemented or stored in memory.

Unlike arrays, linked lists are not stored in contiguous or back-to-back memory slots. They are stored/linked using pointers.

A pointer is a data type used for storing a memory address. It enables us to store the memory address of another memory address/slot.

This is what a basic linked list looks like:

Breakdown

When creating a linked list, we create a structure called a node. A linked list includes a series of connected nodes. Each node has a data/value and a pointer to the next node in the linked list.

Linked Lists in Memory

Linked lists are not stored in contiguous memory slots. They are stored using pointers. Here is how they're actually stored. In memory, we would have two back-to-back memory slots for each node, where one memory slot holds the data/value, and the second memory slot holds the pointer. The next node in the linked list we're pointing could be anywhere in the memory. Let's look at an example:

1 -> 2 -> 3 -> 4

The first data/value in our linked list is called the head. Our first data/value in our linked list is the number 1. That value is stored in memory address 18, and the pointer is stored next to it in memory address 19, because each node has the value and the pointer, and they need to be in a back-to-back memory slot. Memory address 19 points to the value of number 2 at memory address 9. The pointer is stored next to it in memory address 10. Memory address 10 points to the value of the number 3 at memory address 3. The pointer is stored next to it in memory address 4. Memory address 4 points to the value of the number 4 at memory address 7. The pointer is stored next to it in memory address 8. Memory address 8 points to null, which basically points to nothing. The last node (value & pointer) in our linked list is known as the tail.

An important thing to note is that, if any two back-to-back memory slots are occupied, our program will never replace/delete that data. Our program will try to find other available memory slot/address that are free to store in our data.

Why Linked Lists?

As mentioned, a linked list is very similar to an array. Both have their own pros and cons. Arrays are easy and quick to access. On the other hand linked lists require iteration of the entire data structure to access data. Insertion of a new element or deletion of an element in an array would shift every element in the array, which is not efficient. However, in linked list, it can be done by redirecting the next pointer of the previous node to point to the new node instead of the current one and the next pointer of the new node must point to the original next node.

Types of Linked Lists

Singly Linked List: The most basic and simple type of linked list, where each node points to the next node in the linked list. The first node is knows as the head, whereas the last node is called the tail.

Example:
1 -> 2 -> 3 -> 4 -> 5 -> null

Doubly Linked List: Similar to singly linked list, however each node has a pointer to the previous node in the linked list. The previous node is usually referred to as prev

Example:
null <-> 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> null

Circular Linked List: A type of linked list that has no plain head or tail, because the pointers form a closing circle. A circular linked list can be either a singly or doubly linked list.

Example 1:
1 -> 2 -> 3 -> 4 -> 5 -> 1 -> 2 -> 3 -> 4 -> 5 -> 1 ...
Example 2:
1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 1 <-> 2 <-> 3 <-> 4 <-> 5 ...

Conclusion

A linked list is a linear data structure. Each element is represented as a node, which contains the value and a pointer to the next node. Linked list is not stored at a contiguous memory address. The nodes are linked and stored using pointers. There are three main types of linked lists: singly, doubly, and circular linked list.

Thank you!
Jonny

Memory

Jonny — Sat, 03 Dec 2022 04:47:21 +0000

Memory is a broad topic. There are a lot of computer science courses, videos, and lessons that are relevant to memory. For the sake of time, This blog will cover memory in the context of technical/coding interviews.

Introduction

The very basic thing we can do in programming is declare variables. We declare variables to store in some kind of data and use them later in our program. That variable has to be stored somewhere in the computer to be referenced later on in our code. This is where memory comes into play.

What is Memory?

This is a basic representation of memory. It's divided into a lot of little memory slots. These memory slots are identified by a unique number known as memory addresses.

There are a finite number of memory slots, meaning it is bounded. If every memory slot is occupied, we wouldn't have any available memory slots to store data. Let's look at an example:

const num = 73;

Here we have a variable with the value of the number 73. Our program will store the value of the variable in a memory slot. Any memory slot that is NOT OCCUPIED.

Easy right? let's dive deeper.

Bit, Byte, Fixed-width integer

Turns out, when we store data in a memory slot, we don't store them by their value, because computers only understand 0s and 1s. When we store data, we actually store them in the form of bits.

A bit is the smallest unit of data that a computer comprehends. A bit is always represented by a 0 or 1. So for our previously declared variable, we store the data in the form of bits instead of the value 73.

A group of 8 bits is called a byte. As an example: 01001010. This is considered a byte, because it has 8 bits of 0s and 1s. If we have more than 8 bits, as an example, in the case of 16 bits, we would divide 16 by 8 to convert it to the number of bytes, which would give us 2 bytes. In the case of 32 bits, we would divide 32 by 8 bits, which would give us 4 bytes.

A single memory slot can only hold eight bits or one byte, if we have more than one byte, our program needs to store the data in back-to-back or contiguous free memory slots.

Different data types are represented by a different number of bits. If you come from C++ or Java background, you might know that int data type is represented as a 32-bit integer, and a long data type is represented as a 64-bit integer. These are known as Fixed-width integer, which are integral data types with a fixed number of bits. Anything that is more than 8 bits or 1 byte will take up more memory slots. For example, our previously declared variable has a value of 73, which is an integer. We know that an integer is represented as a 32-bit integer. 32 / 8 will give us 4 bytes. This means that our program will need a total of 4 free memory slots to store the data since one memory slot can only hold 1 byte.

This is the 32-bit representation of of our previously declared variable 73.

00000000 00000000 00000000 01001001

This is what it looks like when stored in our memory.

One important thing to note is that when we are dealing with integers, the number of memory slots we're going to be using is always constant. The number of memory slots will not increase or decrease if our number increases or decreases. if we declare a 32-bits integer, it will always take 4 memory slots, and if we declare a 64-bits integer, it will always take 8 memory slots.

It also works the same way if we have an array/list. Our program takes contiguous memory slots to store the data.

How are strings stored in memory?

Well, we can actually convert or map a character into an integer. This method is known as ASCII character mapping. ASCII is basically a table that assigns a bunch of characters to a number. As an example, the letter 'A' is represented as 65 in the ASCII code. This means that declaring a variable and assigning it a value of 65 and declaring another variable and assigning it a value of the letter 'A' are the same in terms of bits.

Nowadays, Unicode is mostly used to store text data. Unicode is similar to ASCII, however, Unicode represents far more characters than ASCII. It supports a larger range of characters, which takes up a lot more space than ASCII. Unicode encodes emojis as well.

Advanced

So far, we've only stored data types like integers and strings in our memory slots/addresses. However, that is not the end line. We can actually store the memory addresses of another memory address/slot. As an example, we can store the memory address 18 at the memory slot 2. This is referred to as a pointer. A pointer from one memory slot/address to another memory slot.

Conclusion

Memory is the place where information is stored for immediate use. Memory is one of the basic functions of a computer, because without it, a computer would not be able to function properly.

Thank you!
Jonny

Data Structures and Algorithms - Part II

Jonny — Tue, 22 Nov 2022 18:03:47 +0000

if
you haven't already, i highly suggest that you check out part one, where i talked about data structures. Link for part one: https://dev.to/jonnynotbravo/data-structures-and-algorithms-4ni8

else
Enjoy!

What is an Algorithm?

In simple terms, an algorithm is a set of instructions or steps for completing a task. Our daily life consists of algorithms. Morning and night routines, a recipe, and even the steps we do to tie our shoes are algorithms.

Algorithms in Programming

So what does tying a shoe has anything to do with programming? To tie our shoes, we must follow a set of steps. Likewise, to write a program, we have to write an algorithm. Generally speaking, almost any code that has zero or more defined input is executed with an algorithm. The process is as follows:

An algorithm should have zero or more well-defined inputs. It should also have zero or more well-defined outputs. After the program runs, the algorithm must terminate. Let's look at an example:

function add(num1, num2) {

   const sum = num1 + num2;

   return sum;
}

Here we have a function that takes two numbers as parameters and finds the sum of the two numbers. Here are some things to notice:

num1 & num2 - the input values
a "sum" variable that does the addition operation - the algorithm
the return value - the output

The Importance of Algorithms

The primary purpose of algorithms is to perform a task or solve a problem. Different people develop different algorithms for these problems, and some people will have better algorithms than others. So what makes an algorithm a "better" algorithm? Let's look at how these two codes below use two different algorithms to add two numbers.

Code A


///Declare an empty array variable
const array = []

function add(num1, num2) {

  ///Push the sum of the two numbers into the array
  array.push(num1 + num2)
  //Convert the array to a string
  const arrayToString = array.join()
  //Convert the string to a number
  const stringToNumber = Number(arrayToString)

  //output
  return stringToNumber;

}

Code B

function add(num1, num2) {

  return num1 + num2;

}

It's evident that code A uses a complex algorithm to find the sum of the two numbers. It adds the numbers and pushes them into an array. Next, that array is converted to a string. Next, that string is converted to a number, and then we finally get the result. This algorithm works, and it's guaranteed that we get the correct answer. However, it is less efficient.

In programming, efficiency is the number of computational resources used by an algorithm. In simple terms, it's the number of steps the program takes to execute. The more steps and more complex the algorithm, the less efficient the algorithm is.

On the other hand, Code B looks very easy to understand, and it takes the least amount of code to execute in terms of code complexity, time, and memory.

List of Algorithms

There are many algorithms in computer programming that help to develop great programs and thus will improve efficiency and quality. Here are some of the most familiar ones and the ones that are used almost on a daily basis.

Searching Algorithms

Linear Search
Binary Search

Sorting Algorithms

Quick Sort
Heap Sort
Merge Sort
Buble Sort
Selection Sort
Radix Sort

Graph Algorithm

Dijkstra's Algorithm
Breadth-first search
Depth-first search
A* algorithm

Conclusion

Algorithms and algorithmic thinking, or the ability to define clear steps to solve a problem, are crucial in many different fields. Even if we’re not conscious of it, we use algorithms and algorithmic thinking all the time. Algorithmic thinking allows us to break down problems and conceptualize solutions in terms of discrete steps. Being able to understand and implement an algorithm require us to practice structured thinking and reasoning abilities.

Thank you!

Jonny

Data Structures and Algorithms - Part I

Jonny — Sat, 12 Nov 2022 05:19:58 +0000

What is a Data Structure

In simple terms, a data structure is a way of organizing and storing data. It's a collection of data types. It's a way of accessing and organizing items in terms of memories.

Types of Data Structures

There are mainly two types of data structures:

Primitive data structure: is a kind of data structure derived from the programming language. They are predefined and atomic in nature. They can only hold a single type and value in a specific memory location. e.g. integer, character, boolean, float, double, long, pointer, etc.
Non-primitive data structure: is a kind of data structure that are created using the primitive data structures, meaning they are user defined. They can hold multiple values in a chained or random memory locations. e.g. arrays, stacks, queues, linked lists, trees, graphs, etc.

Classifications of Non-primitive data structures

Linear data structures
Non-linear data structures

1. Linear Data Structure

Is a type of data structure where the arrangement of all the elements of the data are in sequential order. Each element of the data is arranged linearly such that its attached to the previous and next elements. e.g. arrays, linked lists, queues, and stacks.

Static data structure: data structures with a fixed memory size. The size of the data needs to be known in advance, meaning the user cannot change the size of the data after the program runs. However, the value or the data itself can be changed. One of the advantages of static data structure is having fast access to the data. Since static data structures are contiguous, there is no need to worry about the memory location of the data. It can easily be found using indexes. The disadvantages of static data structure would be having a slower insertion and deletion process.
Dynamic data structure: data structures with dynamic or flexible size. The memory is allocated at run time, therefore the size of the data does not need to be know in advance. The advantages would be having faster insertion and deletion process. The disadvantage would be slower access to the data.

2. Non-linear Data Structure

Is a type of data structure where the arrangement of all the elements of the data are not in sequential order. e.g. trees, graphs.

Conclusion

Data Structure is the process of manipulating data. It's a way of organizing and storing data. There are many data structures. However, using appropriate data structures is always needed to save time while storing, retrieving or processing data.

Now we know what data structures are, let's move on to algorithms (Click here)

Thank you!

Jonny