Introduction to ALX

On that day I was happy I got in, and became a member of the ALX 12-Month SE August 2022 cohort, and this is like a dream come true, because being a self taught developer is doable but not always the best route. This will be coming like a weekly series to document my progress through this program and as I do aspiring software engineers can learn about a lot of things.

Firstly we had our Karibu(welcome) ceremony and it was fun, educative and most importantly prepared us for what is to come. We were addressed by the CEO Fred Swaniker and by other mentors. We met with the team and knew what role they had in the program.

Next we got hooked on **Slack **and took a deep dive into the Intranet. Oh! My bad, I will expain what these are. These platforms were going to be essential and we would do almost everything on these platforms. Slack being a more social platform than Intranet where we did most of the task and learning. Slack was where we were grouped according to our cohort and also region. We could communicate on slack with our peers and also our mentors that guide us through the program. The Intranet was where the projects, tasks, quizzes, assessment, scoring and many more stuff was released and deadlines attached to each task. We had to set up these two platforms to enable us to go through the software engineering program successfully.

Everything was set technically and ready to start firing, but we needed to also be psychologically, mentally prepared with the right motivation. So the organizers let us watch Angela Duckworth and Prof. Carol Dweck who talked about **Grit **and the Growth mindset and to make sure we watched it, a quiz was set from the videos and a compulsory summary must be written and reviewed by a fellow aspiring software engineer.

Right after we looked at concepts like the **shell navigation **and powerfully flexible text editors like vi and emacs bellow are some important point what remembering as a software engineer

Shell navigation

We explored the Unix system and files architecture. Basically we learnt the commands for doing a whole lot in a Unix/Linux environment. Some notable and useful commands include:

Command description

ls Lists all files and directories in the present working directory

ls -R Lists files in subdirectories as well

**ls -a ** Lists hidden files as well

ls -al Lists files and directories with detailed information like permissions,size, owner, etc.

cd or cd ~ Navigate to HOME directory

**cd .. ** Move one level up

**cd ** To change to a particular directory

**cd / ** Move to the root directory

cat > filename Creates a new file

cat filename Displays the file content

cat file1 file2 > file3 Joins two files (file1, file2) and stores the output in a new file (file3)

**mv file "new file path" ** Moves the files to the new location

mv filename new_file_name Renames the file to a new filename

**sudo ** Allows regular users to run programs with the security privileges of the superuser or root

rm filename Deletes a file

**man ** Gives help information on a command

history Gives a list of all past commands typed in the current terminal session

clear Clears the terminal

mkdir directory name Creates a new directory in the present working directory or a at
the specified path

**rmdir ** Deletes a directory

**mv ** Renames a directory

Text editors Emacs and Vi commands commonly used:

Emacs:

Char-Sequence and function

C-f Move forward one character

Meta-f Move forward one word

**C-a **Move to beginning of current line

Meta-a Move to beginning of sentence

C-n Move to next line

C-v View next page

Meta-[ Move to next paragraph

Meta-< Move to beginning of buffer

C-@ Mark this place in the buffer

DEL Delete last character

Meta-d Delete word

Meta-Del Delete backward one word

C-k Kill rest of line

C-y Yank out what is in the buffer

C-y Yank previous kill

Meta-h Mark paragraph

Meta-t Transpose two words

C-o Open line

C-i Indent according to mode

C-s Search forward (C-g or Meta to end)

Meta-c Capitalize initial letter of word

Meta-u Capitalize whole word

C-h Emacs help system

**C-x i **Insert a file

C-x C-f Get (Find) file

C-x C-v Visit a file

C-x 2 Split window horizontally

C-x o Move to another window

C-b Move backward one character

Meta-b Move backward one word

C-e Move to end of current line

Meta-e Move to end of current sentence

C-p Move to previous line

Meta-v View previous page

Meta-] Move to previous paragraph

Meta-> Move to end of buffer

Vi :

i (I) Insert before the cursor (line)

o (O) Open a new line below (above)

l (h) Move right (left) one character

w (b) forward (backward) word

0 ($) move to the beginning (end) of line

fx Find char. x in the line

( [)] To previous [next] sentence

a (A) Append after the cursor (line)

J Join next line to current line

k (j) Move up (down) one line

c/E go to end of the word

^ to first visible char. of line

tx Go to char. x in line

{ [}] To previous [next] paragraph

nG (Go) to line n

H (L) to top (bottom) of screen

C-f/C-F Forward screen

C-d/C-D Down half screen

z Put line on top of screen

` Move to mark

m Mark this place as

r Replace one character

cw Replace (Chage) a word

dd Delete one line

u Undo the most recent change

nyy (ynw) Copy n lines (n words) into buffer

/ Search forward for

G to last line in buffer

M to middle of screen

C-b/C-B Backward screen

C-u/C-U Up half screen

z. Put line on middle of screen

% Move to matching bracket symbol

C-g Show status

R Replace mode

dw Delete one word

D Delete to the end of line

U Undo all changes on the current line

p Paste the buffer

n Repeat previous search

We were now getting a feel of the program. We learnt about Pseudo code, Algorithms and Flowchart. These practices are really valuable as they help simplify transfering ideas into code. It also helps software engineers when debugging to easily see how their program or code runs.

Then Jumped on the priceless Git/Github

Git and Github:

Git:

Basic Git commands

To use Git, developers use specific commands to copy, create, change, and combine code. These commands can be executed directly from the command line or by using an application like GitHub Desktop. Here are some common commands for using Git:

• git init initializes a brand new Git repository and begins tracking an existing directory. It adds a hidden subfolder within the existing directory that houses the internal data structure required for version control.

• git clone creates a local copy of a project that already exists remotely. The clone includes all the project's files, history, and branches.

• git add stages a change. Git tracks changes to a developer's codebase, but it's necessary to stage and take a snapshot of the changes to include them in the project's history. This command performs staging, the first part of that two-step process. Any changes that are staged will become a part of the next snapshot and a part of the project's history. Staging and committing separately gives developers complete control over the history of their project without changing how they code and work.

• git commit saves the snapshot to the project history and completes the change-tracking process. In short, a commit functions like taking a photo. Anything that's been staged with git add will become a part of the snapshot with git commit.

• git status shows the status of changes as untracked, modified, or staged.

• git branch shows the branches being worked on locally.

• git merge merges lines of development together. This command is typically used to combine changes made on two distinct branches. For example, a developer would merge when they want to combine changes from a feature branch into the main branch for deployment.

• git pull updates the local line of development with updates from its remote counterpart. Developers use this command if a teammate has made commits to a branch on a remote, and they would like to reflect those changes in their local environment.

• git push updates the remote repository with any commits made locally to a branch.

Github:

GitHub is a code hosting platform for version control and collaboration. It lets you and others work together on projects from anywhere. To connect to github from the CLI a username and personal access token is often required, and then use git config --global user.email "you@example.com" and ``` git config --global user.name "Your Name"

At the center and core of Github is Git. We also looked at doing some tasks both remotely on github and locally on git in the command line or github desktop client. 
We looked at advanced concepts like branching, rebase, squashing commits into one and many more.

Solving merge conflicts is a great skill to have if we are going to be working collaboratively with other programmers. A good commit message is also good practice as it solves a lot of problems in the future.
Pull request or merge request are made then the feature or branch reviewed before it is merged into the main codebase branch.

## Other Topics Covered:

Next we revisited the Grit and Growth Mindset task, but this time we did not just watch the motivational videos but also did interviews with adults, to share with us how they have experienced growth or the lack of it through their lives and careers.

We also learnt how to learn, yes that is correct. Implementing the **Feynman learning technique**, this will help us to master anything we learn and be able to explain it to anyone without google search. This technique involves going over a material or concept over and over, taking notes if possible and trying to understand the concept properly in a way you can easily explain with simple terminologies to anyone, even a child.

Other topics include **preserving our mental health & conquering imposter syndrome**, which is something we as aspiring software engineers are supposed to be aware of. Imposter syndrome is often tied to our identities and sense of self-worth. We are not sure if we fit for such roles or if we are actually capable of handling the role. But we were taught to look at ourselves and believe that we are amazing and we are no fraud. These lectures are necessary at the start of the program to enable us to prepare for what is common and could come our way.

The value this program gives is unmatched, and I am ready to ride through this journey of becoming a good software engineer. Keep eyes out for next week's summary about my journey as the program officially kicks off.