DEV Community: kali kimanzi

Git From Zero to Hero: A Master Class

kali kimanzi — Mon, 10 Aug 2026 11:11:54 +0000

Git From Zero to Hero: A Master Class

Git runs almost every codebase you have ever touched, yet most developers only know a handful of commands by muscle memory. They type git add ., git commit, git push, and hope for the best. This guide is different. It starts from the absolute beginning and walks all the way to the internals that power tools like GitHub, GitLab, and every CI pipeline you rely on.

By the end you will not just know the commands. You will understand the model underneath them, which means you will never be afraid of a merge conflict, a detached HEAD, or a broken rebase again.

This course has three levels.

Beginner: what Git is, the three trees, and your first commits
Intermediate: branching, merging, rebasing, and working with remotes
Expert: the object model, refs, the reflog, and advanced recovery and workflows

Grab a terminal and follow along.

Why Git Exists
Beginner: The Three Trees
Beginner: Your First Repository
Beginner: Ignoring Files
Intermediate: Branches Are Just Pointers
Intermediate: Merging
Intermediate: Rebasing
Intermediate: Merge vs Rebase, the Real Answer
Intermediate: Working With Remotes
Intermediate: Stash and Tags
Expert: The Object Model
Expert: Refs, HEAD, and Detached States
Expert: The Reflog, Your Safety Net
Expert: Interactive Rebase
Expert: Cherry-pick and Bisect
Expert: Workflows That Teams Actually Use
Cheat Sheet
Closing Thoughts

Why Git Exists

Before Git, most teams used centralized version control. A single server held the entire history, and every commit required a network round trip. If that server went down, work stopped. If your connection was slow, your workflow suffered with it.

Linus Torvalds built Git in 2005 to maintain the Linux kernel, and he designed it around a simple idea: every developer keeps a full copy of the project history on their own machine. There is no single point of failure, and almost every operation is instant because it happens locally.

Diagram by Kali Kimanzi

Notice the dotted line in the distributed model. Developers can even share commits directly with each other without touching the central remote at all. That single design decision is why Git scales from a solo hobby project to a codebase with thousands of contributors.

Beginner: The Three Trees

Everything in Git revolves around three areas living on your machine. People new to Git often skip past this and jump straight to memorizing commands, which is exactly why git add feels mysterious. Once you see the three trees, the commands explain themselves.

Diagram by Kali Kimanzi

The working directory is what you see in your editor right now.
The staging area (also called the index) is a draft of your next commit. You choose exactly what goes in it.
The repository is the permanent, immutable history stored inside the .git folder.

This is the entire mental model. git add moves changes from the working directory into the draft. git commit seals that draft into history forever. Nothing about Git makes sense until this clicks, so read that diagram twice if you need to.

Beginner: Your First Repository

# one time setup on a new machine
git config --global user.name "Kali Kimanzi"
git config --global user.email "you@example.com"

# start a new repo
mkdir my-project && cd my-project
git init

# check what state things are in
git status

# create a file, then stage and commit it
echo "# My Project" > README.md
git add README.md
git commit -m "Initial commit"

# see the history
git log

A few commands you will run constantly:

Command	What it actually does
`git status`	Shows which files are in the working directory vs staged
`git add <file>`	Moves a file's changes into the staging area
`git commit -m "msg"`	Seals staged changes into a permanent snapshot
`git log`	Shows the commit history, newest first
`git diff`	Shows unstaged changes between working directory and staging
`git diff --staged`	Shows staged changes between staging and last commit

Diagram by Kali Kimanzi

Beginner: Ignoring Files

Not everything belongs in history. Build artifacts, dependency folders, and secrets should never be committed. Git reads a .gitignore file at the root of your repo.

node_modules/
dist/
.env
*.log

A rule of thumb that will save you from painful incidents: anything that can be regenerated (build output, installed packages) or that contains a secret (API keys, passwords) does not belong in Git.

Intermediate: Branches Are Just Pointers

This is the idea that unlocks Git for good. A branch is not a copy of your code. A branch is a small file containing one thing, the hash of a single commit. When you commit again, Git just moves that pointer forward. That is the entire mechanism, and it is why creating a branch in Git is instant regardless of how large the project is.

Diagram by Kali Kimanzi

git branch feature/login       # create a branch, stay where you are
git switch feature/login       # move to that branch
git switch -c feature/signup   # create and switch in one step
git branch                     # list local branches
git branch -d feature/login    # delete a branch that has been merged

Because a branch is just a movable pointer, switching branches is cheap and creating experimental branches costs nothing. This is why Git culture leans heavily on branching for every feature, every bugfix, and every experiment.

Intermediate: Merging

A merge brings the work from one branch into another. If the two branches changed different parts of the code, Git combines them automatically and creates a new commit with two parents, called a merge commit.

Diagram by Kali Kimanzi

git switch main
git merge feature/login

When both branches edited the same lines, Git cannot guess your intent and asks you to resolve a conflict. It marks the file like this:

<<<<<<< HEAD
const greeting = "Hello there";
=======
const greeting = "Hi friend";
>>>>>>> feature/login

You edit the file to keep what you actually want, remove the markers, then run:

git add <file>
git commit

A conflict is not a failure. It is Git correctly refusing to guess between two changes it cannot reconcile on its own.

Intermediate: Rebasing

Rebase takes the commits from your branch and replays them on top of another branch, one at a time, as if you had started your work later than you actually did. The result is a straight, linear history with no merge commit.

Diagram by Kali Kimanzi

git switch feature/login
git rebase main

Notice the commits become c3' and c4', with a prime mark. Rebase does not move the original commits, it creates brand new ones with the same changes but different parent history and a new hash. This detail matters a lot, and it leads directly to the next section.

Intermediate: Merge vs Rebase, the Real Answer

This is one of the most argued about topics in software engineering, and the honest answer is that both are correct tools for different jobs.

Diagram by Kali Kimanzi

The one rule that prevents real disasters: never rebase a branch that other people have already pulled. Since rebase rewrites commit hashes, anyone who already has the old commits will end up with duplicated, conflicting history. Merge is always safe on shared branches. Rebase is a personal cleanup tool for your own local, unpublished work.

Intermediate: Working With Remotes

A remote is just another copy of the repository, usually hosted on a service like GitHub. Your local repo and the remote sync through three operations.

Diagram by Kali Kimanzi

git clone https://github.com/user/repo.git   # copy a remote repo locally
git remote -v                                # see configured remotes
git fetch origin                             # download new commits, do not touch your branch
git pull origin main                         # fetch, then merge into your current branch
git push origin main                         # upload your commits
git pull --rebase origin main                # fetch, then rebase instead of merge

fetch is always safe. It only downloads data, it never touches your working directory or your current branch. pull is fetch plus an automatic merge, which is convenient but can surprise you with a merge commit you were not expecting. Many experienced developers run git fetch followed by a manual git merge or git rebase so they stay in control of what happens.

Intermediate: Stash and Tags

Sometimes you need to switch branches but you are not ready to commit. Stash lets you shelve your changes temporarily.

git stash              # save working directory changes, revert to clean state
git stash list          # see saved stashes
git stash pop           # reapply the most recent stash and remove it from the list
git stash apply         # reapply without removing it from the list

Tags mark a specific commit permanently, most often used for releases.

git tag v1.0.0                       # lightweight tag on current commit
git tag -a v1.0.0 -m "First release" # annotated tag with metadata
git push origin v1.0.0               # tags are not pushed automatically

Expert: The Object Model

Here is the part that turns Git from a tool you use into a system you understand. Everything in a Git repository, every file, every folder, every commit, is stored as an object identified by the SHA hash of its content. This is called content addressable storage, and it is the real foundation everything else sits on.

There are four object types.

Diagram by Kali Kimanzi

A blob stores the raw content of a single file. It has no filename, no permissions, nothing but content. Two files with identical content anywhere in your repo history share the exact same blob.
A tree represents a directory. It lists blobs and other trees along with filenames and modes.
A commit points to one tree (the full snapshot of the project at that moment) plus one or more parent commits, an author, and a message.
A tag (the annotated kind) points at a commit and adds extra metadata like a signature.

You can inspect this yourself:

git cat-file -p HEAD                 # show a commit object
git cat-file -p HEAD^{tree}          # show the tree it points to
git cat-file -t <hash>               # ask Git what type an object is
git hash-object -w somefile.txt      # manually create a blob, see the hash

Because objects are addressed by the hash of their content, a commit hash is really a hash of a hash of hashes, a fingerprint of the entire project history up to that point. This is exactly why changing anything in the past, even one character in one old commit, changes that commit's hash and every hash after it. That single fact explains why rebase produces new commit hashes and why Git history is described as immutable.

Expert: Refs, HEAD, and Detached States

A ref is a human friendly name that points at a commit hash. Branches live at .git/refs/heads/, remote tracking branches at .git/refs/remotes/, and tags at .git/refs/tags/. HEAD is special, it usually points at a branch, which then points at a commit.

Diagram by Kali Kimanzi

When you check out a specific commit hash instead of a branch, HEAD points directly at that commit. This is called a detached HEAD.

Diagram by Kali Kimanzi

A detached HEAD is not dangerous, it just means new commits you make will not belong to any branch. If you commit here and then switch to another branch without creating a new branch first, those commits become unreachable from any ref. They are not deleted immediately, but they will eventually be garbage collected. If you find yourself in a detached HEAD and want to keep your work, run git switch -c new-branch-name before doing anything else.

Expert: The Reflog, Your Safety Net

Even "unreachable" commits are not gone right away. Git keeps a local log of every place HEAD has pointed, called the reflog, and it is the single most underused recovery tool in Git.

git reflog

a1b2c3d HEAD@{0}: commit: fix login bug
e4f5g6h HEAD@{1}: checkout: moving from main to feature/login
i7j8k9l HEAD@{2}: reset: moving to HEAD~1
m0n1o2p HEAD@{3}: commit: initial version

Accidentally ran git reset --hard and lost commits? Force pushed and overwrote a branch? As long as it is still within the reflog window (90 days by default for reachable commits), you can recover it.

git reflog                        # find the hash right before the disaster
git reset --hard HEAD@{2}         # or: git checkout -b rescue-branch <hash>

Learn this one tool well. It has saved more careers than any other Git feature, and it is the reason the phrase "I force pushed and lost everything" is almost never actually true.

Expert: Interactive Rebase

Interactive rebase lets you rewrite local history before sharing it: squash messy commits into one, reorder them, edit messages, or drop a commit entirely.

git rebase -i HEAD~4

This opens an editor with your last four commits listed oldest to newest:

pick a1b2c3d Add login form
pick e4f5g6h Fix typo
pick i7j8k9l Add validation
pick m0n1o2p Fix typo again

Change the keywords to control what happens:

Keyword	Effect
`pick`	keep the commit as is
`reword`	keep the changes, edit the message
`squash`	merge into the previous commit, combine messages
`fixup`	merge into the previous commit, discard this message
`drop`	remove the commit entirely

pick a1b2c3d Add login form
fixup e4f5g6h Fix typo
pick i7j8k9l Add validation
fixup m0n1o2p Fix typo again

Save and exit, and those four messy commits become two clean ones. This is exactly how experienced developers keep a readable history despite committing constantly while actually working. The same rule from earlier still applies, only rebase commits that are still local and unpushed, or that you are certain nobody else has already pulled.

Expert: Cherry-pick and Bisect

cherry-pick copies a single commit from one branch onto another, creating a new commit with the same changes but a new hash and parent.

git cherry-pick a1b2c3d

This is the tool for the common real world situation where a hotfix landed on main and you need that exact fix on a release branch too, without merging all of main's other changes.

bisect performs a binary search through history to find the exact commit that introduced a bug. Instead of manually checking commits one by one, you tell Git one good commit and one bad commit, and it checks out the midpoint for you to test.

git bisect start
git bisect bad                 # current commit has the bug
git bisect good v1.2.0         # this old tag was fine
# Git checks out a commit in the middle, you test it, then:
git bisect good   # or: git bisect bad
# repeat until Git names the exact commit that broke things
git bisect reset  # return to where you started

Diagram by Kali Kimanzi

In a history of 1000 commits, bisect finds the culprit in about 10 tests instead of up to 1000, because it halves the search space every step.

Expert: Workflows That Teams Actually Use

The commands are the same everywhere, but teams organize branches differently depending on how often they release.

Diagram by Kali Kimanzi

Git Flow uses long lived develop and main branches, plus feature, release, and hotfix branches. It gives strong structure and suits products with scheduled releases, but it adds overhead that many fast moving teams find unnecessary.

Trunk based development keeps everyone working off a single main branch with short lived feature branches, often merged within a day. It pairs well with feature flags and continuous deployment, and it is what most modern SaaS companies use today.

GitHub flow sits in between: branch from main, open a pull request, review, merge, deploy. Simple, and the default most newer teams should reach for unless they have a specific reason not to.

There is no universally correct choice. Pick the workflow that matches how often your team actually ships.

Cheat Sheet

# setup
git init
git clone <url>
git config --global user.name "Kali Kimanzi"
git config --global user.email "you@example.com"

# daily loop
git status
git add <file>
git commit -m "message"
git push
git pull

# branching
git switch -c <branch>
git switch <branch>
git branch -d <branch>
git merge <branch>
git rebase <branch>

# inspecting
git log --oneline --graph --all
git diff
git show <hash>
git blame <file>

# undoing
git restore <file>              # discard working directory changes
git restore --staged <file>     # unstage, keep changes
git commit --amend              # fix the last commit
git reset --soft HEAD~1         # undo commit, keep changes staged
git reset --hard HEAD~1         # undo commit, discard changes (careful)
git revert <hash>               # safe undo, creates a new commit

# recovery
git reflog
git reset --hard HEAD@{n}

# advanced
git rebase -i HEAD~n
git cherry-pick <hash>
git bisect start
git stash
git tag -a v1.0.0 -m "release"

Closing Thoughts

Git rewards understanding over memorization. Once you see that a branch is just a pointer, that a commit is just a snapshot linked to its parent, and that almost every command is a small, predictable operation on that graph, the tool stops feeling like magic. You stop fearing conflicts, detached HEADs, and rebases, because you know exactly what is happening underneath and you know the reflog has your back.

Start with the three trees. Get comfortable branching and merging. Then, when you are ready, go read your own .git folder with cat-file and watch the object model become real in front of you. That is the moment Git actually clicks.

If this guide helped you, follow along for more deep dives like this one.

Kali Kimanzi

The Vision of One or the Vision of Many: A Dilemma in the Age of Innovation(Elon Musk or Jack Dorsey)

kali kimanzi — Fri, 27 Oct 2023 15:29:46 +0000

Imagine a solar system with a single star and many planets, each with its own orbit, rotation, and characteristics. Now imagine another solar system with multiple stars and fewer planets, each influenced by the gravitational forces of different stars. Which solar system is more stable, more diverse, and more conducive to life?

This is the metaphor that comes to my mind when I think about the vision of one versus the vision of many in the world of technology and innovation. Should we follow the lead of a single visionary who has a clear and ambitious plan for the future, or should we embrace the diversity and creativity of many visionaries who have different perspectives and goals?

A few years ago, if you had asked me this question, I would have told you that I believe in the vision of many. I would have argued that from chaos comes order, and that the vision of many creates chaos that fosters innovation and adaptation. I would have associated Jack Dorsey with the vision of many, not from his role as the CEO of Twitter, but from his involvement in Bitcoin, Nostr, and Primal, projects that aim to decentralize and democratize various aspects of society.

But lately, I have been conflicted by the impressive achievements of Elon Musk, who epitomizes the vision of one. He has a grand vision for humanity that spans across multiple domains, such as space exploration, electric vehicles, renewable energy, neural interfaces, and artificial intelligence. He has demonstrated his ability to execute his vision with remarkable speed and efficiency, creating companies that disrupt and dominate their respective industries.

Can the vision of one and the vision of many coexist and complement each other, or are they incompatible and competitive? While I have not lived long enough to witness the long-term outcomes of these two approaches, I can see from a distance that both have their merits and drawbacks. The vision of one can provide direction, focus, and scale, but it can also entail risk, rigidity, and monopoly. The vision of many can offer diversity, creativity, and resilience, but it can also result in fragmentation, confusion, and conflict.

What does this mean for the computing systems of the future? Which approach has more advantages over the other, or should we reframe the question and look at how each approach has been implemented? Does this mean that centralized systems are not all that bad, or that decentralized systems are not all that good? Time will tell.

The Daily Newsletter: Your Secret Weapon for Success in Software Engineering

kali kimanzi — Tue, 24 Oct 2023 09:11:07 +0000

As a software engineer, I know how important it is to keep up with the latest developments in technology. But with so much information out there, how can I find the time and energy to read everything?

That’s why I have adopted a simple habit: reading a newsletter a day. Yes, you heard me right. Just one newsletter a day can make a huge difference in my skills and knowledge as a software engineer.

Here are some of the benefits of reading a newsletter a day:

It provides concise information that summarizes the most important updates in software engineering.
It offers curated content from reputable sources or industry experts who know what matters.
It ensures regular updates that keep me informed about the latest trends, tools, and technologies in software engineering.
It gives me diverse perspectives from different authors, which broaden my understanding and approach towards software engineering.
It allows me to learn at my own pace, spending time on complex topics and skipping those that are not relevant to me.
It creates networking opportunities with online communities or forums where I can interact, ask questions, and share ideas with like-minded professionals. I have been reading a newsletter a day for the past few months and I can say that it has significantly improved my skills and knowledge as a software engineer. I have learned new things, discovered new tools, and gained new insights that have helped me in my work.

If you’re looking for an easy and effective way to stay updated and grow as a software engineer, I highly recommend reading a newsletter a day. You can find many newsletters that cater to your interests and needs online. Just pick one that resonates with you and make it part of your daily routine.

Trust me, you won’t regret it!

The Efficacy of Psychometric Tests in Identifying Proficient Software Engineers

kali kimanzi — Mon, 23 Oct 2023 00:10:47 +0000

In the recent past, I found myself taking a psychometric test that emphasized speed and accuracy. This approach seemed somewhat out of place to me. Is the essence of engineering truly about speed? Has the discipline been diminished to mere instincts, much like foreign exchange trading? While I recognize that engineering involves solving problems, I question whether reaching a solution more quickly is synonymous with reaching the safest solution.

Engineering is not merely about finding solutions at a rapid pace. Accuracy is indeed a factor to consider, but it is not the sole determinant of a good engineering solution. Safety and resource efficiency must also be taken into account.

Interestingly, psychometric tests seem to reduce engineering to an analytical approach, while in reality, engineering is largely a classical discipline.

So, are psychometric tests the most effective way to determine if an engineer excels in their work? I would challenge this approach to some extent. From my own engineering experience, I have come to realize that solutions can arise from various perspectives and that quick thinking contributes minimally to effective engineering solutions.

I believe that speed and accuracy only measure certain aspects of an individual engineer's quick thinking abilities. While these traits might be beneficial in certain fields like aviation engineering, I believe that they represent an inner layer - something innate - that has minimal influence on the overall effectiveness of an engineer.

Finally, psychometric tests can be gamed. There are many resources available online and in books that teach people how to improve their performance on psychometric tests. This means that candidates who are good at taking tests may score higher than candidates who are more skilled in engineering.

While there may not be a universally accepted approach to determine a good engineer, I am skeptical about the inclusion of psychometric tests in the hiring process. These tests may provide some insights but should not be the sole or primary determinant in the hiring decision.

Efficient String Splitting in Go: A Solution for Gophers Dealing with API Responses

kali kimanzi — Tue, 27 Jun 2023 03:19:17 +0000

Introduction

When working with API responses in Go, Gophers often encounter the need to split strings based on a specific delimiter. This article aims to provide a solution to this common problem by presenting an efficient code snippet for string splitting in Go. By understanding and implementing this solution, Gophers can effortlessly separate string values, especially when dealing with API responses.

Understanding the Problem

In the realm of API development, parsing and manipulating response data is an essential task. It's not uncommon to receive a string that needs to be split into separate parts based on a specific delimiter, such as a dollar sign ($). While Go provides built-in functions for string manipulation, knowing the most efficient way to split strings can greatly enhance a developer's productivity.

The Solution: String Splitting in Go

To tackle this problem efficiently, we will leverage Go's standard library package strings and its Split function. The code snippet provided below demonstrates a clean and effective way to split a string using the dollar sign ($) as the delimiter:

package main

import (
    "fmt"
    "strings"
)

func separateString(input string) []string {
    // Split the string using the dollar sign ($) as the delimiter
    parts := strings.Split(input, "$")

    // Remove any leading or trailing empty strings resulting from the split
    var result []string
    for _, part := range parts {
        if part != "" {
            result = append(result, part)
        }
    }

    return result
}

func main() {
    // Example usage
    input := "Hello$world$how$are$you?"
    parts := separateString(input)

    fmt.Println("Original String:", input)
    fmt.Println("Separated Parts:", parts)
}

Results

Original String: Hello$world$how$are$you?
Separated Parts: [Hello world how are you?]

By utilizing the strings.Split function, the input string is split into separate parts based on the dollar sign ($) delimiter. To ensure clean results, the code snippet also removes any leading or trailing empty strings that may result from the split.

Benefits and Use Cases

The provided code snippet offers several benefits and can be applied in various scenarios:

API Response Parsing: When working with API responses, it's common to receive string data that needs to be parsed and processed. The efficient string splitting solution presented here can be a valuable asset in handling and extracting meaningful information from API responses.
Custom Delimiters: While the code snippet uses the dollar sign ($) as the delimiter, it can be easily modified to work with other delimiters based on your specific requirements. This flexibility empowers developers to adapt the solution to a wide range of use cases.
Improved Productivity: By understanding and implementing this efficient string splitting approach, Gophers can save valuable development time and effort. The solution provides a streamlined way to process and manipulate strings, making API response handling more convenient and less error-prone.

Conclusion

Working with API responses often requires Gophers to split strings based on specific delimiters. With the provided solution for efficient string splitting in Go, developers can handle this task effortlessly. By utilizing the strings.Split function and incorporating the additional logic to remove empty strings, Gophers can extract meaningful information from API responses with ease. Armed with this knowledge, Gophers can enhance their productivity and streamline their string handling capabilities in Go.

Sending Gmail with Swiftmailer

kali kimanzi — Mon, 12 Jul 2021 12:02:41 +0000

adding mailing functionality to website is quite an essential part of website development. most website have this sections either in the contact us section, feedback sections among other sections like registration and sign up. It can be quite a hustle when you are beginner because we have you need to have a solutions that works without too much hassle, I prefer swift mailer because i find it straight of the box solutions compared to vanilla solutions and PHPMAILER(you are allowed to have an alternative view who cares though ). This tutorial assumes you have installed your XAMPP or whatever server you have there and also prior knowledge on PHP is a bonus .

To avoid too much stories let's get straight to it.

Steps

Download swiftmailer
create mailing script
Enable your gmail account for IMAP
Testing your mailing script

1. Download swiftmailer

In your htdocs folder create your working director in my case i have named it sendmail.

inside the sendmail directory install swiftmailer with composer. Check also on the swiftmailer official website here

composer require "swiftmailer/swiftmailer:^6.0"

2. Create mailing script

This is a simple script which contains mailing function and html form, the message is hardcoded but for demonstration purpose. create this script inside your working directory eg sendmail

<?php

if (isset($_POST["email"])){

//echo $_POST["email"] ;

require_once './vendor/autoload.php';

// Create the Transport
$transport = (new Swift_SmtpTransport('smtp.gmail.com', 465, 'ssl'))
  ->setUsername('putyouremail@gmail.com')
  ->setPassword('putyouremailpassword')
;

// Create the Mailer using your created Transport
$mailer = new Swift_Mailer($transport);

// Create a message
$message = (new Swift_Message('Mail tutorial '))
  ->setFrom(['putyouremail@gmail.com' => 'sending mail tutorial'])
  ->setTo([$_POST["email"] => 'testing the mail sending option '])
  ->setBody('congrats you have send your firstmail cheers to your new skill')
  ;

// Send the message
$result = $mailer->send($message);

}
?>

<form action="" method="post">
<input type="text" name="email" placeholder = "Email Me">
<input type="submit" value="Email me">
</form>

3. Enable your gmail account for IMAP

after you have created this script use the following address to enable IMAP settings due to google security settings

https://www.google.com/settings/security/lesssecureapps

4. Testing your mailing script

Run your script on local host and enjoying using it. you can create complicated mailing systems with swiftmailer among other things. Happy coding

ABOUT ME

I hope you have liked this article.
I am Kali Kimanzi a Masters student Energy Informatics at University of Applied Sciences Upper Austria, I am also a software developer at NTUITY a brand of neoom group Gmbh Wien | Freistadt. I take interest in Data sciences using python and I use python libraries like pandas, numpy and Matplotlib. I specialize in Python, PHP/Laravel, Java.
Social media links
Kali kimanzi @ Facebook: Kali Kimanzi
Kali Kimanzi @ Linkedin: Kali Kimanzi
Kali Kimanzi @ instagram : Kali_Kimanzi
Kali Kimanzi GitHub: Kali Kimanzi
kali kimanzi Twitter : Kali Kimanzi

HOW TO PUT A ANGULAR APPLICATION TO A DOCKER CONTAINER

kali kimanzi — Wed, 05 Aug 2020 14:03:25 +0000

I have read quite complicated articles on how to deploy an Angular application to a docker container that is why I am motivated to write this simplest step by step guide to putting your angular app to docker container

1 Assuming you have already created your app and now you want to dockerize it. run the code below to create a dist folder in your application folder

ng build

2 create a file called Dockerfile under root of your application as illustrated below

3 copy following code to your Dockerfile

FROM node:alpine AS my-app-build
WORKDIR /app
COPY . .
RUN npm install && npm run build

FROM nginx:alpine
COPY --from=my-app-build /app/dist/{name-of-your-application} /usr/share/nginx/html
EXPOSE 80

4 Now your application is ready to be put in a docker container. this tutorial assumes you have downloaded docker and a copy is running locally on your machine. if you have not downloaded the docker application visit the Docker website to download the version suitable for your machine . when all that has been set up use the code below to build image for your application.

// docker build -t name-of-container:tag-of-image .
docker build -t my-application-container:latest .

5 To start your application locally and test it on a browser run
docker run --publish 80:80 --detach --name bb bulletinboard:lastest

I hope you enjoyed this tutorial. i will write more tutorials on how to deploy your Docker container on Azure.

Finding a minimum number in a Java Array

kali kimanzi — Fri, 10 Jan 2020 10:35:38 +0000

Sometime back we were given a java assignment but I realized the concepts looked easy but some of my friends had problems implementing them that is why I have decided to be sharing some of the java assignments that I have done in the past to help students and learners who are new to programming in java.

Question:

Write a function int findMin (int[] numbers), which yields the smallest element of numbers that contains positive integers. The result shall be -1, if numbers has the value null or the array does exclusively contain positive integers. Use several test cases.

Java Source Code:



public class FindingMinimum {

    public static void main(String[] args) {
        // int[] numbers =null;
        // System.out.println(x);
        // int[] numbers= {2,3,4,5,6,20,1,-5};
        int[] numbers = { 2, 3, 4, 5, 6, 20, 1 };
        //int[] numbersSet1= {2,3,4,5,6,20,1,-5};

        int minimumNumber = findMin(numbers);
        System.out.println("The Minimum number is :\t"+minimumNumber);
        //minimumNumber = findMin(numbersSet1);
        //System.out.println("The Minimum number is :\t"+minimumNumber);

    }

    static int findMin(int[] numbers) {
        int minValue = numbers[0];

        if (isExclusivePositive(numbers)) {

            for (int i = 1; i < numbers.length; i++) {
                if (numbers[i] < minValue) {
                    minValue = numbers[i];
                }
            }
        } else {
            minValue = -1;
        }
        return minValue;

    }

    static boolean isExclusivePositive(int[] numbers) {
        int value = 0;

        for (int i = 0; i < numbers.length; i++) {
            value = numbers[i];

            if (value < 0)
                return false;
        }

        return true;
    }

}

Output:

The Minimum number is : 1

I hope you have liked this article.

I am Kali Kimanzi a Masters student at University of Applied Sciences Upper Austria, I am a software developer at NTUITY a brand of neoom group gmbh Wien | Freistadt. I take interest in Data sciences using python and i use python libraries like pandas, numpy and Matplotlib. I specialize in Python, PHP/Laravel, Java.

Social media links

Kali kimanzi @ Facebook: Kali Kimanzi
Kali Kimanzi @ Linkedin: Kali Kimanzi
Kali Kimanzi @ instagram : Kali Kimanzi
Kali Kimanzi GitHub: Kali Kimanzi
kali kimanzi Twitter : Kali Kimanzi

Writing Python Api with Flask RESTful

kali kimanzi — Thu, 09 Jan 2020 22:20:15 +0000

I had been working on a python application, Now it came to the section where I had to write an API for my application. it was such a headache because I was a newbie on Api's and I had little understanding of APIs. So I spend so much time online reading about APIs and how to integrate one to my application. it all looked like rocket science from most of the articles I went through. that is why I decided to come up with this article. it will take you through implementing a simple API, Later I will come up with a more detailed article though this code will take you through most of the basics of flask RESTful API and how to create one successfully.
I have put comments on my code for clarification and detailed walkthrough.

everything that starts with # is a comment, I believe if you are reading the article you have an understanding of python coding. hope you will like this article.
The concept of using classes with python has been covered in this article to help you have full understanding. I will write a more advanced article for now this
article is for absolute beginners

what the application below does

Receives json file and extracts the json values that are then used for computation
After computation, the application creates a JSON file. this request can be done through postman which enable to make api calls and request.

Before i begin this article it would be nice if share how the file structure looks on my pycharm IDE.

This is the main file for your flask

from flask import Flask, jsonify, request
#importing flask restful extenstion
from flask_restful import Resource, Api

#importing a class from a package called ntuity in the application

from ntuity.ntuityprac import  #importing a class from a package called ntuity

app = Flask(__name__)
*api=Api(app)


##class Kamau(Resource):

    def post(self):
        jsonval=request.get_json()
        content=jsonval.get("number")
        sum=10*content
        bestie=["welcome", 525, "kiza"]
        return jsonify({"sum":sum,"kenya":bestie})

class Kithome(Resource):
    p=NtuityPrac() #class object
    getval=p.get_square
    getsum=p.get_sum


    def post(self):
        jsonval = request.get_json()
        content = jsonval.get("number")
        get_add=self.getsum(content)
        get_sum=self.getval(content)
        return jsonify({"square":get_sum, "sum":get_add})


api.add_resource(Kamau,'/kama')
api.add_resource(Kithome,'/kithome')
if __name__ == '__main__':
    app.run()

below is the imported class from a package has two methods 

1. get_square()
2. get_sum()


class NtuityPrac:
#this class has two methods get square and get sum
    def get_square(self,num1):
        return num1*num1

    def get_sum(self, num1):
        return num1+num1

This a post man json request to kithome endpoint

The output of this request is json file with sum and square

I hope you have liked this article.

I am Kali Kimanzi a Masters student Energy Informatics at University of Applied Sciences Upper Austria, I am also a software developer at NTUITY a brand of neoom group gmbh Wien | Freistadt. I take interest in Data sciences using python and i use python libraries like pandas, numpy and Matplotlib. I specialize in Python, PHP/Laravel, Java.

Social media links

Kali kimanzi @ Facebook: Kali Kimanzi
Kali Kimanzi @ Linkedin: Kali Kimanzi
Kali Kimanzi @ instagram : Kali Kimanzi
Kali Kimanzi GitHub: Kali Kimanzi
kali kimanzi Twitter : Kali Kimanzi

Nesting For loops in Java

kali kimanzi — Wed, 08 Jan 2020 17:28:32 +0000

this program aims at demystifying the headache behind nesting of for loops in java and other programming languages

?signin=true

DEV Community: kali kimanzi

Git From Zero to Hero: A Master Class

Git From Zero to Hero: A Master Class

Table of Contents

Why Git Exists

Beginner: The Three Trees

Beginner: Your First Repository

Beginner: Ignoring Files

Intermediate: Branches Are Just Pointers

Intermediate: Merging

Intermediate: Rebasing

Intermediate: Merge vs Rebase, the Real Answer

Intermediate: Working With Remotes

Intermediate: Stash and Tags

Expert: The Object Model

Expert: Refs, HEAD, and Detached States

Expert: The Reflog, Your Safety Net

Expert: Interactive Rebase

Expert: Cherry-pick and Bisect

Expert: Workflows That Teams Actually Use

Cheat Sheet

Closing Thoughts

The Vision of One or the Vision of Many: A Dilemma in the Age of Innovation(Elon Musk or Jack Dorsey)

The Daily Newsletter: Your Secret Weapon for Success in Software Engineering

The Efficacy of Psychometric Tests in Identifying Proficient Software Engineers

Efficient String Splitting in Go: A Solution for Gophers Dealing with API Responses

Introduction

Understanding the Problem

The Solution: String Splitting in Go

Benefits and Use Cases

Conclusion

Sending Gmail with Swiftmailer

1. Download swiftmailer

2. Create mailing script

3. Enable your gmail account for IMAP

4. Testing your mailing script

ABOUT ME

HOW TO PUT A ANGULAR APPLICATION TO A DOCKER CONTAINER

Finding a minimum number in a Java Array

Writing Python Api with Flask RESTful

what the application below does

Nesting For loops in Java