DEV Community: Kwerenachi Utosu

Object Oriented Programming Summarised

Kwerenachi Utosu — Sat, 12 Oct 2024 13:14:30 +0000

Object oriented programming often written as OOP is a concept that every software engineer should understand. Being an engineer for a few years now, I can say that having an in-depth knowledge of OOP would set you up for success.

What is Object Oriented Programming?

Object Oriented Programming can be defined as a programming paradigm that to mimics or models entities. In OOP, we tend to reference real world entity behaviours and interactions, through the operations we perform on objects.

Why bother learning about OOP?

You may be asking yourself, why bother learning this? But the truth is, OOP have become a major anchor in modern software development. If you plan to build scalable applications, with reusable components that allows for ease of collaboration, you'd have to build on the core concepts and principles of OOP.

Since we're keeping it short, I'd go straight into the basic terminologies or core concepts of object oriented programming. And then after that, I'd discuss the principles or feature of OOP.

Core Concepts of OOP

There are 4 most commonly used terminologies or concepts of OOP.

Class: A Class is a template or blueprint that define the behaviour, structure and properties of objects. It contains the data attributes and functions or methods that operate on that data.
Object: An Object is an instance of a specified class. It contains real values instead of variables. It also represent real-world interpretation of a Class and can perform operations defined by that class.
Method: A method is function. It can be defined within a class or implemented from an interface. Methods defines the behaviour of objects and can be used to perform operations and data manipulation on objects.
Property: Properties are the data members or variables of a class. They are also knowns as fields and store the feature or data associated with an object.

Principles of OOP

There are 4 major principles of OOP and I'd briefly explain each of them below. Since we're doing an OOP summary, I'm going to try to make it as simple and short as possible.

Encapsulation
Encapsulation just like the English definition involves enforcing controls or hiding of data implementation of a class by restricting access to class methods. This principle helps to ensure that only the public methods and properties are available to the public.

For Example, you don't need to understand the inner mechanical workings of a car to drive the car, or the hardware build process of a phone to use the phone to satisfy your need.

Abstraction
Abstraction can also be explained in plain terms as reducing the complexity of an object or class by putting all the complex details in a different place, usually an abstract class or interface.

This pattern enables high level thinking, and handling complex edge cases on a surface level. In most cases, abstract classes or interfaces would define some contract or rules that connecting classes must obey.

Inheritance
I love how these principles are self explanatory like their names 😀. Inheritance like the name implies involves passing knowledge or information down within classes. When class A inherits from class B, this simply means that, class A gets the attributes and methods with in class B for free.

For Example, A class Shape which is the superclass has attribute name and method getArea(). If another class Circle which is the subclass inherits from Shape, it automatically get a the attribute and method within shape.

Polymorphism
Polymorphism is the ability of an objects to take different forms. There's the static polymorphism and dynamic polymorphism. Polymorphism is closely related to Inheritance, so I'm going to use the example above to explain it better.

If we had another class, say Triangle that inherits from Shape, this new class also gets the name attribute and getArea() function. While in the Circle class getArea() would but implemented as πr2 where r is is the radius of the circle. In the triangle it would implemented as 1/2*b*h where b and h are the base and height of the triangle. The implementation could also introduce a new formula depending on the type of triangle.

The ability to change the behaviour of methods or attributes in the different objects is called Polymorphic.

Conclusion
I hope this piece was helpful to you. There's still a lot to learn in OOP, but this is a summarised introduction.

Regular Expressions As Applied In Programming

Kwerenachi Utosu — Tue, 30 Mar 2021 12:42:33 +0000

Regular Expressions as also know as Regex, work on the principle of providing characters that must be matched. Regular Expression is usually used especially when trying to work on a large number of data.

Working on that much data, we're not expected to make updates or alter the data one after the other because it would take up too much of our time, so we use Regex to group them together and make our update.

What is a Regular Expression?

A regular expression is a sequence of characters that specifies a search pattern. Regular expressions are also known as patterns used to match character combinations in strings. Usually, such patterns are used by string-searching algorithms for find or find and replace operations on strings, or for input validation.

For Example, a simple Expression like [a-zA-Z] would match all the alphabets. Every word containing simple plain alphabets without any tone marks would fall into that category, words like code, table, Markdown, and many more.

Some Major Uses Of Regex In Programming
Regular Expressions as stated earlier are very useful to programmers for a variety of tasks.

For implementing find and replace function that identifies group or sequence of characters and replaces them with something else as specified by the expression.
For search operations, for example, being able to identify a single string in a whole document.
For Input Validation, for example, passwords, email addresses, and other input types that may require a special character.

Metacharacters In Regular Expressions

Before we dive into writing some Regex and explaining the various patterns, we must first understand the metacharacters involved in creating this expression.

A metacharacter is a character that has a special meaning to a computer program, such as a shell interpreter or a regular expression (regex) engine.

       [  ]  -  +  *  ?  ^  $  (  )  {  }  |  .  \

Each of these metacharacters above has a completely different meaning when interpreted in a Regex enabled environment.

Square Bracket [ ]
This is used to group like data together and create a range. For example [0-9] simple means every digit from 0 to 9.

Hyphen -
This simple represents to,i.e a range or an interval.

Plus Sign +
This matches One or more of the preceding character or group of characters.

For example, a simple expression like /ab+c/ simply means that words gotten from this expression must start with an a, have one or as many bs as possible, and must always end with a c. Some accepted outputs are abc, abbc, abbbc, and many more.

Asterisk *
This matches Zero or more of the preceding character or group of characters.

For example, a simple expression like /ab*c/ simply means that words gotten from this expression must start with an a, have zero or as many bs as possible, and must always end with a c. Some accepted outputs are ac, abbc, abbbc, and many more.

Question Mark ?
This matches Zero or one of the preceding character or group of characters.

For example, a simple expression like /ab?c/ simply means that words gotten from this expression must start with an a, have zero or one b, and must always end with a c. There are only 2 accepted outputs ac and abc.

Caret ^
The caret serves two different purposes. It is a special character that denotes “the beginning of a line” and it is a “not” operator inside of []s.
Take a look at these three examples,

/([^aeiou])/
/^([aeiou])/
/^([^aeiou])/

The first example simply matches any character that is not a vowel.
The second one matches a vowel at the start of a line.
And the third one matches any character that is not a vowel, at the start of a line.

Dollar Sign $
This matches the end of a line. For example, /$([aeiou])/ matches a vowel at the end of the line.

Parentheses ()
Parentheses in a regular expression usually indicate a ‘capture group’, or a subset of the string to be stored for later reference.

For an example like /^([aeiou])([0-9])/
This example matches a string starting with a single vowel (the first capture group is a single vowel), followed by any single digit (the second capture group is any digit).

Curly Braces {}
This matches a specific range. It is used when you want to be very specific about the number of occurrences an operator or subexpression must match in the source string. Curly braces and their contents are known as interval expressions. For example {n} matches preceding element or subexpression must occur exactly n times.

Pipe Symbol |
Two regular expressions separated by a pipe symbol match either an occurrence of the first or an occurrence of the second.

For example, a simple expression like /(a|b)*c/ simply means that words gotten from this expression must start with either an a, a b or none, and must always end with a c. Some accepted outputs are c, ac, bc, and many more.

Dot .
The dot operator matches any character. It has so many dynamic uses.

For example, the expression /^([0-9])(.)/ simply matches a string that starts with a digit, followed by any character.

*Backlash \*
A Backlash is used to escape metacharacters. The term "to escape a metacharacter" means to make the metacharacter ineffective (to strip it of its special meaning), causing it to have its literal meaning.

For example, a dot (".") stands for any single character as a metacharacter. So when we have an expression like ab., it matches an a, a b followed by any character. But when it's escaped like ab\. it simply means ab.

Regular Expressions In Methods And Classes

Now let's apply all we've learned in the examples below

Example 1
The expression in this first example matches two different words in the string given as str in the code snippet below. The program would return an affirmative alert.

var regex = /li[kv]e/;
var str = "They like the live show.";

// Test the string against the regular expression
if(regex.test(str)) {
    alert("Match found!");
} else {
    alert("Match not found.");
}

Output

Match found!

Example 2
In this next example, a g was added to record every word occurrence of the sequence in the string given below.

var regex = /[rt]?each/g;
var str = "To teach means to reach as many kids, each also reaching others";
var matches = str.match(regex);

if(regex.exec(str)) {
    alert(matches.length + " Matches found!");
} else {
    alert("Match not found.");
}

The output for this example is teach, reach, each, and reach following the explanation given previously, which means they are 4 in number. You can try running this code snippet for confirmation.
Output

4 Matches found!

Character Classes

A character class is the most basic regex concept after a literal match. It makes one small sequence of characters match a larger set of characters. For example, [A-Z] basically be given as \u, and \d could mean any digit.

See some character classes below:

\d represents digits. It is also written as [0-9].
\D represents Non-digits. It is also written as [^0-9].
\w represents alphanumeric characters and the underscore. It is also written as [A-Za-z0-9_].
\W represents non-word characters. It is also written as [^A-Za-z0-9_].
\s represents whitespace characters. It is also written as [ \t\r\n\v\f].
\S represents non-whitespace characters. It is also written as [^ \t\r\n\v\f].
\a represents alphabetic characters. It is also written as [A-Za-z].
\l represents lowercase characters. It is also written as [a-z].
\u represents uppercase characters. It is also written as [A-Z].
\x represents Hexadecimal digits. It is also written as [A-Fa-f0-9].
\b simply represents boundaries.
\g simply represents global search. Meaning it'll match all occurrences.

Note that, these character classes might differ in some programming languages or test environments.

Character Classes In Programming

We'd look at a few more examples that involve Character classes and other literals.

Example 3
The expression below splits the strings into an array of strings. According to the Regex, the split criteria is any white space. I console logged so that you can see the list of strings.

var regex = /[\s,]+/;
var str = "My house is painted white, purple and blue";
var parts = str.split(regex);

// Loop through parts array and display substrings
for(var part of parts){
    console.log(part)
    document.write("<p>" + part + "</p>");
}

Example 4
In this next example, we replace all the digits in the str variable with hyphens.

var regex = /\d/g;
var replacement = "-";
var str = "There 3 kids, 4 adults and 98 animals";

// Replace digits with -
var matches = str.replace(regex, replacement);
console.log(matches)

Example 5
For the fifth example, we also did a replace but replaced all lowercase vowels with an asterisk.

var re = /[aeiou]/g;
var replace = "*";
var str2 = "Every one of them knows the answer to No 2";

// Replace lowercase vowels with *
var matches2 = str2.replace(re, replace);
console.log(matches2)

You can also retest the given code snippets above and try out new expressions in your free time. As usual, the more you practise, the higher your chances of becoming an expert.

Conclusion

Regular Expressions can be applied to every aspect of computer programming and data management. It can be used to perform SQL or database operations. With Regex there's always a lot of scenarios to try out. I hope this article has been very helpful to you. It doesn't stop here though, practice, practice and more practice.

Multi-threading and Parallel Programming

Kwerenachi Utosu — Fri, 05 Feb 2021 07:34:20 +0000

Multi-threading is a widespread programming and execution model that allows multiple threads to exist within the context of one process. Each of these threads can run in parallel and these thread share similar address space. Okay let's start from the very beginning.

What is a Thread?

A thread of execution is the smallest sequence of programmed instructions that can be managed independently by a scheduler, which is typically a part of the operating system. Most times a thread exist within the process and multiple threads can exist within a single process, hence multi-threading.

I'd say a Computer Scientist would see A Thread the same way a Chemist would see an An Atom .

These threads run concurrently and they share resources. The implementation of threads and processes differ between operating systems, but in most cases a thread is a component of a process.

What is a Process?

Processes are instances of programs which typically run independent from each other. For Example, if you start a Java program the operating system spawns a new process which runs in parallel to other programs. Inside those processes we can utilize threads to execute code concurrently, so we can make the most out of the available cores of the CPU.

Unlike Threads, processes do not share resource with one another. A process is a unit of resources, while a thread is a unit of scheduling and execution.

Thread Pool

Creating a brand-new OS thread requires memory allocation and CPU instructions in order to set it up and also kill it down. In order to better handle the usage of a thread and also avoid the creation of new ones, the operating systems or platforms reckon with a Thread Pool feature, which allows the application to take an already existing thread to use.

That’s a much more efficient way to handle multiple threads without dealing with its creation or destruction. Furthermore, the OSs know when a thread from the thread pool is not actively in use thus, they can automatically “skip” it during the threads’ iteration.

Descriptive Programming Representations Of Threads

We'd take a look at threads as implemented from two classes in Java, Executors and Runnable.

Executors Executors as a class in Java that abstracts most of the manual thread creation process. They are capable of running asynchronous tasks and typically manage a pool of threads, so we don't have to create new threads manually.

The class Executors provides convenient factory methods for creating different kinds of executor services. In the sample below we use an executor with a thread pool of size one.

The result looks similar to the above sample but when running the code you'll notice an important difference, the java process never stops! Executors have to be stopped explicitly - otherwise they keep listening for new tasks.

An ExecutorService provides two methods for that purpose: shutdown() waits for currently running tasks to finish while shutdownNow() interrupts all running tasks and shut the executor down immediately. This service is mostly used when working with socket connections, to facilitate asynchronous calls(Sink-Source connections).

Runnable A Runnable is functional interface defining a single void no-arguments method run(). Before starting a new thread you have to specify the code to be executed by this thread, often called the task and this is done by implementing a Runnable. Note that, you can have as many tasks as possible.

For the example above, we utilize Java 8 lambda expressions to print the current threads name to the console. First we execute the runnable directly on the main thread before starting a new thread. See the sample outputs below.



Hello main
Hello Thread-0
Done!

Or that:



Hello main
Done!
Hello Thread-0

We have two possible outputs because due to concurrent execution we cannot predict if the runnable will be invoked before or after printing Done. The order is non-deterministic, thus making concurrent programming a complex task in larger applications. Although Threads can also be put to sleep for a certain duration.

Multi-threading in-depth

Like we've clearly stated earlier, A multi-threaded program contains two or more parts that can run concurrently and each part can handle a different task at the same time making optimal use of the available resources specially when your computer has multiple CPUs.

Multi-threading extends the idea of multitasking into applications where you can subdivide specific operations within a single application into individual threads. It enables you to write in a way where multiple activities can proceed concurrently in the same program.

There are a handful of programming languages that give room for multi-threading, and most of the languages are Object Oriented Programming languages(OOP). Languages like Java, C,C++ and even .NET frameworks. Some other interpreted languages also made the cut, like Ruby MRI for Ruby and CPython for Python. If you were waiting to see Javascript, well you won't because JavaScript does not support multi-threading and that's because the JavaScript interpreter in the browser is a single thread.

Heavily Multi-threaded Applications

Almost all well-built applications support multi-threading. Let's look at browsers. Most browsers are multi-threaded from firefox to Safari to Chrome and many others. But today we'd talk more about Chrome.

Google Chrome
Chrome has a multi-process architecture and each process is heavily multi-threaded. The main goal is to keep the main thread (“UI” thread in the browser process) and IO thread (each process’ thread for handling IPC) responsive. This means offloading any blocking I/O or other expensive operations to other threads.

In Chrome, each and every tab you open gets its own content process. Five tabs, 5 processes, one hundred tabs, 100 processes. This approach maximizes performance, but you pay a hefty penalty in memory consumption and battery life. Ever wondered why the CPU consumption for Chrome on your task manager is always high? Well, here you go.

Every chrome process has,

A main thread This thread updates the UI and runs most of Blink.
An IO thread This thread handles IPCs and network requests
A few more special-purpose threads.
A pool of general-purpose threads.

Chrome Compared to Firefox
While Chrome creates a content process for each tab, Firefox instead spins up to four content process threads by default. In Firefox, the first 4 tabs each use those 4 processes and additional tabs then use threads within those processes. Multiple tabs within a process share the browser engine that already exists in memory, instead of each creating their own.

// Detect dark theme var iframe = document.getElementById('tweet-1357400668835823617-793'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1357400668835823617&theme=dark" }

Threads Vs Processes

Threads are different from the conventional multitasking process in so many ways:

Processes are typically independent, while threads exist as subsets of a process.
Processes carry considerably more state information than threads, whereas multiple threads within a process share process state as well as memory and other resources.
Processes have separate address spaces, whereas threads share their address space.
Processes interact only through system-provided inter-process communication mechanisms.
Context switching between threads in the same process typically occurs faster than context switching between processes.

Parallelism

Parallelism relate to the concept were the work is distributed in multiple units, in such a way that it doesn't compromise the final product but minimizing the total execution time.

Parallel execution is the ability of two (or more) tasks to run at the very same time. While Concurrency stands for the possibility, Parallelism is the reality.

Conclusion

Multithreading is now an important part of modern software development. It’s supported by many programming languages and platforms and goes all the way down to the operating system. Knowing how to work with multiple threads can definitely lead developers to build better applications.

Lambda Expressions In Simple Terms

Kwerenachi Utosu — Wed, 27 Jan 2021 12:51:57 +0000

A lambda expression is a short block of code which takes in parameters and returns a value. The sample expression below has one parameter. The expression can also contain two or more parameters.

parameter -> expression

A lambda expression can also be seen as an anonymous function. A function that doesn’t have a name and doesn’t belong to any class. Lambda expressions are similar to methods, but they do not need a name and they can be implemented right in the body of a method.

(parameter1, parameter2) -> expression

The concept of lambda expression was first introduced in LISP programming language. Expressions are limited. They have to immediately return a value, and they cannot contain variables, assignments or statements such as if or for. In order to do more complex operations, a code block can be used with curly braces.

(parameter_list) -> {function_body}

If the lambda expression needs to return a value, then the code block should have a return statement.

Components Of Lambda Expression

Lambda Expressions usually contain these 3 components:

Argument-list: This argument is usually a list. It can be empty or non-empty as well.
Arrow-token: It is used to link arguments-list and body of expression.
Body: It contains expressions and statements for lambda expression. The body can be a simple statement or can contain a block of code.

Some Sample Implementations and Outputs

For the first example, We'd start with a list of numbers. We are going to do a couple of mathematical computations on the content of this list.

// A Java program to demonstrate simple lambda expressions 
import java.util.ArrayList;

public class Main {
  public static void main(String[] args) {
    // Creating an ArrayList with elements  
    // And add elements{7,4,2} to the list
    ArrayList<Integer> numbers = new ArrayList<Integer>();
    numbers.add(7);
    numbers.add(4);
    numbers.add(2);

    //Using Lambda to print out all elements
    numbers.forEach( n -> System.out.println(n));

    //Using Lambda to print out the double value of each element
    numbers.forEach( n -> System.out.println(n+n));

    //Using Lambda to print all even elements
    numbers.forEach( n -> {if (n%2 == 0) System.out.println(n);});
  }
}

In the Java class above we have three different Lambda Expressions.

The first expression iterates through a list and prints out each value on a new line.
The second one print out the value of each element plus itself.
The third one prints out only the even numbers.

Output 1

7
4
2

Output 2

14
8
4

Output 3

4
2

Lambda Expression in Functional Interfaces.

For these next examples, We'd work with Functional Interfaces.
A functional interface in Java is an interface that contains only a single abstract (unimplemented) method. A functional interface can also contain default and static methods which do have an implementation.

Functional Interfaces with No Parameter

interface MyFunctionalInterface {

    //A method with no parameter
    public String sayHello();
}
public class ExampleOne {

   public static void main(String args[]) {
        // lambda expression
        MyFunctionalInterface message = () -> {
            return "Hello";
        };
        System.out.println(message.sayHello());
    }
}

Output

Hello

Functional Interfaces with One Parameter

interface MyFunctionalInterface {

    //A method with one parameter
    public String sayHelloName(String str);
}
public class ExampleTwo {

   public static void main(String args[]) {
        // lambda expression
        MyFunctionalInterface message = (str) -> {
            return "Hello " + str;
        };
        System.out.println(message.sayHelloName("Joy"));
    }
}

Output

Hello Joy

Functional Interfaces with multiple Parameters

interface MyFunctionalInterface {

    //A method with one parameter
    public String concatStrings(String str1, String str2);
}
public class ExampleThree {

   public static void main(String args[]) {
        // lambda expression
        MyFunctionalInterface message = (str1, str2) -> {
            return str1 + str2;
        };
        System.out.println(message.concatStrings("Good ","Day"));
    }
}

Output

Good Day

Lambda Expression in Hash Maps.

Lambda Expression can also be used in Hash Maps, to iterate or do computational alterations on the elements of a Map. Let's see this example below.

public class HashMapExample{
  public static void main(String[] args) {
    // Creating a HashMap and putting in elements
    Map<String, Integer> prices = new HashMap<>();
    prices.put("Apple", 50);
    prices.put("Orange", 20);
    prices.put("Banana", 10);
    prices.put("Grapes", 40);

    //Using Lambda to print out all elements, k=key,v=value
    prices.forEach((k,v)->System.out.println("Fruit: " + k + ", 
    Price: " + v));
  }
}

Output

Fruit: Apple, Price: 50
Fruit: Orange, Price: 20
Fruit: Banana, Price: 10
Fruit: Grapes, Price: 40

Lambda Expression For Running Threads

You can use lambda expression to run threads. In the following example, we are implementing run method by using lambda expression.

public class ThreadExample{
  public static void main(String[] args) {
        //Thread Example without lambda  
        Runnable r1=new Runnable(){  
            public void run(){  
                System.out.println("Thread1 is running...");  
            }  
        };  
        Thread t1=new Thread(r1);  
        t1.start();  
        //Thread Example with lambda  
        Runnable r2=()->{  
                System.out.println("Thread2 is running...");  
        };  
        Thread t2=new Thread(r2);  
        t2.start();  
  }
}

Output

Thread1 is running...
Thread2 is running...

Lambda Expression to Compare and Filter Collection list

Lambda Expression can also be used as a comparator and can also be used to filter through a list.

class Product{  
    int id;  
    String name;  
    float price;  
    public Product(int id, String name, float price) {  
        super();  
        this.id = id;  
        this.name = name;  
        this.price = price;  
    }  
}  

public class FilterListExample{
  public static void main(String[] args) {
        List<Product> list=new ArrayList<Product>();  
        list.add(new Product(1,"Volvo",19000f));  
        list.add(new Product(3,"Tesla",75000f));  
        list.add(new Product(2,"Toyota",38000f)); 

        // using lambda to filter data  
        Stream<Product> filtered_data = list.stream().filter(p -> 
        p.price > 3000);  

        // using lambda to iterate through collection  
        filtered_data.forEach(  
                product -> System.out.println(product.name+": 
        "+product.price)   
       );
  }
}

Output

Tesla: 75000.0
Toyota: 38000.0

Some Points to note when using Lambda Expression

The body of a lambda expression can contain zero, one or more statements.
When there is a single statement curly brackets are not mandatory and the return type of the anonymous function is the same as that of the body expression.
When there are more than one statements, then these must be enclosed in curly brackets (a code block) and the return type of the anonymous function is the same as the type of the value returned within the code block, or void if nothing is returned

Why Use Lambda Expressions

Here are some benefits of using Lambda Expressions.

Fewer Lines of Code:
One of the benefits of using lambda expression is the reduced amount of code.
Sequential and Parallel Execution Support by passing behavior in methods:
With the introduction of Stream API in Java 8, functions can be passed to collection methods and now it is the responsibility of collection to process the elements either in a sequential or parallel manner.
Higher Efficiency (Utilizing Multicore CPU’s):
Using Stream API’s and lambda expression we can achieve higher efficiency (parallel execution) in case of bulk operations on collections. Also, the lambda expressions can help in achieving internal iteration of collections rather than external iteration as shown in the above example. As nowadays we have CPUs with multicores, we can take advantage of these multicore CPU’s by parallel processing of collections using lambda.

In Summary, Lambda Expressions are welcome additions to any code base and this article is just meant to show us pointers on how to use and apply them.

Git Intro for Beginners

Kwerenachi Utosu — Tue, 17 Nov 2020 09:45:09 +0000

What is Git?
Git is a free, open source distributed version control system tool designed to handle everything from small to very large projects with speed and efficiency. Git has the functionality, performance, security and flexibility that most teams, individual developers and researchers need. It was created by Linus Torvalds in 2005 to develop Linux Kernel.

What is the purpose of Git?
Git is primarily used to manage your project, comprising a set of code or text files that may change that may change over time.

Git is also used to save your remotely and allow access to multiple individuals for updates.

Here are 15 git commands to master for a start

git init
This command is used to initialize or start a new git repo
see sample below. Navigate into the folder you're initializing if it already exist, or simply create a new one.

git config
The git config command sets the author name and email address respectively to be used with your commits.

git clone
This command is used to obtain or download a repository
from an existing source.

git add
This command is used to add a single file or multiple files to a staging area. Note that, the added file(s) won't be on your remote environment until they're pushed.

Here are some git add commands

git add filename adds a file called "filename" to the staging area
git add . stages new files and modifications, without deletions
git add -A stages all changes
git add -u stages modifications and deletions, without new files

git commit
This command records or snapshots the file permanently in the version history.

Here are some git commit commands

git commit -m "My First Commit" gives you the opportunity to add a commit message.
git commit -a commits any files you’ve added with the git add command and also commits any files you’ve changed since then.

git remote
This command is used to connect your local repository to the remote server.

git status
This command lets you see which changes have been staged, which haven't, and which files aren't being tracked by Git. Status output does not show you any information regarding the committed project history.

git fetch
The command is a primary command used to download contents from a remote repository. This content includes branches and tags.

git checkout
This command is used to switch from one branch to another.

This command can be used to create a new branch. To create a new git checkout -b my-new-branch where "my-new-branch" is the name of the new branch.

git push
This command sends information committed to your remote repository. when using git push you can there are multiple way commits can be pushed to the remote.

git push [remote-variable-name] [branch-name] this command pushes commits staged on a particular branch to a remote origin, example git push origin master we can also have git push heroku my-new-branch.
git push all this command pushes all branches to your remote repository.
git push -force or git push -f this command forcefully send the current staged commit to the remote repository.
git push -u origin master is used for pushing staged content to GitHub. In the code, the origin is your default remote repository name and -u flag is upstream, which is equivalent to -set-upstream and the master is the branch name.

git pull
This command fetches and merges changes on the remote server to your working directory.

git stash
This command temporarily stores all the modified tracked files. this command can also be used to check all new modifications and move them to a new branch.

git stash pop this command restores the most recently stashed files on the current branch.
git stash list this command lists all stashed changes.
git stash drop this command discards the most recently stashed changes.

git merge
This command merges the specified branch’s history into the current branch.

git branch
This command lists all the local branches in the current repository. This command can also be used to create a new branch or delete an existing branch.

git branch new-branch-name this command creates a new branch called "new-branch-name".
git branch -d [branch-name] this command deletes the feature branch.

git log
This command is used to list the version history for the current branch.

You can start by practicing these few git commands, using them constantly also helps to learn them faster. I hope you have a great learning experience.

To get a more in-depth knowledge of git please click here learn git

The K.I.S.S Principle in Programming

Kwerenachi Utosu — Wed, 15 Jul 2020 15:38:50 +0000

KISS is an acronym which means Keep It Simple Stupid. I don't like to use the word Stupid because I know my readers aren't stupid, that’s why I choose to translate it to Keep It Super Simple.🙂

KISS is an important term in programming because it puts in your subconscious that every process you’re creating should be as simple as possible and also equally as efficient.

When we say ‘Simple’, what do we mean?

Simple in this context doesn’t necessarily mean easy, It simply means producing the same results or a better result with less effort or complexity.

In the concept of KISS, we neither want just less nor more, we simply wish to have only as much as is required.

If you’re building a product that moves an object from point A to point B, then do that as efficiently as possible, while having simplicity at the back of your mind.

Keep Simple Tasks Simple!

The KISS principle can also be applied in Artificial Intelligence and Machine Learning. When building a simple Artificial intelligent system, you may not necessarily need to create a machine learning model, if an If Statement can do the job efficiently.

// Detect dark theme var iframe = document.getElementById('tweet-1272561538914750464-823'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1272561538914750464&theme=dark" }

In the programming context, there are a few points to note whenever we want to reduce complexity.

Ensure your variable names describes the variable it holds properly.
Ensure your method names translates to the purpose of that method.
Write comments within your method where necessary.
Ensure your classes has a single responsibility.
Avoid global states and behaviors like as much as you can.
Delete instances, methods or redundant processes within the code base that are not in use.

We should try to reduce complexity, while maintaining an efficient system. The British computer scientist, M. A Jackson actually wrote that,

Programmers often take refuge in an understandable, but disastrous, inclination towards complexity and ingenuity in their work.

Why is the KISS principle important in programming?

One major challenge Developers face is working on an existing code base. But when the KISS principle is applied it tackles that issue.
The KISS principle facilitates continuity when needed and gives room for other people to understand the process.
Simpler processes allow for greater efficiency in automated testing. It is easier to test a simple system than a complex one.

Finally, we should strive to reduce complexity as much as we can, make our coding process very transparent, efficient and secure.

For me, KISS brings to mind and indestructible glass box, where all the processes can be clearly seen but is also very secure.

On a lighter note, If you’re in a business meeting and you been cornered with some hard business questions that you barely understand but you’re expected to know, give Complex Technological Answers! 😂, Otherwise keep it simple always!. 😉

Adios.🙂