DEV Community: Abdurraheem Abdul-majeed

Getting started in Software development: A Path to a rewarding career (Part 4, What type of programmer should I be)

Abdurraheem Abdul-majeed — Sun, 27 Aug 2023 16:34:22 +0000

Hello and welcome

Thanks for stopping by.

Table of Content

Full table of content for the entire series is here

Today, we will continue the following

Getting started (cont'd)
- Decide which route you want to take (web, desktop, mobile, game, data, frontend, backend, Fullstack etc. We will be selecting Fullstack web development)

Decisions

Today, we will discuss one of the biggest challenges for new or upcoming software developers. What are my options in the profession, what route should I take from among the options, which of these is most fulfilling and when I choose, can I switch.

As a new developer, it is understandable for this to be a problem, especially because there is a wide range of options to pick from and to make it more interesting, every few years, the options increase by at least one or fifty 🤷.

The good news though is the same, there are many available options in terms of career paths and areas of specialization. You have a buffet and anyone you choose to pursue gives you the chance to have a fulfilling career so long as you commit to getting good at your chosen field and leveraging the many opportunities.

Switching is also quite easy in this line of work, just put in some work and get good at the new field and you will be able to secure roles in no time. Another amazing bit is that a good amount of the knowledge in each subfield carries over well to others.

Let us take a quick glimpse at some of the more common options:

Web Development

Building websites (like company landing pages, society information sites etc) and web applications (like Facebook, Netflix, Gmail etc). For these you will need technologies like HTML, CSS, JavaScript, python, php etc.

Web development is usually broken into two broad subsections namely

Frontend development: this involves two things; (1) designing the user interfaces (UI), the pages the users will see and interact with like buttons, colours, icons, lists etc. and (2) implementing the behaviours for speaking with the backend based on users’ interactions like filling a signup form and clicking submit, clicking follow on twitter (X), clicking play on Netflix, clicking upload on Instagram and so on
Backend development: this also involves two things (1) the server-side logic that controls what happens when users interact with the frontend like login, sign up, make payment, add profile picture and (2) database interactions to ensure that the changes made while using the application are persisted for next time. Without the database, there will be no way to keep information from a previous session so users can continue whenever they return to the application.

There are some awesome fellas however who can do both, because they have the skills to build out the frontend and the backend. They are called Fullstack developers. Awesome is good so we will be learning towards becoming one of such awesome Fullstack Developers.

Mobile App Development

This is quite like web development, and you will find that most of the web applications you see out there have accompanying mobile apps. It involves building applications to run on the most common mobile operating systems in the market (iOS and Android).

There are two approaches that are common in the industry these days:

Native mobile development: this involves building the applications using the native platforms provided by the maintainers of the operating systems like using Swift for iOS and Java or Kotlin for Android.
Cross-platform or Hybrid mobile development: There are frameworks like Ionic, React Native and Flutter that also allow developers to write code in web development technologies (HTML, CSS, Javascript) and then build them to works on multiple platforms like android and iOS devices.

There are trade-offs to either choice like:

Performance (native code is optimized for each OS so it will likely run better)
Cost and time to build (with hybrid, you can code once and build for multiple devices while with native you must code the same thing at least twice)
Access to native functionality like hardware features and APIs (native code has these out of the box but hybrids need to implement workarounds)
Maintenance (for every change on each OS for native, you must ensure you make same for the other and this also applies to bug fixes and stuff like that which can be a pain to track but for hybrids, all the coding is done once per change)

We will probably do a course on mobile development and go into more details when we are done with web development.

Desktop Application Development

This is a lot like mobile applications except you are creating applications that run on desktop operating systems like Windows, macOS, and Linux. This can involve various programming languages like Java, C#, Python, and C++. There are also some hybrid solutions for building desktop applications like Electronjs and the same constraints as in mobile apply here.

Game Development

All the video games we play are applications too and they can be built using specialized engines and tools like Unity or Unreal Engine. This field is highly specialized as combines programming skills with creativity and design. It takes some time and skill to get good at this, but the reward is worth the hustle

DevOps Engineer

They manage the entire process of enabling Developer operation*s* (DevOps). It typically involves some coding or automation to enable the IT operations involved in the software engineering process. After all the code has been written, it needs to be tested and deployed to production for our users to use it, this requires some IT operations to provision the servers, install dependencies, handle networking, data storage, and so on.

DevOps engineers focus on automating these processes enabling continuous integration and continuous deployment also referred to as CI/CD.

The typical DevOps person also needs some knowledge of Cloud Computing from providers like AWS, GCP, Azure and the likes

Quality Assurance (QA) Engineer

This type of developers are the unsung heroes of software development because they are the ones that write code to test the quality of code written by other developers to quickly identify bugs before it gets to the users ensuring software quality.

There are many levels of testing and language used for testing largely depends on the language being tested. There are however some tools and libraries that can mimic user behaviour on applications making it easy to go on the user journey and identify issues before releasing the application to the users

UI/UX Designer

These are not strictly developers, but I deem them worth a mention here because they are the ones that conceptualize the interfaces we have all come to know and love. UI/UX (User Interface/User Experience) designers work closely with frontend developers to create user-friendly and visually appealing interfaces.

There are several other options like Embedded Systems Development, Cybersecurity Analyst, Cloud Computing Specialist, Blockchain Developer, Augmented Reality (AR) / Virtual Reality (VR) Developer, Machine Learning/Artificial Intelligence Engineer, Data Science/Analysis and more but for our scope we will leave it at this.

To reiterate, we will be going Fullstack because we are awesome and to this end, we will start with learning Javascript (the only language you can code in fullstack) in the next one.

As always remember we are here to help and stay frosty

Previous post is here

Next post will be here

Getting started in Software development: A Path to a rewarding career (Part 3E, Functional Programming and OOP)

Abdurraheem Abdul-majeed — Sat, 12 Aug 2023 23:43:36 +0000

Hello and welcome

Thanks for stopping by.

Table of Content

Full table of content for the entire series is here

Today, we will continue the following

Getting started (cont'd)
- Learn Programming concepts (cont'd)

Programming Concepts

Today we will round up the section on programming concepts with brief descriptions of Functional Programming and Object-Oriented Programming (OOP).

Fair warning, these concepts are a bit involved so just go through them for the sake of getting introduced to them. Do not be under pressure to understand them completely for now. We are only addressing them here because it is good to have this basic exposure now before we go in deeper in future sessions

Lets goooo!!!

Functional Programming

Functional programming (or FP) is a software development paradigm where functions (Pure functions to be specific) are the building blocks of the computations to be done in the application.

Another aspect to it is that it seeks to avoid concepts of shared state and mutable data. Now lets zoom in to some of the key aspects of FP. Yes, the ones in bold.

Pure functions

They are the basis of functional programming. They are functions like the ones we have addressed in the previous session (used for bundling behaviour to be reused) but with some specific behaviours:

They take input parameters and return an output without modifying any external state or data. So, if your function affects anything outside its scope, it produces a side effect and that makes it impure.

Being an impure function is not a crime but it no longer fits the FP paradigm and you have to watch for the pitfalls that make pure functions desirable. It will only be wrong to have those if FP is what you are aiming for.

Same inputs to pure functions return same outputs all the time. Like a function to add 2 numbers; no matter how many times you try the function with the same parameters, you can be sure the output will be the same.

function add(a,b) {
   return a+b
}

This add function is pure. It does not impact/modify anything else and it will always return the same output given the same inputs.

This behaviour of pure functions makes them easy to work with because they are predictable and easily testable.

Shared state and Data Immutability

In functional programming, once data is created, it is not changed. Instead, new versions or copies are created when required. This reduces the issues that can arise from mutating (changing) data that can lead to side effect which can be hard to track, test and manage in programming.

FP is not as common as it used to be because it was replaced/overtaken by OOP but there are still a few cases where it holds a lot of value and knowing and applying it as much as is convenient in your programming career might come in handy.

Object Oriented Programming

This is a paradigm that organizes your application code into structures called objects.

The way it works is that everything in your code is an object. Whether you are building a social media app, a ride hailing app or a to-do list app, everything is an object. The database connection is an object, the user is an object, authentication is an object etc. Literally everything in the world can be modeled in your application as an object.

Objects are built from Classes and a Class is simply a template or blueprint that defines the properties (attributes/features) and behaviors (methods/abilities) that objects of that class will have.

In the image above, you create a class called Human and from that Human class you can build any number of ‘Human’ objects in your application as needed using that blueprint or template.

Inside the Human class like every other class, you will specify 2 sets of things

Attributes like gender, name, email address, account number and any other attributes that are relevant to your application use case for the Human’s objects.
Methods or function or actions that represent what the Humans in your application can do

Do not make the mistake I made earlier while learning by specifying everything you can think of for a human, only the attributes relevant to the app. If the application does not use the date of birth of the human then it is not relevant. Seems like a given but is worth mentioning.

There are the 4 main concepts in OOP namely Inheritance, Polymorphism, Abstraction and Encapsulation. Do not worry too much what they mean for now, we will go in deeper when we get to the OOP section in our journey

In my opinion, OOP is a super power once you grasp it but it takes some time and effort to truly get it right.

This is it for today and for this section on basic programming concepts.

In the next one, we will get into the real meat of the matter and start writing code.

Until then stay frosty and remember, we are here to help

Previous post is here

Next post is here

Getting started in Software development: A Path to a rewarding career (Part 3D, Functions, Data structures and Debugging)

Abdurraheem Abdul-majeed — Mon, 31 Jul 2023 09:23:37 +0000

Hello and welcome

Thanks for stopping by.

Table of Content

Full table of content for the entire series is here

Today, we will continue the following

Getting started (cont'd)
- Learn Programming concepts (cont'd)

Programming Concepts

Here we are again to serve you more basic programming concepts.

Functions

This is the term used to describe a block of code that performs a specific task or we can say it is a block of code that performs a specific function 😜. They are also sometime called ‘methods’, ‘procedures’, ‘subroutines’ in some programming languages.

We need functions to ensure that the same operation or task can be implemented once in the code and reused as many times as needed instead of re-implementing the same operation everywhere it is needed.

Let us take a function to add 2 numbers:

function add(a,b) {
   return a+b
}

In the function above, we gave it a name of add and passed the 2 numbers we want to add to it as the variables a and b and then we return the result of adding them.

Now anywhere in the code we want to add 2 numbers, we simply call the function to do the job for us instead of reimplementing the addition again.

An example of adding 2 numbers might seem trivial but imagine if you had to take a list of users, call a save function in a database for all of them and send a confirmation email for all of them when done.

The single implementation of this alone is a big task to do. Now imagine having to re do the same logic anytime you have some users who need these operations.

This is where functions shine. Implement logic once and call it everywhere you need it in the code

Do not worry about how the code above works, we are not there yet

Just understand that reusability is a crucial part of application development and functions are one of the tools that help to achieve that. We will do more on functions when we get to demo.

Input/Output (I/O)

This simply describes operations that enable the program to read from and write to the storage of the server.

Sometimes you might want to store a user’s profile image on a server or read an existing image so you can display it on the user’s profile when they log on. I/O operations enable these types of actions. We will take some time to learn some basics about these when we get to demo.

Data structures

This as the name suggests is the structure of data. It is a term used to refer the different way in which data can be structured and stored to enable its efficient use.

Some data structures make it easier and/or more efficient to read data from them than alternatives.

Some data structures make it easier and/or more efficient to add data to them than alternatives.

Some data structures make it easier and/or more efficient to edit data in them than alternatives.

Some data structures make it easier and/or more efficient to delete data from them than alternatives.

There are many data structures in different programming languages but the most common include:

Array / List

This is a list of items of any data type or objects. Some programming languages enforce uniform types for all items while others (like our beloved javascript) allows arrays with items of different data types.
Example:

arrayOfStudentAges = [12,15,12,13,14,13,12]

Object / Map

This is a data structure that provide a collection of key-value pairs that can be used to store information about an object or provide a mapping of information together
Example:

person = {
  name: "John",
  age: 30,
  city: "New York"
};

Set

This data structure is similar to an array but with a condition that all items must be unique in the list

Example:

setOfUniqueStudentAges = [12,13,14,15] // no duplicates

Stack

The stack is like a list except that it enforces Last in First out (LIFO) interactions. This means that any data added to the stack can only be remove after all subsequent items have been removed.

Data can only be added or removed only from the top. Picture a stack of books, or boxes. Ideally, you will remove or destack (yes, its a real word) each item from the top of the stack.

Queue

This is also quite similar to a list except that it enforces First in First out (FIFO) operations.

So like a queue at the mall or at the filling station, first in first out. Items can be added from the back of the queue only and can be removed from the front of the queue only.

There are quite a few more data structures out there like Linkedlists, Trees, Graphs, Heaps and more. We will get to them as we go along because we are here to help

They are however more complex and require more than basic knowledge to implement and understand

Bugs

A bug is anything that does not go right with your code. Bugs are defects or errors in your programs that make them to behave unexpectedly or generate incorrect or unintended results.

Some common types of bugs include:

Syntax Errors

These bugs occur due to code that does not match the syntax rules of the programming language in use. They are typically easier to find and fix using a good IDE. Syntax errors can also be detected by the compiler or interpreter and prevent the code from running since the computer will not understand the language while trying to compile it and so it will throw errors.

Logic Errors

Sometimes, the syntax is correct, but the logic is wrong. In this case the code will run without any syntax errors because the problem is not a syntax one, but it will produce incorrect, unintended or unexpected results due to flaws in the logic or algorithmic mistakes.

For example, if you are writing a function to check if a number is greater than 5 but you use the less than operator in your comparison (because we all do this sometimes), the code will run fine but the function will return the exact opposite of what was intended. Logic Error

Runtime Errors

These bugs occur during program execution and often lead to program crashes or unexpected behaviour if not handled properly. Examples include division by zero, accessing invalid memory locations, or using uninitialized variables.

Debugging

Debugging is the process of finding and fixing these bugs to ensure the program works as intended. It is an essential part of the software development process because no matter how good the developer, we all tend to introduce bugs from time to time.

There involves various techniques and tools to locate and resolve issues effectively.

Print Statements

Inserting print statements at various points in the code to output the values of variables and track the program's flow can be an effective way to understand what's happening during execution.

Debuggers

Debugging tools and integrated development environments (IDEs) provide debuggers that allow developers to set breakpoints, inspect variables, and step through the code line by line to find issues.

Logging

Using logging methods in the programming language (console.log in javascript) to write debug information to the console or to log files can help in tracking the program's execution and resolving issues when they arise.

Unit Testing

Writing unit tests to verify the correctness of individual units (functions, methods) in the code can help catch bugs early in the development process before shipping it off to users.

Code Reviews

Having peers review your code can be valuable in catching errors that you might have missed because 2 heads are better than one.

The typical process of finding and fixing bugs is as follows

First, reproduce the Bug
Isolate the Issue by determining which part of the code is causing the bug (using the techniques above).
Read error messages and stack traces as they are typically good at helping to pinpoint the location and nature of the bug. Some error messages even recommend fixes (what a time to be a developer).

Once the bug is identified, apply the necessary fixes, and thoroughly test the code to ensure that the issue is resolved without introducing new bugs 😅.

Debugging is a skill that improves with experience. It requires patience, attention to detail, and a methodical approach to systematically find and fix bugs in the code. Effective debugging practices lead to more robust and reliable software.

This is it for today. Until next time. Be cool.

Previous post is here

Next post is here

Getting started in Software development: A Path to a rewarding career (Part 3C, Control structures)

Abdurraheem Abdul-majeed — Sat, 22 Jul 2023 21:18:57 +0000

Hello and welcome

Thanks for stopping by yet again.

Table of Content

Full table of content for the entire series is here

Today, we will continue the following

Getting started (cont'd)
- Learn Programming concepts (cont'd)

Programming Concepts

Here again to learn some more basic programming concepts.

Control Structures

Control structures in programming are a fancy name for ways to make decisions, repeat actions, and execute specific blocks of code based on certain conditions being true or false (Boolean).

Say for example you want to display a different message to a person depending on their age or gender, then you can use control structures to execute the code that handles each scenario.

Say you want the same block of code to run multiple times like print from 1 to 10 or continue to display the current time every second then control structures are for you.

We are JavaScript developers here so we will look at some control structures in JavaScript below. For ease of understanding we will broadly categorize them into 2 sub-groups; the Decision Control Structures and the Repetition Control Structures

Decision Control Structures

These are used to decide if to execute some block of code instead of others depending on a given condition and they include:

if...else statement: This allows you to execute different blocks of code based on a given condition. It allows you to say ‘if’ a condition is true then do some code ‘else’ do another thing.

if (someConditionIsTrue) {
  // Code to execute if the condition is true
  // do something in your application
} else {
  // Code to execute if the condition is false
  // do something else in your application
}

It is important to note that any block of code whose condition is not true will not be executed

if (1 + 1 > 3){
  // 1 + 1 > 3 is true
}
else{
  // 1 + 1 > 3 is not true
}

From the example above, we see that the code 1 + 1 > 3 is true will not run because 1 + 1 > 3 will return false.
The code that will run in this case is 1 + 1 > 3 is not true

So the logic of the if else is:
if condition is true, do what is in the block of code in between the curly braces {} and jump to the code after the if…else block.

Otherwise, do what is in the curly braces {} in the else block and then continue

if…else if...else statement: This here is the same as the if else statement, but it gives you the option of checking for multiple conditions instead of just 2

Say you want to do something different on each weekday, you can say

if (today === ‘Monday’){
  // do the Monday thing
}

else if(today === ‘Tuesday’){
  // do the Tuesday thing
}

else if(today === ‘Wednesday’){
  // do the Wednesday thing
}

else if(today === ‘Thursday’){
  // do the Thursday thing
}

else if(today === ‘Friday’){
  // do the Friday thing
}

else{
  // do nothing because it the weekend!!!
}

We can see that we are handling multiple cases in the if and else if blocks and if none of them meet the criteria set then the else block serves as a kind of catch all for any case that is not handled.

The final else block is not required but if it will be used then it must come last in the list

We will take more examples in the weeks to come. This is just to aid basic understanding and so we have a starting point when demos begin because we are here to help.

switch statement: This allows you to pass an expression and then execute a block of code depending on the outcome of that expression.

switch (expression) {

  case value1:
    // Code to execute if expression is equal to value1
    break;
  case value2:
    // Code to execute if expression is equal to value2
    break;
  case value3:
    // Code to execute if expression is equal to value3
    break;

  // Add as many cases as needed

  default:
    // Code to execute if expression does not match any case
}

From the above, we see that what the computer does is dependent on if the expression that was given to the switch block matches any of the cases.

If no case is matched, there is the default block that serves as a catch all.

It is also important to note that the break is needed otherwise the code of the next case will be executed as well. The break is like saying move on to the next line of code outside the switch block so it must come after whatever you want to do for each case.
Example:

switch (dayOfTheWeek) {

  case ‘Monday’:
    // Code to execute if dayOfTheWeek is equal to ‘Monday’
    break;
  case ‘Tuesday’:
    // Code to execute if dayOfTheWeek is equal to ‘Tuesday’
    break;
  case ‘Wednesday’:
    // Code to execute if dayOfTheWeek is equal to ‘Wednesday’
    break;
  case ‘Thursday’:
    // Code to execute if dayOfTheWeek is equal to ‘Thursday’
    break;
  case ‘Friday’:
    // Code to execute if dayOfTheWeek is equal to ‘Friday’
    break;
  default:
    // Code to execute if dayOfTheWeek does not match any weekday 
    // So it may be weekend or some other value not matched above
}

If the condition you want to check for is based on the same unchanging expression like weekday above then switch statement can be a more concise replacement for if…else if…else statement.

Repetition Control Structures

These are used to execute the same block of code repeatedly until a condition is met or not met. They are sometimes referred to as loops because the code is run in a loop until something breaks the loop or ends it. And they are:

while loop: This loop executes a block of code repeatedly as long as the specified condition is true. The syntax is

while (someCondition) {
  // Code to execute repeatedly as long as the someCondition is true
}

So lets say we have an integer or number variable called count and its value is 100. We can write a while loop to do something until the value of count is 0.

count = 100
while(count > 0){
  // do something interesting
  // or just print count
}

This code here will repeat everything in the code block until the value of count is 0.

In the code we have above, the code will run forever because the value of count is 100 and so, every time it runs the code block and then goes back to check again, count > 0 will still be true, so it will run again.

A loop that runs forever is called an infinite loop, it is a loop whose condition can never be false so it will continue to run until you manually stop it or the machine crashes or some other stopping event happens.

Infinite loops should be avoided unless you know what you are doing, and you want the code to keep repeating endlessly.

Since we do not want that here, we need to fix the above code by reducing the value of count in each iteration of the loop like so:

count = 100
while(count > 0){
  // do something interesting
  // or just print count
  count = count – 1
  // or count-- 
  // to reduce the value of count by 1
}

Now, the value of count will be reduced by 1 on each iteration of the loop and once count is no long greater than 0, the loop will break and move on to the next line of code after the loop block.

In the example above, the loop will run 100 times because the counter variable which we named count here is 100 and it is decremented by 1 each iteration.

There is no law that says we must only decrement by 1 so we can decrement by 2 or 5 or 10 in each iteration and the loop will adjust accordingly.

There is also no law that says we must start our counter from 100, it can be anything. We can start from 0 and count upwards and set the condition to be when count is up to a certain value like 1000. We can even use other data types as the ‘counter’. So long as we alter them in the loop until the at some point in the future, the loop ends (if we want it to). The counter is simply the controller of the loop that determines if the loop will break or continue.

do…while loop: Almost the same as the while loop, but the code block is executed at least once before checking the condition. So the instruction is do what is in the code block while a given condition is true. But because you encounter the do block first then the code in it will run at least once before the while condition is checked and then repeated (or not) depending on the condition of the condition. Get it?. No?. Ok moving on. Example:

do {
  // Code to execute at least once then repeatedly 
  // as long as the condition is true
} while (condition);

for loop: This is a more concise way of writing the other loops. It allows you put the counter, condition and the change on each iteration in one line. Syntax is as follows.

for (initialization; condition; change) {
  // Code to execute repeatedly as long as the condition is true
}

let us revisit out while loop from above. It now prints the count and uses the decrement operator to (well) decrement the value of count on each iteration

count = 100
while(count > 0){
  // just print count
  print(count)
  count-- 
  // to reduce the value of count by 1
}

Now let us do the same thing using the for loop.

for (count = 100; count > 0; count--) {
  // just print count
  print(count)
}

The 2 snippets above do the exact same thing but the for loop is more concise and cleaner too if you ask me but then what do I know right.

There are other ways to loop in Javascript like the for…in, for…of and some others that allow looping through certain data structures but we are here to do the basics and we will get into those when we start coding demos.

This is it for today. Stay frosty guys.

Previous post is here

Next post is here

Getting started in Software development: A Path to a rewarding career (Part 3B, Operators)

Abdurraheem Abdul-majeed — Sun, 16 Jul 2023 19:29:49 +0000

Hello and welcome

Thanks for stopping by yet again.

Table of Content

Full table of content for the entire series is here

Today, we will continue the following

Getting started (cont'd)
- Learn Programming concepts (cont'd)

Programming Concepts

Where were we? 💿 🤔 Oh yeah, last time we started learning some basic programming concepts. Let us continue.

Operators

Operators, like in mathematics, allow you to perform some operations on values. For example, in the operation: 1+1, the plus sign ‘+’ is the operator and it lets you add the numbers on its 2 sides. Similarly, in code, operators tell the computer to perform certain operations with the adjoining values.

There are several operators in the typical programming language and Javascript is no different. Here are some of the more common ones you will encounter in the early days of your software development life; fair warning, some of them may look like the ones you already know 😜.

Also, the aim here is to understand how they work on a surface level, we will do a lot of practice with them when the time comes. 😎

Mathematical operators

Mathematical operators are used for mathematical operations like adding, multiplying and so on.

Now before your fear of maths makes you run off, it is enough to know basic arithmetic to understand these concepts so no fear, you gat this.

They are as follows

Addition (+): Adds two values together e.g.: 1+1 will return 2
Subtraction (-): Subtracts one value from another e.g.: 2-1 will return 1
Multiplication (*): Multiplies two values e.g.: 4*5 will return 20
Division (/): Divides one value by another e.g.: 16/2 will return 8
Modulus (%): Returns the remainder of a division operation e.g.: 5%2 will return 1 (because 5/2 will return 2 and a remainder of 1)
Increment (++): Increase the value of a variable by 1 e.g.: if variable a has the value of 1 and we do a++ we will get 2 in return (it is the same as 1+1)
Decrement (--): Decrease the value of a variable by 1 e.g.: if a has the value of 2 and we do a-- we will get 1 in return (it is the same as 2-1)
Exponent or Exponentiation operator (**): Raise the first operand to the power of the second operand e.g.: 2**5 will return 32 (meaning 2 raised to the power of 5 or 2 raised to the 5th power; 2*2*2*2*2)

Assignment Operators

Assignment (=): Assigns a value to a variable. Remember we spoke about assigning a value to a variable in the last post, this is the operator to do that.

If you have a variable called someCoolVariable, in order to assign a value (like the number 5) to that variable, you say

someCoolVariable = 5

Now, in the memory of the computer, there is a storage area (variable) named someCoolVariable and it has the value of 5.

What we did there was assigning the value of 5 to the variable someCoolVariable

To change the value in that memory location or variable to something else (say 22), we simply assign another value to it like so:

someCoolVariable = 22

Now let us say we want to change the value of someCoolVariable to its original value plus 2;

We can say

someCoolVariable =  someCoolVariable + 2

Meaning we take whatever is in the someCoolVariable memory location, we add 2 to it using the addition operator from above;

someCoolVariable + 2

and store/assign the result back to the same location so we say

someCoolVariable =  someCoolVariable + 2

If this is not clear, fear not, we will practice later on, and you will understand it with real examples.

Addition assignment (+=): Adds a value to the variable and assigns the result to the same variable giving it a new value. This is simply a shorter way of doing the following

someCoolVariable =  someCoolVariable + 2

By making it:

someCoolVariable += 2

The 2 lines above do the exact same thing but the second one using the addition assignment is shorter to type

Subtraction assignment (-=): Subtracts a value from the variable and assigns the result to the variable. This is simply a shorter way of doing the following

someCoolVariable =  someCoolVariable - 2

By making it:

someCoolVariable -= 2

The 2 lines above do the exact same thing but the second one using the subtraction assignment is shorter to type

Multiplication assignment (*=): Multiplies the variable by a value and assigns the result to the variable. This is simply a shorter way of doing the following

someCoolVariable =  someCoolVariable * 2

By making it:

someCoolVariable *= 2

The 2 lines above do the exact same thing but the second one using the multiplication assignment is shorter to type

Division assignment (/=): Divides the variable by a value and assigns the result to the variable. This is simply a shorter way of doing the following

someCoolVariable =  someCoolVariable / 2

By making it:

someCoolVariable /= 2

The 2 lines above do the exact same thing but the second one using the division assignment is shorter to type

Modulus assignment (%=): Performs modulus division on the variable and assigns the result to the variable. This is simply a shorter way of doing the following

someCoolVariable =  someCoolVariable % 2

By making it:

someCoolVariable %= 2

The 2 lines above do the exact same thing but the second one using the modulus assignment is shorter to type

Comparison Operators

Equal to (==): Compares two values for equality. This equality (==) operator checks whether its two operands are equal, and returns a Boolean (true or false) result.

Something to note about this is that if it is given 2 operands of different data types like a string and a Boolean or a string and a number, it will attempt to convert the operands to the same type before comparing.

Example:

1 == 1
// read as ‘is 1 equal to 1’ and the answer in Boolean is true
// same data type. Expected output: true

'hello' == 'hello'
// same data type. Expected output: true

'1' ==  1
// different data types, ‘1’ is a string and 1 is a number. Expected output: true
// this is because when converted to a string, 1 is ‘1’ which is equal to the other string 
// and when converted to a number, ‘1’ is 1 which is equal to the other number 

0 == false
// different data types, number and Boolean. Expected output: true
// because when converted to a number, false is 0, equal
// and when converted to a Boolean, 0 is false, equal

Not equal to (!=): Compares two values for inequality, allowing type coercion. This is the reverse of the equal operator, it returns true if the 2 operands are not equal even after type coercion and false when they are equal.

Example:

1 != 1
// read as ‘is 1 not equal to 1’ and the answer in Boolean is false
// same data type. Expected output: false

The ! is the negation operator and it usually just returns the opposite of its operand
So if you have a variable isCool and it is assigned the value of false, !isCool will be true because the ! operator reverses it

Strict equal to (===): Compares two values for equality without type coercion. In this case, unlike == above, the operands will be compared as they are supplied without any type changes

Example:

1 === 1
// read as ‘is 1 strictly equal to 1’ and the answer in Boolean is true
// same data type. Expected output: true

'hello' === 'hello'
// same data type. Expected output: true

'1' ===  1
// different data types, ‘1’ is a string and 1 is a number. Expected output: false 
// this is because there is no type coercion and string ‘1’ is not the exact same strictly speaking as number 1 
// the data type mismatch already makes them unequal so the result is false

0 === false
// different data types, number and Boolean. Expected output: false
// because there is no type coercion 
// the data type mismatch already makes them unequal so the result is false

Strict not equal to (!==): Compares two values for inequality without type coercion. This is the reverse of the strict equal above, it returns true if the 2 operands are not equal with no type coercion and false when they are equal.

Example:

‘1’ !== 1
// read as ‘is ‘1’ not strictly equal to 1’ and the answer in Boolean is true
// different data type means it is true to say they are not equal. Expected output: true

Greater than (>): Checks if one value is greater than another. This is easy enough, returns true only if value on the left is greater than value on the right

Example:

5 > 3
// read as ‘is 5 greater than 3’. Expected result: true

3 > 4
// read as ‘is 3 greater than 4’. Expected result: false

3 > 3
// read as ‘is 3 greater than 3’. Expected result: false
// because 3 is not greater than 3, seriously, its not, I promise you.

Less than (<): Checks if one value is less than another. This is the reverse of the greater than and returns true only if value on the left is less than value on the right

Example:

5 < 3
// read as ‘is 5 less than 3’. Expected result: false

3 < 4
// read as ‘is 3 less than 4’. Expected result: true

3 < 3
// read as ‘is 3 less than 3’. Expected result: false
// because 3 is not less than 3, no seriously, shocking stuff.

Greater than or equal to (>=): Checks if one value is greater than or equal to another. This returns true either if value on the left is greater than value on the right or if they are equal

Example:

5 >= 3
// read as ‘is 5 greater than or equal to 3’. Expected result: true
// because it meets one of the conditions (it is greater than)

3 >= 4
// read as ‘is 3 greater than or equal to 4’. Expected result: false
// because it doesn’t meet any of the conditions (it is not greater than and not equal to)

3 >= 3
// read as ‘is 3 greater than or equal to 3’. Expected result: true
// because it meets one of the conditions (it is not greater than but it is equal to) whew, finally

Less than or equal to (<=): Checks if one value is less than or equal to another. This returns true either if value on the left is less than value on the right or if they are equal

Example:

5 <= 3
// read as ‘is 5 less than or equal to 3’. Expected result: false
// because it doesn’t meet any of the conditions (it is not less than and not equal to)

3 <= 4
// read as ‘is 3 less than or equal to 4’. Expected result: true
// because it meets one of the conditions (it is less than)

3 <= 3
// read as ‘is 3 less than or equal to 3’. Expected result: true
// because it meets one of the conditions (it is not less than but it is equal to) awesome!

There are other operators that we will encounter as we go along but in order not to overwhelm us, we will take a pause here until next time.

Stay frosty guys, leave comments or questions down there because we are here to help

Previous post is here

Next post is here

Getting started in Software development: A Path to a rewarding career (Part 3A, Programming concepts)

Abdurraheem Abdul-majeed — Sun, 09 Jul 2023 18:35:24 +0000

Hello and welcome

Thanks for stopping by again.

Table of Content

Full table of content for the entire series is here

Today, we will address the following

Getting started (cont'd)
- Learn Programming concepts

Programming Concepts

These are the building blocks of the trade. We have touched on some of them during the introduction and definitions phase but here, we will take on the ones that you will need and use on a day-to-day basis as a developer. This is the foundation of your journey and if you get it right here, building on top of it will be a breeze 😜

There are quite a few concepts you will come across in your software development journey and anyone who tells you that they can teach you all of them in one sitting is probably trying to sell you something 😈.

Instead, we will go through the fundamentals, the basics, the ones you cannot escape and must know very well in order to be a decent developer. They are as follows:

Syntax
Algorithm
Pseudocode
IDE (Integrated Development Environment)
Variables
Data types
Operators
Control Structures
- If/Else Statements
- Loops
Functions
Input/Output (I/O)
Data structures
- Arrays and Lists
- Objects and Maps
- Sets
- Stacks
- Queues
Bugs and Debugging
Functional Programming
Object-Oriented Programming (OOP)

If we missed anything in the list above, please mention it in the comments and an edit might be on the cards. Also, we will need to split the explanations into 2 many sessions so this is part 1 of 2 n where n is some number we will determine at the end of this section.

Let us begin

Syntax

Simply put, syntax is programming grammar. The way we have grammar in any language which determines the correct order and arrangement of words and punctuations to convey what you want to say to a person, is the same way there is syntax defining the correct order and arrangement of what you want to ‘say’ to the computer.

Remember that programming is just you, giving the computer instructions, ‘saying’ stuff to the computer, telling it what to do.

For example: if you want to tell a friend to open your bag, bring out your book, place it on the table and open it, there is a proper sequence to doing this, a set of rules to follow and it might look something like this:

Hi Najeebah
Please open my bag
Bring out my book
Place it on the table
Open it

You will not for example start the conversation with ‘place it on the table’ because then Najeebah will probably ask, place what on the table. Syntax error.

You will also not say ‘place the on it table’ or ‘plcae teh on it tblae’ because well that does not make sense and Najeebah will not know what you intend by that. Plus, it is weird to talk that way.
Syntax error.

This is in English and if you were speaking French or Arabic, you will naturally have to adjust to the syntax or grammar of these languages as well. The same applies in code. Each programming language has its own syntax and depending on the language you are speaking (writing your code in), you will need to adjust syntax.

The way you give each command in your code must align with the syntax of the language you are speaking to the computer, just like with human language.

Algorithm

This is the recipe for the task you are looking to do. It is a set of well-defined steps or instructions designed to solve a specific problem or accomplish a particular task.

A good algorithm needs to be at least all the following and maybe more:

Clearly defined and easy to follow
Take zero or more inputs and generate some output or result
Must finish executing at some point (what is the point of a never-ending algorithm if we will never get the result from it)
Must be consistent and predictable in its behaviour
Must be a sequence of steps

There are many ways to represent algorithms such as natural/human language descriptions, pseudocode, flowcharts, or programming code. For now, we will use regular human language

Here is an example of an algorithm that adds two numbers:
1- Take input 1
2- Take input 2
3- Add input 1 and input 2
4- Store result in output
5- Return output

In the above algorithm, we see that there is a clear list of steps, inputs and outputs, it is finite in its execution and every time you run this 'function', the behavior and output can be predicted.

Now let us take a slightly more complex example that builds on the addition example above.

A calculator with the 4 basic operations (Add, Subtract, Multiply, Divide)

Before we do this, we should go back to what we learnt about problem solving and how we need to understand the problem and break it down before we execute.

The problem is to take 2 numbers and an operation and then execute the selected operation on the 2 numbers.

We need to handle all the 4 possible operations. We have an example of one operation above, so we just need to use some sort of decision system to decide what to do in case of each operation

Algorithm:
1- Take input 1 (First number)
2- Take input 2 (Second number)
3- Take input 3 (Operation)
4- If Operation is ‘Add’
5- Add input 1 and input 2
6- Store result in output
7- Return output
8- Else if Operation is ‘Subtract’
9- Subtract input 1 and input 2
10- Store result in output
11- Return output
12- Else if Operation is ‘Multiply’
13- Multiply input 1 and input 2
14- Store result in output
15- Return output
16- Else if Operation is ‘Divide’
17- Divide input 1 and input 2
18- Store result in output
19- Return output

You will notice that the steps in italics are checks to see if the operation input matches a condition and the steps in bold are the ones handling the actual computation depending on which operation was provided as input 3. We will get more into these concepts as we go further but the above is hopefully clear enough.

From these two examples, we can see that algorithms are nothing to be afraid of, just a step by step list of what to tell the computer to do with your code when you eventually write it.

Algorithms come before coding because with algorithms, you can lay out the steps to solve the problem without worrying about syntax since it is in human readable format

After some time, when you get really good in programming, it will no longer be necessary to write out the algorithms for simple tasks like addition or a basic calculator but for more complex tasks, it will always come in handy.

Pseudocode

It is one of the ways of representing algorithms and it is very similar to human language but unlike what we did above with human language algorithms, pseudocode has some code-like syntax. As the name ‘pseudo’ suggests, it is not actual code but resembles it.

For example, the pseudocode for our addition function from above will look something like:

function addition():
    display "Enter the first number:"
    read firstNumber

    display "Enter the second number:"
    read secondNumber

    sum = firstNumber + secondNumber

    display "The sum is: " + sum

In this pseudocode, the program prompts the user to enter the first number and the second number. It then calculates the sum by adding the two numbers together and stores the result in the variable ‘sum’. Finally, it displays the sum to the user as an output.

Remember, pseudocode is not tied to any specific programming language syntax, so you would need to translate this pseudocode into the syntax of the programming language you are using to implement the addition functionality.

It looks a lot like code, it is structured like code, we even gave it a black background like code, but it is not code 😜, still human language but written as Pseudocode.

IDE (Integrated Development Environment)

This is a fancy name for the text editor where you will write your code.

If you want to write an article for people who want to get started in software development like yours truly 😉, any text editor can do the job. Notepad, WordPad, sticky notes, TextEdit (on mac) and others will take in your text and allow you edit it and save but you will agree that none of these options is as productive as using Microsoft word or Google docs to write the article. Why is that? Well, because Word and Docs are designed for that specific task.

When you make a grammar (or syntax) mistake, Word will notify you with the red or blue underline, there are options to manage fonts, spacing, alignment, layouts and so much more right from the apps without much effort.

This is the same idea with IDEs, they are text editors designed to help you with code highlighting, code completion, syntax checking, indentation and so on. Some even help you build, run and deploy your code right from the IDE. It is true to say you can use other text editors like Microsoft word and Notepad for coding for sure, and the code will work if saved in the right format and run in the right way but an IDE is designed to help you with your code and is the right way to go just like with writing articles with Microsoft Word and not notepad.

Some IDEs are dynamic and can be used for several programming languages and some others are built specifically for specific languages. When we get to the coding part of this journey, we will be using VS code (Visual studio code) as our IDE

Variables

These are storage boxes for storing data values in the computer memory. Any task a computer does is largely dependent on data and involves data processing and manipulation. A variable is used to store and manipulate data in a program. It typically has a name and can be assigned a value when it is created. The variable name is like a label on the storage box of the data and the value may or may not change during the execution of the program.

A variable is created using a declaration or keyword that varies across languages. The declaration of a variable typically provides some information and context as to what data type is stored in it and how it can be accessed and manipulated across the application.

Variable names are typically alphanumeric, meaning they contain a-z and 0-9 and some special characters like underscore or the dollar sign.

It is also very important to note that the name you choose for a variable must be descriptive of what that variable is used for. If the variable is ‘user name’, calling it ‘var1’ or ‘un’ or ‘usern’ or ‘uname’ is not the best, and can be misleading for other developers and even you if you return to it after some time. Call it ‘userName’ so everyone knows what it is. The compiler might not complain about bad naming but it is bad nonetheless.

In the example of the pseudocode above, ‘firstNumber’, ‘secondNumber’ and ‘sum’ are examples of variables named properly.

Data types

Profoundly enough, this simply refers to the types of data. A little on the nose I know but that’s just how it is.

The most common ones (especially in JavaScript) are as follows:

String: used to represent a ‘string’ of characters like a company’s name, a car’s plate number, a story, a phone number and the likes
Boolean (true or false): used to represent a Yes or No situation and can only be either ‘true’ or ‘false’. No grey areas, it either is or isn’t
Number: used to represent integers like 1, 50, 994 and floating-point numbers (decimal-base) like 75.2222, 3.14142142142, 322.435 and so on
Array: used to represent a collection or list of data like the grade of everyone in a class or the salary of all employees in HR department

You may be thinking this surely will not be enough to represent every possible data in the world, like if you wanted to represent a person or a house or a fish as data in an application, you will need something more complex than these.

If you are thinking that then you are right, there are more complex data types. These here are the basics, and the more complex types can be created using the basics as building blocks.

Some programming languages have some more complex data types inbuilt and many of the mainstream programming languages allow you to build your own data types using other methods like object-oriented programming (OOP) which we will get into later.

We will stop here for this session so we are not overwhelmed.

The remaining concepts will be explained in the next one.

Until then, stay frosty and remember. We are here to help

Previous post is here

Next post is here

Getting started in Software development: A Path to a rewarding career (Part 2, Problem solving)

Abdurraheem Abdul-majeed — Sat, 01 Jul 2023 20:43:43 +0000

Hello and welcome

Thanks for stopping by again.

Table of Content

Full table of content for the entire series is here

For today though we will address the following

Getting started
- Learn problem solving as an idea

Getting started

Now that the intro, plan and basic definitions are cleared up and understood, it is time to get started for real by learning problem solving as an idea or a process. We will try to go through everything at a steady pace to ease understanding. This is especially important because subsequent sessions will rely on some of what is covered previously.

Learn problem solving as an idea

Simply put, this involves learning how to solve problems and while that is quite obvious, it is necessary to go deeper into it,
understand it and internalize it.

A problem in this context can be described as a challenge or task or process you are looking to develop software for.

Learning problem-solving skills is as crucial in software development as it is in everyday life and below, we will go through some practical steps to solve almost any problem because as usual, we are here to help 😁

Understand the Problem

This is arguably the most important step in problem solving. You want to know the problem, embrace the problem, visualize the problem, become one with the problem, get into the problem, appreciate the problem, the problem is the enemy and as Sun Tzu said; ‘Know thy enemy’.

I cannot tell you how many lines of code in my experience have gone to waste because of misunderstood problems.

Read and analyse the problem carefully as many times as necessary. Put a good amount of thinking into understanding it. You want to ensure you have a clear understanding of what needs to be solved because knowing the problem well will help you properly identify the requirements, constraints, the what, the why and so on of the problem.

The better you know the problem, the better your chances of solving the problem properly. The quality of your solution is a direct factor of your knowledge and understanding of the problem. It is just that important. Understand. The. Problem.

Break Down the Problem

Here, after you have become one with the problem and you have a strong grasp of what needs to be done, you want to break down the problem into smaller more manageable chunks.

Any problem, no matter how complex, is just a lot of smaller problems in one, and if the smaller problems of the initial problem are still too complex, then break them into smaller problems still and the cycle continues until all you have are simple problems that cannot be broken down further.

A sky scrapper is a grand structure but once broken down, it is just a lot of single buildings stacked upon each other.

A building is still imposing in its own way but once broken down is just a lot of bricks arranged in a certain way.

A brick, well that is not nearly as scary as a sky scrapper

Using the example above, if you take the problem as a sky scrapper, it will be overwhelming but if it is broken down to mere bricks then things will not look so scary anymore.

One of these folks that say wise things once said, “A big problem is just a problem that has not been broken down properly”.
Another one is “if you find the problem to be too complex, seek first to break it down further”
Break. Things. Down

Plan and Execute

So, you now understand the problem and you have broken it down into manageable chunks after a lot of thinking, time to plan how you will solve the problem.

Devise a strategy to solve the problems in their manageable form. What tools can you use, what algorithms can you use, how will it all flow together etc. This will give your execution some structure so that your efforts are not scattered or wasted.

Sometimes, while planning, you will realize you do not fully understand the problem or did not break things down well enough. If this ever happens, you are not alone, these first three steps are usually a cycle in my experience. No worries at all, this is quite normal, all you have to do is go back and break things down further. If you do not run into that then great job, you are ready to execute.

Implement the plan you have put together and while doing this, if you find that you missed something, go back to the understanding or breaking down phase and clear things up then proceed as before.
Think. Plan. Execute

Test and evaluate

Once you have executed the plan, the job is almost done. Next you need to check your output for correctness. You need to test what you have built to see if it works and if it works as it was intended. Does it do what you set out to achieve.

Is the problem solved, is it solved well, does it meet the requirements, are there edge cases where your solution might struggle, in the case of a user solution; are the user defined metrics and standards met. Basically, did you get the job done? Check. Check. Check

Review and Take lessons

A common mistake with getting the job done is the assumption that it is great and that’s it, but almost always, there are lessons to be learnt against next time.

Go back and take a look at your solutions to see what could have been done better, faster, with less resources, more efficiently and what can be added to a library somewhere as part of a knowledge base to help improve yourself and others in the future.

Review your solution and reflect on the problem-solving process, consider alternative approaches or optimizations that could improve your solution, learn from your mistakes and analyse how you can avoid similar pitfalls in the future.

Take on the next problem and repeat

A simple fact of life is that problem-solving skills are developed through practice and experience. Engaging in problem-solving activities regularly will help enhance your skills. Solve as many problems as you can from different domains in different contexts to get your brain attuned to the problem-solving process as well as actually solving problems.

Do not be afraid to take on new challenges with increasingly complex or unfamiliar problems because that is how you will grow (trust me I know this much).

Seek guidance from resources around (like this article 😁) and collaborate with others and seek mentorship so you can glean experience from others and grow as a result.
As usual, we are here to help

Consult resources like books, tutorials, or online platforms (like this series 😁) that offer problem-solving tools and tips.

Participate in competitions, hackathons, or collaborative projects to solve problems collectively whenever you can. This is especially useful as you will need to collaborate with one or more teams when you get into the software development industry.

To conclude

It is very important to note that problem-solving can be challenging and require perseverance. Embrace the process of learning and view obstacles and failings as opportunities for growth.

Stay positive, patient, and persistent in your problem-solving journey and remember that problem-solving skills are developed through practice and experience. As you tackle a wide range of problems and apply different strategies, you will become more proficient in understanding problems, analysing, planning, and executing solutions effectively. 💪💪💪

Until next time. Cheers

Previous post is here

Next post is here

Getting started in Software development: A Path to a rewarding career (Part 1)

Abdurraheem Abdul-majeed — Sat, 24 Jun 2023 20:15:49 +0000

Introduction

Software development offers exciting and interesting opportunities for those seeking a dynamic, value driven and rewarding career. Regardless of who you are, where you are, what your situation in life is or what stage you are in your career; be it a recent graduate, long term veteran in other fields, a career changer, a new mom, a not so new mom or simply someone passionate/curious about learning it, software development is an option for you. This fact alone among others makes it appealing to nearly everyone.

As dynamic and all welcoming as it is, however, diving into the vast realm of software development or application development as some will call it can be overwhelming, especially for beginners. Fear not though! In the words of Tony Stark’s iron legion: “We are here to help”.

In this series, we will provide you with a comprehensive guide on how to commence the adventure, equipping you with step-by-step guides, essential tips, pitfalls to avoid, demos and insights to embark on a successful journey in this exciting field.

You are most welcome!

Table of Content

This table of content will guide the entire series, but the sections handled in each post will be emboldened as below

Introduction (up there)
Definitions: Helping you know what some concepts mean and how they fit together
What you will need to get started and clarifying expectations
Getting started
- Learn problem solving as an idea
- Learn Programming concepts
- Decide which route you want to take (web, desktop, mobile, game, data, frontend, backend, Fullstack etc. We will be selecting Fullstack web development)
- Learn a programming language (preferably one that can be used for what you choose in the step above. We will use JavaScript)
- Learn industry leading frameworks (because most programming languages are better as frameworks where all the heavy lifting is done and most roles will require one or more of them)
- Build stuff (We will build and deploy a ‘water ordering ecommerce system’ end to end)
- Learn more and build more
- Create a portfolio to showcase your work and skills
How to seek employment and get hired and do well for your self
- Keep learning and building and doing well for yourself in an endless loop.
- Interview Prep and Ideas
Key concepts to know as a developer
- Data structures and algorithms
- Principles (SOLID, DRY, YAGNI, KISS, MVC, MVVM, MVT)
- Design Patterns

Now to begin with definitions

First, we will define terms you will encounter as we go along. Do not memorize the meanings but instead understand them, read each meaning as many times as you need to and link it to your own world experience to help you understand what each term means in the practical sense.

Software: in simple terms, software is an application on a computer that performs tasks, any application, seriously, all applications are software. Your:

Browser (google chrome, firefox etc) is a software,
Microsoft word, powerpoint, excel etc is software,
Whatsapp, facebook, twitter, Instagram are software,
Video games are software
Point of sale (POS) machine uses software
ATM machine uses software
VLC player, software
Canva, photoshop, figma…. software
Spotify, Netflix, Prime Video… software

I think you get the idea. Everything that performs some tasks on a computer is software.

Software development: this is, well, the development of software and all the practices it entails. Some of these practices include writing code or programming, testing, debugging, deploying. There are other aspects like system analysis and design, UI/UX and the likes but for simplicity let us leave it at that.

Also, you should know that software development is quite broad and has different areas, such as web development, mobile app development, data science, or game development. Each domain offers its own set of tools, frameworks, and challenges and we will get into all of that in time

Software developer/Programmer: me and you who write build/develop the software. Once you build software, you are automatically added to an elite guild/Cabal of awesome folks: The Software Developers

Inserts dramatic sounds

Code: this is a set of instructions you write as a software developer and give to the computer in a language it understands (Programming language) to perform the tasks the software is for. Think of it like a recipe. A recipe is a set of steps or instructions which a person should follow to prepare a meal and a typical recipe contains ingredients and all of what is required to prepare a meal. Code is basically you the developer giving the computer a recipe to tell it how to prepare a software.

Programming: this is the act of writing code in a specific language the computer understands

Programming language: is a language the computer understands. Language here is the same as in human context so, same way we have English, Arabic, French and Yoruba. The computer has many languages it understands or can be taught to understand (kind of like us humans too) like C, C++, C#, Python, Java, JavaScript, PHP, Rust, Go, and the list goes on

What you need to get started

A computer system: Because we are building applications to be run on a computer system, you will need one to write the code, to test the code and to host the application locally to see if it works before you move it to a server (which interestingly is also another computer, more details on that later)
Internet connection: many of the tools you will need will need to be downloaded from the internet, and in case you run into issues not covered here, you will need the internet to help you with possible solutions
These articles 😁 : because well, we are here to help
Commitment and Patience: In the words of one of these guys who say wise stuff; ‘You only loose when you give up’. If you are committed and patient with yourself in the learning process, then it will be worth it in the end. At times, you might feel overwhelmed or out of place, that is not a sign to quit but a sign to take a break and give it another shot in a bit. No pressure to get it at the first try, very few people do. ‘If at first you do not succeed then try and try again’. 💪

Expectations

Even though we will go into a lot of detail, this remains a getting started series and as such will not be all you need to succeed as a developer. If you follow the series diligently, at the end, you will be ready for a junior-mid level role in a typical organization.

If we still have you eyes and ears at this point then great job, great start, and see you in the next one where we will actually get started 💯 🎉

Next link is here.

Cheers