This tutorial will serve as your introductory guide to TypeScript. It's designed to cater to learners at all stages – from beginners to advanced users. It teaches both fundamental and advanced TypeScript concepts, making it a helpful resource for anyone looking to delve into TypeScript.

The aim of this guide is not to be an exhaustive resource, but rather a concise and handy reference. It distills the essence of TypeScript into a digestible format.

Whether you're a novice just starting out, an intermediate learner aiming to consolidate your knowledge, or an advanced user in need of a quick refresher, this guide is crafted to meet your TypeScript learning requirements.

After carefully reading through this tutorial and practicing the examples it contains, you should have the skills to build robust, scalable, and maintainable TypeScript applications. We'll cover key TypeScript concepts like types, functions, classes, interfaces, generics, and more.

Table of Contents

• Prerequisites

• Who is this guide for?

• TypeScript vs. JavaScript

• Advantages of TypeScript

• Code Generation

• Installation

• Configuration

• Understanding tsconfig.json

• TypeScript Basics

• Type Declarations and Variables in TypeScript

• Functions in TypeScript

• Classes and Objects in TypeScript

• Interfaces in TypeScript

• Enums in TypeScript

• Generics in TypeScript

Prerequisites

Before you begin going through this guide, you should have a basic understanding of JavaScript. Familiarity with object-oriented programming concepts like classes, interfaces, and inheritance is also recommended.

But if you're new to these concepts, don't worry - we'll cover them in detail in this guide.

Who is this Guide For?

This guide is for anyone looking to learn TypeScript. Whether you're a beginner, an intermediate learner, or an advanced user, this guide is designed to meet your TypeScript learning needs.

It's also a handy reference for anyone looking to brush up on their TypeScript skills.

TypeScript vs JavaScript

TypeScript is a statically-typed superset of JavaScript, designed to enhance the development of large-scale applications.

It introduces optional static typing, classes, and interfaces to JavaScript, drawing parallels with languages like C# and Java. TypeScript code is transpiled to plain JavaScript, ensuring compatibility across various JavaScript environments.

While TypeScript and JavaScript can operate in the same environment, they exhibit key differences. The main one is that TypeScript is statically typed, providing type safety, while JavaScript is dynamically typed.

Let's delve into some of these differences:

TypeScript code is written in .ts or .tsx files, whereas JavaScript code resides in .js or .jsx files. The .tsx and .jsx extensions indicate that the file may contain JSX syntax, a popular choice for UI development in libraries like React.

Let's explore the differences between JavaScript and TypeScript through an example:

// JavaScript
function add(a, b) {
  return a + b;
}

// Calling the function
add(1, 2); // Returns: 3

In the JavaScript example above, the add function takes two parameters, a and b, and returns their sum. The function is invoked with the arguments 1 and 2, yielding 3. Notice that the function parameters are not annotated with types, which is typical in JavaScript.

Now, let's see how we can write the same function in TypeScript:

// TypeScript
function add(a: number, b: number): number {
  return a + b;
}

// Calling the function
add(1, 2); // Returns: 3

In the TypeScript version, we've annotated the parameters a and b with the number type. We've also specified that the function returns a number.

This is a key difference between JavaScript and TypeScript. TypeScript enforces type safety, meaning it checks the types of values at compile time and throws errors if they don't match the expected types.

This feature helps catch errors early in the development process, making TypeScript a popular choice for large-scale applications.

TypeScript and JavaScript are both powerful languages used in a wide range of applications. Let's summarize their key differences:

Advantages of TypeScript

TypeScript offers several advantages over JavaScript:

2. Improved Tooling: TypeScript's static typing enables better tooling support. Features like autocompletion, type inference, and type checking make the development process more efficient and enjoyable.

3. Better Documentation: TypeScript codebases are often easier to understand and maintain. The type annotations serve as implicit documentation, making it easier to understand what kind of values a function expects and returns.

4. Advanced Features: TypeScript supports advanced JavaScript features such as decorators and async/await, and it also introduces features not available in JavaScript, such as interfaces, enums, and tuples.

5. Refactoring: TypeScript's tooling makes refactoring larger codebases safer and more predictable. You can make large-scale changes with confidence.

6. Gradual Adoption: TypeScript is a superset of JavaScript, which means you can gradually adopt TypeScript in your projects. You can start by renaming your .js files to .ts and then you can gradually add type annotations as you see fit.

7. Community and Ecosystem: TypeScript has a growing community and ecosystem. Many popular JavaScript libraries, such as React and Angular, have TypeScript definitions, which makes it easier to use them in a TypeScript project.

Code Generation

TypeScript code isn't natively understood by browsers or Node.js, so it needs to be transpiled into JavaScript. This transpilation process is handled by the TypeScript compiler (tsc), which reads TypeScript code and generates equivalent JavaScript code.

To transpile a TypeScript file, you can use the tsc command followed by the filename:

$ tsc index.ts

This command transpiles the index.ts file into a index.js file in the same directory. The resulting JavaScript code can be executed in any JavaScript environment, such as a browser or Node.js.

Watching for File Changes

During active development, it's beneficial to have your TypeScript code automatically recompiled whenever you make changes. The TypeScript compiler provides a --watch option for this purpose:

$ tsc index.ts --watch

With this command, the compiler will monitor the index.ts file and automatically recompile it whenever it detects a change.

Configuring the TypeScript Compiler

For larger projects, it's common to have a configuration file, tsconfig.json, to manage compiler options. This file allows you to specify the root level files and the compiler options required to compile the project.

Here's an example of a tsconfig.json file:

{
  "compilerOptions": {
    "target": "es5",
    "module": "commonjs",
    "strict": true,
    "outDir": "./dist"
  },
  "include": ["src/**/*.ts"],
  "exclude": ["node_modules"]
}

In this configuration, the compilerOptions object contains options for the compiler. The target option specifies the ECMAScript target version, the module option sets the module system, the strict option enables a wide range of type checking behavior, and the outDir option specifies the output directory for the compiled JavaScript files.

The include and exclude options are used to specify the files to be compiled and ignored, respectively.

To compile the project based on the tsconfig.json file, you can run the tsc command without any arguments:

$ tsc

This command will compile all TypeScript files in the project according to the options specified in the tsconfig.json file.

TypeScript Basics

In this section , we'll go through the basics of TypeScript. You'll see more examples of how TypeScript is statically typed, and you'll learn more about its tooling and error checking.

Installation

Before we dive into TypeScript, you'll need to make sure that you have Node.js installed on your system. Node.js is a runtime environment that allows you to run JavaScript outside of the browser. You can download Node.js from the official website.

Once Node.js is installed, you can install TypeScript using the Node Package Manager (npm), which comes bundled with Node.js.

Open your terminal and run the following command:

npm install -g typescript

This command installs TypeScript globally on your system. You can confirm the installation by running the tsc command, which stands for TypeScript compiler:

tsc --version

This command should display the version of TypeScript that you've installed.

Now that TypeScript is installed, we're ready to start our journey into the world of TypeScript!

Configuration

Great! Now that we have TypeScript installed, let's talk about something else important: configuration. For larger projects, it's common to have a configuration file, tsconfig.json, to manage compiler options. This file allows you to specify the root level files and the compiler options required to compile the project.

When you run the tsc command, the compiler looks for a tsconfig.json file in the current directory. If it finds one, it uses the options specified in the file to compile the project. If it doesn't find one, it uses the default options.

To generate a tsconfig.json file, you can run the following command:

tsc --init

Understanding tsconfig.json

Now that we have TypeScript installed and configured, let's dive deeper into the tsconfig.json file. This file is a crucial part of any TypeScript project. It holds various settings that determine how your TypeScript code gets compiled into JavaScript.

To create a tsconfig.json file, you can use the tsc --init command as I showed above. This command generates a tsconfig.json file in your current directory with some default settings.

Here's an example of what a tsconfig.json file might look like:

{
 "compilerOptions": {
    "target": "es5",
    "module": "commonjs",
    "strict": true,
    "outDir": "./dist"
 },
 "include": ["src/**/*.ts"],
 "exclude": ["node_modules"]
}

In this configuration:

• The compilerOptions object contains settings for the TypeScript compiler.

• The target option tells the compiler which version of ECMAScript to compile your code down to.

• The module option sets the module system for your project.

• The strict option enables a wide range of type checking behavior.

• The outDir option specifies the directory where the compiled JavaScript files will be placed.

• The include and exclude options tell the compiler which files to include and exclude during the compilation process.

After setting up your tsconfig.json file, you can compile your TypeScript project by simply running the tsc command in your terminal. This command will compile all TypeScript files in your project according to the options specified in your tsconfig.json file.

Type Declarations and Variables in TypeScript

Let's now learn more about types. TypeScript supports several types, including number, string, boolean, object, null, undefined, symbol, bigint, and any. Let's explore each of these types in detail.

1. number: This type is used for numeric values. It can be an integer or floating-point value.

Example:

let age: number = 30;
let weight: number = 65.5;

2. string: This type is used for textual data. It can be defined using single quotes, double quotes, or template literals.

Example:

let name: string = 'John Doe';
let greeting: string = `Hello, ${name}`;

3. boolean: This type is used for logical values. It can only be true or false.

Example:

let isAdult: boolean = true;
let isStudent: boolean = false;

4. object: This type is used for complex data structures. An object can have properties and methods.

Example:

let person: object = { name: 'John Doe', age: 30 };
let date: object = new Date();

5. null: This type has only one value: null. It is used when you want to explicitly set a variable to have no value or object.

Example:

let emptyValue: null = null;
let anotherEmptyValue: null = null;

6. undefined: This type has only one value: undefined. It is used when a variable has been declared but has not yet been assigned a value.

Example:

let unassignedValue: undefined = undefined;
let anotherUnassignedValue: undefined;

7. symbol: This type is used to create unique identifiers for objects.

Example:

let symbol1: symbol = Symbol('symbol1');
let symbol2: symbol = Symbol('symbol2');

8. bigint: This type is used for whole numbers larger than 2^53 - 1, which is the upper limit for the number type.

Example:

let bigNumber: bigint = 9007199254740993n;
let anotherBigNumber: bigint = BigInt(9007199254740993);

9. any: This type is used when the type of a variable could be anything. It is a way of opting out of type-checking.

Example:

let variable: any = 'I am a string';
variable = 42; // I am a number now

Now let talk about some different ways you can declare variables in TypeScript.

TypeScript provides a way to define the shape of an object, including its properties and methods, using type declarations. This allows you to create reusable types that can be used to define the structure of objects throughout your codebase.

1. Type Aliases: Type aliases are a way to create a new name for an existing type. They are often used to define complex types that are used in multiple places.

Example:

type Point = {
  x: number;
  y: number;
}

let origin: Point = { x: 0, y: 0 };

In this example, Point is a type alias for an object with x and y properties. It is used to define the type of the origin object.

2. Intersection Types: Intersection types are a way to combine multiple types into a single type. They are often used to create complex types that have the properties of multiple other types.

Example:

type Printable = {
  print: () => void;
};

type Loggable = {
  log: () => void;
};

type Logger = Printable & Loggable;

let logger: Logger = {
  print: () => console.log('Printing...'),
  log: () => console.log('Logging...'),
};

In this example, Printable and Loggable are two types that have a print and log method, respectively. The Logger type is an intersection of Printable and Loggable, so it has both a print and log method.

3. Union Types: Union types are a way to define a type that can be one of several different types. They are often used to create flexible types that can represent a variety of values.

Example:

type ID = string | number;

let id: ID = '123';
id = 123;

In this example, ID is a union type that can be either a string or a number. It is used to define the type of the id variable, which can be assigned a string or a number.

4. Type Assertions: Type assertions are a way to tell the TypeScript compiler that you know more about the type of a value than it does. They are similar to type casting in other languages.

Example:

let value: any = 'Hello, TypeScript!';
let length: number = (value as string).length;

In this example, the as keyword is used to assert that value is of type string. This allows us to access the length property of the string.

Functions in TypeScript

Functions are the building blocks of any programming language. They encapsulate logic into reusable units of code, promoting code reuse and modularity. In TypeScript, functions can be defined using the function keyword or arrow functions (=>). Both methods have their own use cases and characteristics.

Let's talk about some types of functions in TypeScript:

1. Function Declarations: Functions can be declared using the function keyword followed by a unique function name. The function body is enclosed in curly braces {}.

Example:

function greet(name: string): void {
  console.log(`Hello, ${name}!`);
}

greet('Alice');  // Outputs: Hello, Alice!

In this example, greet is a function that takes one parameter, name, of type string. The function doesn't return anything, so its return type is void.

2. Arrow Functions: Arrow functions are a more modern syntax for writing functions in TypeScript and JavaScript. They are especially useful when writing small, inline functions.

Example:

const greet = (name: string): void => {
  console.log(`Hello, ${name}!`);
}

greet('Bob');  // Outputs: Hello, Bob!

In this example, greet is an arrow function that behaves exactly the same as the greet function in the previous example. The => symbol separates the function parameters and the function body.

3. Function Types: In TypeScript, you can specify the types of the parameters and the return value of a function. This provides type safety, ensuring that the function is called with the correct types of arguments and that it returns the correct type of value.

Example:

function add(a: number, b: number): number {
  return a + b;
}

let sum: number = add(1, 2);  // sum is 3

In this example, the add function takes two parameters, a and b, both of type number, and returns a number.

4. Optional and Default Parameters: TypeScript allows function parameters to be optional or have default values.

Example:

function greet(name: string, greeting: string = 'Hello'): void {
  console.log(`${greeting}, ${name}!`);
}

greet('Charlie');  // Outputs: Hello, Charlie!
greet('Charlie', 'Hi');  // Outputs: Hi, Charlie!

In this example, the greet function has two parameters, name and greeting. The greeting parameter is optional and has a default value of 'Hello'.

5. Rest Parameters: TypeScript supports rest parameters, which allow you to pass an arbitrary number of arguments to a function.

Example:

function sum(...numbers: number[]): number {
  return numbers.reduce((a, b) => a + b, 0);
}

let total: number = sum(1, 2, 3, 4, 5); // total is 15

In this example, the sum function takes an arbitrary number of arguments and returns their sum.

Classes and Objects in TypeScript

Classes are a fundamental part of object-oriented programming (OOP). They are templates for creating objects, providing initial values for state (member variables) and implementations of behavior (member functions or methods).

TypeScript supports classes, which are declared using the class keyword. One advantage of TypeScript classes is that they support object-oriented programming (OOP) features such as inheritance, encapsulation, and polymorphism.

1. Class Declaration: In TypeScript, classes are declared using the class keyword.

Example:

class Person {
  name: string;
  age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  greet(): void {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

let john = new Person('John', 25);
john.greet(); // Outputs: Hello, my name is John and I am 25 years old.

In this example, Person is a class with two properties, name and age, and a method greet. The constructor is a special method for creating and initializing an object created with a class.

2. Inheritance: TypeScript supports inheritance, a mechanism of basing a class upon another class, retaining similar implementation. Inheritance is achieved using the extends keyword.

Example:

class Employee extends Person {
  department: string;

  constructor(name: string, age: number, department: string) {
    super(name, age);
    this.department = department;
  }

  greet(): void {
    super.greet();
    console.log(`I work in ${this.department}.`);
  }
}

let jane = new Employee('Jane', 30, 'HR');
jane.greet(); // Outputs: Hello, my name is Jane and I am 30 years old. I work in HR.

In this example, Employee is a class that extends Person. It adds a new property department and overrides the greet method. The super keyword is used to call corresponding methods of the parent class.

3. Abstract Classes: Abstract classes are classes that cannot be instantiated directly. They are used as base classes for other classes and can contain abstract methods that must be implemented by derived classes.

Example:

abstract class Shape {
  abstract area(): number;
}

class Circle extends Shape {
  radius: number;

  constructor(radius: number) {
    super();
    this.radius = radius;
  }

  area(): number {
    return Math.PI * this.radius ** 2;
  }
}

let circle = new Circle(5);
console.log(circle.area()); // Outputs: 78.54

In this example, Shape is an abstract class with an abstract method area. The Circle class extends Shape and implements the area method. Abstract classes are useful for defining a common interface for a set of classes.

4. Encapsulation: Encapsulation is the bundling of data (properties) and methods that operate on the data (methods) into a single unit called a class. In TypeScript, encapsulation is achieved by using access modifiers such as public, private, and protected.

Example:

class Person {
  private name: string;
  protected age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  greet(): void {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

let john = new Person("John", 25);
console.log(john.name); // Error: Property "name" is private
console.log(john.age);  // Error: Property "age" is protected

In this example, name is a private property of the Person class, so it cannot be accessed from outside the class. age is a protected property, so it can be accessed from subclasses but not from outside the class.

5. Polymorphism: Polymorphism is the ability of an object to take on many forms. In TypeScript, polymorphism is achieved through method overriding, where a method in a subclass has the same name and signature as a method in its superclass.

Example:

class Animal {
  speak(): void {
    console.log('Animal makes a sound');
  }
}

class Dog extends Animal {
  speak(): void {
    console.log('Dog barks');
  }
}

let animal: Animal = new Dog();
animal.speak(); // Outputs: Dog barks

In this example, Animal is a base class with a speak method. Dog is a subclass that overrides the speak method. When an instance of Dog is assigned to a variable of type Animal, the speak method of Dog is called.

6. Access Modifiers: TypeScript supports the access modifiers public, private, and protected. By default, each member is public.

Example:

class Animal {
  private name: string;

  constructor(name: string) {
    this.name = name;
  }

  public getName(): string {
    return this.name;
  }
}

let dog = new Animal('Dog');
console.log(dog.getName()); // Outputs: Dog

In this example, name is a private member of the Animal class. It can only be accessed within the Animal class. The getName method is public, so it can be called from outside the class.

Interfaces in TypeScript

Interfaces in TypeScript are powerful ways to define contracts within your code. They are used to type-check whether an object fits a certain structure.

By defining an interface we can name a specific combination of variables, making sure they will always be used as a set.

1. Interface Declaration: Interfaces are declared with the interface keyword.

Example:

interface Person {
  name: string;
  age: number;
}

let john: Person = { name: 'John', age: 25 };

In this example, Person is an interface that describes an object that has a name of type string and an age of type number.

2. Optional Properties: Interface properties can be marked as optional with ?.

Example:

interface Person {
  name: string;
  age?: number;
}

let alice: Person = { name: 'Alice' };

In this example, age is an optional property in the Person interface. The object alice is still a Person even though it doesn't have an age.

3. Function Types: Interfaces can also describe function types.

Example:

interface GreetFunction {
  (name: string, age: number): string;
}

let greet: GreetFunction = function(name: string, age: number): string {
  return `Hello, my name is ${name} and I am ${age} years old.`;
};

In this example, GreetFunction is an interface that describes a function that takes a name and an age and returns a string.

4. Extending Interfaces: Interfaces can extend one another, creating a new interface that inherits the members of the base interface.

Example:

interface Animal {
  name: string;
}

interface Dog extends Animal {
  breed: string;
}

let myDog: Dog = { name: 'Rex', breed: 'German Shepherd' };

In this example, Dog extends Animal, so a Dog has both a name and a breed.

Enums in TypeScript

Enums are a way to define a set of named constants. They are often used to represent a set of related values, such as the days of the week or the months of the year.

TypeScript supports both numeric and string enums, providing a flexible way to define and work with sets of constants.

1. Numeric Enums: Numeric enums are a way to define a set of named constants with numeric values. By default, the values of the constants start at 0 and increment by 1 for each subsequent constant.

Example:

enum Day {
  Sunday,
  Monday,
  Tuesday,
  Wednesday,
  Thursday,
  Friday,
  Saturday
}

let today: Day = Day.Monday;

In this example, Day is a numeric enum that represents the days of the week. The constants Sunday, Monday, Tuesday, and so on are assigned numeric values starting from 0.

2. String Enums: String enums are a way to define a set of named constants with string values. Unlike numeric enums, the values of the constants in a string enum are initialized with the value of the constant name.

Example:

enum Month {
  January = 'January',
  February = 'February',
  March = 'March',
  April = 'April',
  May = 'May',
  June = 'June',
  July = 'July',
  August = 'August',
  September = 'September',
  October = 'October',
  November = 'November',
  December = 'December'
}

let currentMonth: Month = Month.June;

In this example, Month is a string enum that represents the months of the year. The constants January, February, March, and so on are assigned string values equal to their names.

3. Computed Enums: Enums can have computed values, which are initialized with an expression instead of a constant value. This allows for more flexibility in defining the values of the constants.

Example:

enum Color {
  Red = 1,
  Green = Math.pow(2, 2),
  Blue = Math.pow(2, 3)
}

let color: Color = Color.Green;

In this example, Color is an enum with computed values. The constants Red, Green, and Blue are assigned the values 1, 4, and 8, respectively, using the Math.pow function.

4. Reverse Mapping: Enums in TypeScript support reverse mapping, which means that you can access the name of a constant from its value. This is useful for debugging and logging purposes.

Example:

enum Day {
  Sunday,
  Monday,
  Tuesday,
  Wednesday,
  Thursday,
  Friday,
  Saturday
}

let dayName: string = Day[1]; // 'Monday'

In this example, the Day enum is used to access the name

Generics in TypeScript

Generics are a way to define a function or class that can be used with different types of data. They are often used to create reusable components that can work with different types of data.

TypeScript supports generics, allowing you to write type-safe code that is flexible and reusable.

Now let's look at some examples of generic functions and classes.

1. Generic Functions: Generic functions are functions that can work with a variety of data types. They are defined using type parameters, which are placeholders for the actual types that will be used when the function is called.

Example:

function identity<T>(value: T): T {
  return value;
}

let result1: number = identity<number>(42);
let result2: string = identity<string>('Hello, TypeScript!');

In this example, identity is a generic function that takes a type parameter T and returns a value of type T. The type parameter T is used to specify the type of the argument and the return value.

2. Generic Classes: Generic classes are classes that can work with a variety of data types. They are defined using type parameters, which are placeholders for the actual types that will be used when the class is instantiated.

Example:

class Box<T> {
  value: T;

  constructor(value: T) {
    this.value = value;
  }
}

let box1: Box<number> = new Box<number>(42);
let box2: Box<string> = new Box<string>('Hello, TypeScript!');

In this example, Box is a generic class that takes a type parameter T and has a property value of type T. The type parameter T is used to specify the type of the value stored in the box.

3. Generic Constraints: Generic constraints are a way to restrict the types that can be used with a generic function or class. They are defined using the extends keyword, followed by the type or interface that the type parameter must extend.

Example:

interface Printable {
  print(): void;
}

function printValue<T extends Printable>(value: T): void {
  value.print();
}

class Person implements Printable {
  print(): void {
    console.log('Printing person...');
  }
}

let person: Person = new Person();
printValue(person);

In this example, Printable is an interface that defines a print method. The printValue function is a generic function that takes a type parameter T that must extend Printable. The Person class implements the Printable interface.

At this point you have a basic understanding of TypeScript and you can start diving into more advanced concepts.

Conclusion

In this article, you've learned the basics of TypeScript.

We talked about the basic syntax of TypeScript, such as variables, functions, and classes.

You also learned about TypeScript's built-in types, such as numbers, strings, and booleans.

We discussed TypeScript's built-in enumerations, such as number enums, string enums, and computed enums. And you learned about TypeScript's generic types, such as generic functions and classes.

Thank you for reading!

They don't embrace and understand abstractions in their code, or in their learning.

But what are abstractions? And why are they important?

Let's dive in!

What is an Abstraction?

In coding, developers often use abstractions to simplify a system. Abstractions are a way of hiding complicated details from the end user, and trying to simplify whatever task you're trying to do.

But abstractions can be used in more than just code, so let's start with an example.

Coffee machine abstractions

Imagine if you were creating a machine to make coffee for your users. There could be two approaches:

How to Create it With Abstraction

• Have a button that says "Make coffee"

How to Create it Without Abstraction

• Have a button that says "Boil the water"
• Have a button that says "Add the cold water to the kettle"
• Have a button that says "Add 1 spoon of ground coffee to a clean cup"
• Have a button that says "Clean any dirty cups"
• And all the other buttons

Can you see how, when we use abstraction, we don't expect the user to know how the machine makes coffee? But in the machine without abstraction, the user has to know in which order to press each button, which forces the user to understand how the coffee is made.

Why You Should Abstract Your Details

When we use abstractions well, we make our system/codebase/task and so on much easier to understand and use. By hiding away complicated details inside a module, class, prototype, or function, we can make a super simple way to do complicated things.

So for example, let's say we have some complex code that ends up doing lots of complex, hard to understand math. We can wrap all that logic up in a function and provide a really easy interface where you just pass in your number and the function will do the work.

Developers in all languages and across all ecosystems make use of abstractions. The NodeJS team doesn't force you to understand how to modify 0's and 1's on a hard-drive to save text into a file – you can simply call the writeFile function.

When we use abstraction, we are essentially not forcing the person who uses our code to worry about the implementation details. They can just call the function and they'll get their answer back – they don't have to worry about what the function is doing "under the hood".

That's the strength of abstracting details away in your code.

I used to work at a company with a codebase that was 4 million lines long. Can you imagine a senior developer expecting me to understand every function? Every module? Every class? I would have NEVER merged a single change in that codebase if I did!

You can create a reusable, simple to understand, and easily changeable codebase by abstracting away certain details into the correct modules/separating out your code.

An Example Abstraction

Let's try and illustrate this with a code example.

Imagine you're working on a banking app, and you keep coming across this same weird subtraction over and over again, in different places in the code.

const res = bankAccountBalance - 1200

const res = bankAccountBalance – 1500

const res = bankAccountBalance - 1400

Why do we keep subtracting random numbers from everyone's bank balance once a year?! This is so unclear, there are zero comments explaining this?! What's happening? Is this an error?

Now imagine if this feature was clearer and did this:

const minusFeesInUSDollars = (bankAccountBalance ) => {
    // Our yearly fees for this account are 1200 (USD)
    const YEARLY_FEES = 1200;
    return bankAccountBalance - YEARLY_FEES;
}
const minusFeesInGBPounds = (bankAccountBalance ) => {
    // Our yearly fees for this account are 1500 (GBP)
    const YEARLY_FEES = 1500;
    return bankAccountBalance - YEARLY_FEES;
}
const minusFeesInEuros = (bankAccountBalance ) => {
    // Our yearly fees for this account are 1400 (EUR)
    const YEARLY_FEES = 1400;
    return bankAccountBalance - YEARLY_FEES;
}

The example isn't perfect, because we could remove some duplication in these functions – but we have abstracted logic into "something", in this case, a function.

Why Should I Embrace Abstractions?

I have explained abstractions so far in the context of code, but it can apply to your learning journey as well.

If you can't embrace abstractions (at least when you are starting) you will never be able to understand and excel as a developer.

Why is this the case?

Well, because there is always an abstraction beneath you, that you will be tempted to try and understand. This will ultimately frustrate you, overwhelm you, and kill your learning.

Here's an example.

1. You start to learn React.

This is going well! I'm starting to learn my first few bits of code and render some things to my computer screen. This is going well. 😊

2. You learn that React is a library of JavaScript.

Okay that's cool! I should learn a little bit of JavaScript before I start with React then. I'm going to stop learning React, and learn vanilla JavaScript first.

3. You learn JavaScript is a programming language made up of lots of different pieces.

Okay this is getting more complex now. There are JavaScript engines, third party API's, different runtimes. This is getting confusing.

4. You try to understand how an engine interprets JavaScript code.

Okay! So your JavaScript code is being run, by a piece of software coded in C++. What is C++?

5. You start to learn C++.

This learning journey isn't going so well anymore. This is starting to get very confusing and much longer.

6. You learn that C++ is simply an extension of C.

What on earth is C?!

...and so on.

If you continue to dig deeper and deeper and deeper, into every tiny little detail, you are much more likely to quit your learning journey, and it will only be because you feel overwhelmed.

And if by some miracle you haven't given up, you're going to spend a much, much longer time trying to learn some basic skills you might need for a job.

How Do You Embrace Abstractions?

As you're learning, you're going to have to get comfortable with not fully understanding some things in your learning journey.

You can just "abstract" this knowledge away, and stick to the things that are relevant to what you're currently doing.

Don't chase down every tiny little detail that you encounter if you are new in your learning journey. Truth is, even the experts don't know everything! They normally know lots of things in a narrow area.

One Day You Can Dig into the Abstractions

I don't want this article to come across like I am saying you should never delve below the abstractions you use everyday. But what I am saying is it won't help you to delve into the abstractions before you have spent a decent time coding first.

You should try to learn things as you need to learn them if you are early in your journey to become a developer.

After all, learning to code is hard enough, without committing to learning the entire ecosystem before even understanding the basics.

Once you start to become comfortable in your learning journey, and want to improve your skills, then learn how your abstractions work.

Conclusion

I hope this has been useful, and is encouraging if you are feeling overwhelmed with everything you're currently learning.

I tweet my articles here if you would like to read more.

Because React is open source, anyone can access its source code, inspect it, modify it, and enhance it for their personal needs or app development requirements.

In this tutorial, you'll learn how to install React into your project.

How to Install React

Now that you know what React is and why it's useful, you'll learn how to make use of this library in your project.

Step 1: Install Node.js

Before you start the React installation process, you must have Node.js installed on your computer. If you do not know what Node.js is all about, you can read more here.

You have to install Node first because React.js is a JavaScript library, and Node.js is a JavaScript runtime environment that allows you to run JavaScript on the server side. So when you're writing React, you include JavaScript functions in your React project, and then Node.js helps run this JavaScript code on the web page.

Node.js has various versions. The recommended version is the latest stable version, as it contains major and significant changes. These changes includes bug fixes and security updates, compatibility with your project dependencies, and so on.

To install Node, navigate to the Node.js website. On their webpage, you have the option to download either the recommended version or the current version, as seen in the image below.

Node.js web page interface

After you have downloaded the version of your choice, install it on your computer.

Once installation is complete, open your command prompt to confirm that Node has been successfully installed. Type in node -v in your command prompt, then click the enter button. This command should display the current version of Node installed on your computer.

Here is what it looks like:

Node version displayed in the command prompt

If your Node version is displayed like the above, congratulations! You have successfully installed Node.js on your computer.

Step 2: Install React

Now you can go ahead and install React into your project. Let's go through the steps together.

First, we'll look at the "traditional" way of installing React, using create-react-app (CRA), so you're aware of that process. Then we'll see how to install it using the modern Vite build tool.

Using CRA

Still in your command prompt window, navigate to the directory that you want to use in creating your React project. To do this, type cd [directory name] then click enter.

cd documents command to go to documents directory

As you can see in the image above, I am navigating to the documents directory, which is where I would like to create my React project.

In the documents directory (or wherever you're creating your project), create a folder that you will be using to create your React app. Type mkdir [folder name]then navigate to the newly created directory using cd [newly created folder name].

In the newly created folder directory, type in npx create-react-app [project name of your choice], and then wait until your React project is completely created. The final section should have the text in the image below displayed:

React complete installation in the terminal

Lastly, open the React project in your code editor by typing in code . . Your code editor (if you are making use of VS code) should look like this:

React Complete Installation Display Using CRA

In the above image, let's go over some of the elements you'll see there.

• The node module folder is a storage folder that holds your React package along with other packages that might be installed as you work on your React project. The node module helps configure the design system of your React project.

• The src folder stores in all the files and components used in your react application ranging from the App.js, index.js, App.css just as seen in the image above.

• The package-lock.json file locks the versions of dependencies your React project uses, and this helps in managing dependencies in your React project.

Recently, create-react-app has become deprecated and the React team doesn't recommend using it anymore. Other modern tools provide a faster front-end development experience, and and you can use them to create React apps without stress. Such tools include Vite, Snowpack, Gatsby, Next.js, Percel, and so on.

In this section, you will learn how to use the Vite tool to install React into your project.

Using Vite

Vite is a very fast and customizable modern tool that aims to provide a linear development experience for modern web projects. You can use it to create your React apps in a fast and reliable way. It also has the same features as create-react-app (CRA).

Just as we did when installing React using CRA, the first step is to make sure you have Node installed on your computer. After that, navigate to the directory you want to use and create a new folder (with any name of your choice).

Open the newly created folder in your code editor (VS code).

Vite_React

The image above is what yours should look like. In my case, I named the folder I created Vite_React.

The next step is to open the terminal (located in between Run and Help), as seen in the image above.

Once in the terminal, run npm create vite@latest [your project name]. In my case the project named I used is new-react-vite. The above command should look like this:

Select Framework (React)

At this point, you are asked to select what framework you want to install, so since you are working on React, use your arrow keys to navigate to where we have React, then click on Enter.

Select language (Javascript)

From the image above, the next step is to select what language you want for your project. You can choose any language of your choice, but for the sake of this tutorial, I chose JavaScript.

The next step is to navigate to the project directory where you created the React project. To do this, type cd [directory name]. Yours should look like this:

React Complete Installation Using Vite

Once you have done this, you should see that your React files has been created and displayed on the screen like this:

React Installation Display

Last but not least, install the Node module folder by typing npm install in the terminal. This takes a little time to complete, but when installation is done, you should see the node_module folder at the top, like this:

Node Modules folder

Lastly, type npm run dev to run your project and display on the web page. If you followed the installation steps correctly, you should see your local host:

Local host

Hold your control button and click on your local host. This takes you to the web page. At this point, if your web page is displayed like this:

Final React Display on the web page

Congratulations on installing React on your project!

Conclusion

The React library is a powerful open-source JavaScript tool you can use to create dynamic and appealing applications. It is actually a fun framework to get your hands on, so I recommend trying it out.

I believe at this point you can fully install React into your project with the modern tool (like Vite). If you've done it, congratulations again!

Happy Coding!

You might think, "You can't count that as an open source contribution. That's a joke!"

I had the same thought myself — until recently. Getting my feet wet in open source was daunting, yet I got through it. And looking back, I learned a ton from that first contribution.

As a newbie who didn't know anything about open source, I learned how to communicate with the maintainers, how to work with Git and GitHub, and how to create a pull request. It was a big learning curve!

That is one of the reasons why I wrote this guide: to make your journey in contributing to open-source projects smoother and less daunting.

In this guide, I'll walk you through the basic Git and GitHub workflow when contributing to open-source projects. I'll also explain how to synchronize your forked and local repositories with the original repository and how to resolve merge conflicts when you encounter one.

Without further ado, let's get started!

Table of Contents

• Prerequisites
• Are all GitHub Projects Open Source?
• How to Fork a Repository
• How to Clone a Repository
• How to Create a New Branch
• How to Add Changes to the Staging Area
• How to Commit Changes
• How to Synchronize Changes
• How to Resolve Merge Conflicts
• How to Push Changes
• How to Create a Pull Request
• Final Words

Prerequisites

To follow along with this tutorial, you'll need the following:

• A GitHub account.
• A code editor like VSCode installed on your machine.

Are all GitHub Projects Open Source?

When you're interested in making contributions, you should make sure that the project you're interested in is open source. You can't assume that all projects on GitHub are open source.

In this section, I will share what you should check to know if a project is open source.

The License

The license is the first thing you want to check. A project on GitHub is not an open source unless it has a license.

In most jurisdictions, a project without a license is automatically licensed as "All Rights Reserved" by its owner. It means that no one may use, modify, or redistribute anything in the project without the permission of the owner. If you ignore it, they can legally sue you.

You can find the license in a file called LICENSE. You'd usually see in the "About" section of the repository.

An MIT license in the "About" section on the right sidebar of a repository on GitHub

The Contribution Guide

Most open-source projects are ready to receive contributions when it has a contribution guide. This guide contains everything you should know about how to contribute to the project, from opening an issue to creating a pull request. From the code of conduct to the expected communication style.

The procedures and requirements for contributing to open-source projects may differ from one to another. You always want to read and follow the guide when contributing to a project.

Usually, you'll find a section about the contributing guide on the README. But if you can't find it there, look for a file called CONTRIBUTING.md or anything similar.

Hacktoberfest Topic

Hacktoberfest is a yearly event in October sponsored by DigitalOcean to support open source.

To participate in this event and get your pull requests reviewed and counted, you should check whether a project is involved in Hacktoberfest before contributing.

A project participating in the event should have a hacktoberfest topic that you can find tagged in the "About" section of the repository's main page.

The "About" section on the right sidebar of a repository with hacktoberfest as one of the topics — Credit: AliceWonderland/hacktoberfest

How to Fork a Repository

So, you're ready to contribute to a repository of your choice. The first thing that you should do is to fork the repository.

Fork means creating a copy of a repository in your GitHub account.

You always want to fork a repository because most open-source project owners don't authorize contributors to push changes directly to their repositories.

By convention, your forked repository is called the origin repository, while the original repository is the upstream repository. I will use these aliases from now on to differentiate them.

At the repository's main page on GitHub, click the Fork button at the top right:

Fork button on GitHub

It will redirect you to the "Create a new fork" form. You can leave the inputs as it is. Then, click the green "Create fork" button at the bottom.

A Create a new fork form with a green Create fork button on GitHub

This will create a copy of the repository in your GitHub account.

How to Clone a Repository

After forking the repository, the next thing to do is to clone it.

Cloning a repo means creating a copy of a repository in your local environment. You should clone your forked repository when contributing to an open-source project.

Here are the steps to follow:

Step #1 - Navigate to the forked repo

Navigate to your forked repository with these steps:

• Click your avatar on the top right.
• Click Your repositories on the dropdown menu.
• Click the repository that you want to clone to open it.

Then click on the green <> Code button. Copy the HTTPS URL by clicking the copy icon.

To ensure that you are cloning the forked repository, you should see your GitHub username in the link. For example:

https://github.com/<github-username>/<repository-name>.git

That is:

User's avatar on GitHub

Dropdown menu on GitHub that highlights Your repositories

A green <> Code button and a HTTPS URL of a repository followed by a copy icon on GitHub

Step #2 - Clone the Project Locally

In your terminal, run the git clone command along with the URL that you copied:

git clone <copied-url>

You can navigate to the project's directory with this command:

cd <project-name>

How to Create a New Branch

The best practice in open source is to create a new branch whenever you are going to work on an issue. A new branch isolates your changes and keeps the main branch clean.

Run this command to create a new branch and navigate to it:

git checkout -b <branch-name>

Although you can give a branch any name, you should follow conventions related to naming a branch. A branch name usually refers to the change that you make. For example, feature/add-dark-mode or bugfix/broken-link-to-about-page.

Now you can start to make changes in your new branch.

How to Add Changes to the Staging Area

Let's say you've finished working on changes. Before committing, you must first add them to the staging area.

This step allows you to keep your changes while you can still modify them before committing. It also lets you choose which change(s) you're ready to commit.

Adding changes to the staging area is often seen as a less critical step. But that's not true. This step allows you to change your mind before committing. Because once you commit your changes, you add a piece of story to the project's history.

How to Add Single or Multiple Files to the Staging Area

When you want to add one or multiple files — but not all — to the staging area, run this command:

git add <file-name-1> <file-name-2>

For example:

git add README.md CONTRIBUTING.md

The command above adds the README.md and CONTRIBUTING.md files to the staging area.

When you add nested files(s) to the staging area, you want to add the path(s) to the file(s). If you can't figure out the exact path, running git status will help give you the status of the files that contain your changes.

Here is how to do it:

Run git status in your terminal. You will see something like this:

git status showing paths to three modified files on the VSCode terminal

Copy the path and run the git add command along with the path(s) to the file(s):

git add <path-to-file-1> <path-to-file-2>

Here is an example of adding paths to two files based on the screenshot above:

git add app/routes/__frontend/resources/index.mdx app/routes/__frontend/resources/developer-resources/open-source/index.mdx

How to Add All Files

When you want to add all files to the staging area, run this command:

git add .

This adds all the files with changes to the staging area.

How to Commit Changes

To commit means to record your changes. That is why a commit requires a message as the record. Over time, commits will tell the story of the project's history. So, a clear and descriptive commit message is essential.

What you should know when committing your changes:

• Add and commit your changes often. The best time to add and commit your changes is every time you finish making a meaningful change, even if it's a small change. Committing your work once completed also prevents your changes from being carried over to other branches.
• Use a clear and descriptive message. "Change the background color from black to dark blue" is more descriptive and easy to understand by everyone than "Fix style".

To make a commit, run this command in your terminal:

git commit -m "Your message"

Here is an example of a single line commit:

git commit -m "Fix the link to the About page"

And here's a commit with multiple lines:

git commit -m "Fix the link to the About page
Fix the typos in the About page"

How to Synchronize Changes

When you are working on changes, there is a possibility that the main branch on the upstream repository has already merged in some pull requests. So, the state of the origin and your local repositories at this time will no longer be the same as the upstream.

For this reason, you should always update your local working branch so you'll push the same state as the upstream repository.

How to Update the origin Repository

First, go to the origin repository on GitHub to check if it's up to date with the upstream.

You can push your changes when no change exists in the upstream repository.

To know if the origin repository is up to date, you'll see a message that says, "This branch is up to date with " on the main page of the repository, as shown in the screenshot below:

An up-to-date branch in the origin repository on GitHub

But when there are changes, you will see a message that says, "This branch is X commit(s) behind ".

A message indicating a branch in the origin repository is eight commits behind the upstream repository on GitHub

To update the origin repository:

1. Click the Sync fork dropdown button.
2. Click the green Update branch button.

The Sync fork and Update branch buttons on GitHub

After it's updated, you will see a "Successfully fetched and fast-forwarded from upstream " notification at the top.

A notification "Successfully fetched and fast-forwarded from upstream" on GitHub

How to Pull Changes

Now that your origin is up to date with the upstream repository, it's time to pull the changes and update your local one.

Pull is a way of getting new changes from the remote to the local repository.

To pull the changes, ensure that you are on your working branch. You can do so by running git status:

git status showing a branch name

Run the git pull command to pull the changes from the main branch in the origin repository:

git pull origin main

You can now push your changes if you don't need to resolve conflicts.

How to Resolve Merge Conflicts

After updating your local repository, you might encounter conflicts that you must fix before you can push your changes.

It's common to encounter these conflicts in open source projects. Merge conflicts usually occur when there are changes in the same line(s) and file(s) from two different branches.

When a conflict arises, you will see options for accepting changes on top of your workspace in VSCode. You will also see another change(s) different from yours — the incoming change.

Options to accept change, the current change, and the incoming change on VSCode

How to Fix Merge Conflicts

You can choose from different options when you want to resolve a conflict:

• Accept Current Change: When you wish to keep your changes only.
• Accept Incoming Change: When you want to accept only the incoming changes that aren't yours.
• Accept Both Changes: When you want to accept your changes and the incoming changes.

You can still fix things if necessary after choosing the desirable action.

After resolving the conflicts, you can then add your changes to the staging area and commit them.

Since you'll add and commit changes in an existing file, you can run this command to do both actions at the same time:

git commit -am "Your message"

How to Push Changes

Now, it's time to push your changes. This means moving changes from the local to the remote repository.

You always want to push your changes to the origin repository. To do that, run this command in your terminal:

git push origin <branch-name>

There's a possibility that you may get this error message:

git push message "fatal: The current branch <branch-name> has no upstream branch."

You can copy, paste, and run the command in the error message in your terminal:

git push --set-upstream origin <branch-name>

Alternatively, you can run this command:

git push -u origin <branch-name>

How to Create Pull Request

A pull request — commonly called a PR — is a way to notify others that a branch with changes has been pushed to a remote repository.

After a pull request is opened, maintainers can review and discuss your changes. They can ask you to make more changes before they can merge your pull request or merge them immediately into the main branch.

How to Create a Pull Request

First, go to the upstream or origin repository on GitHub.

Then click the green Compare & pull request button to redirect to the Open a pull request form:

The green Compare & pull request button on GitHub

Then fill out the pull request form. If there's a pull request template, complete all required areas to help maintainers review your changes.

If there is no pull request template, you can write the pull request in a structured manner. Consider this when writing your pull request:

• A short, clear, and informative title.
• A clear description of the changes.
• The link to the related issue. For example, "Closes #456".
• Screenshots or screen recordings when necessary.

Lastly, click the green Create pull request button at the bottom to create a PR.

The green Create pull request on GitHub

Final Words

Contributing to open-source projects can be daunting and make you feel intimidated at the beginning. But like other skills, with continuous practice, you will become better.

Besides understanding Git and GitHub, there are non-technical aspects of open source that you should know too.

And once you get the grip, open source can be so much fun!

If you liked and enjoyed this article, please share it with others. You can find other works of mine on my blog, and let's connect on X (formerly Twitter) or LinkedIn!

Although they are as important as the technical sides, the non-technical ones often get overlooked. In this article, I will share the essential non-technical things you should know when contributing to open source projects.

What are the Important Files in a Repository?

In this section, we'll talk about some of the important files you'll likely come across when contributing to an open source project.

The README.md File

When you're interested in contributing to an open-source project, you should always read the README.md file — commonly called README — to familiarize yourself with the project.

The README.md file is the face of the project, containing everything essential. You'll usually find most, if not all, of these sections in a README:

• The project's description.
• The technology used for the project.
• Instructions on how to install, run, and use the project.
• The project's license.
• The code of conduct.
• How to contribute to the project.
• The expected communication style (through issue and pull request comments, GitHub discussion, chat service apps such as Slack or Discord, and so on).

The CONTRIBUTING.md File

Next, you must know the rules to follow in order to contribute to a project. The procedures and requirements for contributing may differ between projects. For example, in some projects, you're required to comment on an issue before it gets assigned to you, while others allow you to assign an issue to yourself.

The CONTRIBUTING.md file serves as a contribution guide. It explains the community's rules and expectations from their contributors, from creating an issue to creating a pull request.

In most cases, you'll find a contribution section in the README. But if it's not included in the README, you can find it in a file named CONTRIBUTING.md or anything similar.

The LICENSE File

You can't just assume that all projects on GitHub are open-source and that their codebase is freely available.

"In most jurisdictions, any code or content is automatically copyrighted by the author, with all rights reserved, unless otherwise stated." (Source: Open source licenses: What, which, and why)

"All rights reserved" means that no one may use, modify, or redistribute anything in the project unless the owner gives you permission to. If you ignore it, they can legally sue you. So, a project on GitHub is only open source if they have a license that specifies that.

You'd usually find a license section on the README, in the "About" section of a repository. It is found in a file called LICENSE.

An MIT license in the "About" section on the right sidebar of a repository on GitHub

The CODE_OF_CONDUCT.md File

You should habitually read the community's Code of Conduct (COC). The COC is the house rule of the community. It is there for a reason: to maintain a safe, welcoming space for contributors. Following the COC will prevent you from getting banned from the community and the project.

You can find the COC in a file called CODE_OF_CONDUCT.md, in the "About" section on of the repository. Most times, it's also included in the README and contributing guide.

Code of Conduct in the "About" section on the right sidebar of a repository on GitHub

Ethics in Open Source

Check for Duplication

Let's say you install and run a project on your local machine and encounter a bug. Or you read through the docs and find a missing step. You might want to raise an issue to address it.

Before doing so, you must check if a similar (open and closed) issue or pull request has been raised to avoid duplication. Enter possible keywords in the search bar on top of the issue or pull request page on GitHub to check for possible duplication.

Search bar on top of the issue or pull request page on GitHub

For example:

is:issue is:open docs

is:pull request is:closed button

Checking for duplicates will help prevent your issue or pull request from getting turned down by maintainers.

Ask for Permission before Working on an Issue

One of the essential ethics in open source is asking for the maintainer's permission to work on an issue unless stated otherwise in the contribution guide. Asking for permission helps the maintainers in controlling and avoiding duplicate pull requests.

You only want to work on changes and create a pull request after you get the green light from a maintainer. If you ignore this part and go ahead to work on the changes, your pull request will likely be ignored or turned down. This is because the issue may have been assigned to someone else already, or the issue may not be their priority at that moment.

Either way, it would be a loss for you. So, what should you do when asking for permission?

1. Check if the issue has already been assigned

You can see if an issue has been assigned by looking at the "Assignee" column when you open the issue tab in the GitHub repository or on the right sidebar when you open the issue.

Assignee column on the issues page on GitHub

Assignees section on the right sidebar of the issue page on GitHub

2. Check the comment threads

You also want to make sure that someone has not already asked the maintainers to assign the issue to them. If they haven't gotten any response, then the maintainers have probably not seen the comment. You should also check other information in the threads to understand more about the issue.

3. Leave a comment to request for an issue you want to work on

You can say, "Hi, I want to work on this issue. Can you assign it to me?" Or, "I see this issue has been assigned, but I haven't seen any activity here in a while. If you still need help, can I work on this?"

4. Wait until the maintainer replies to your message

If they (the maintainer(s)) say you can have it and assign it to you, then you can start working on the issue and, in the end, create a pull request.

What is the Good First Issue Label?

Labels on GitHub are tags that pass information about the type or the status of an issue or a pull request. A good-first-issue is a label considered appropriate for beginners by the project's owner and maintainers.

I once created an issue about a broken link. I explained the bug and the steps contributors must take to resolve it.

I also mentioned that this issue is beginner-friendly, so we want to leave it for beginners who wish to contribute to the project. After passing the review from the maintainers, the issue was labeled as a good-first-issue.

The sad part was that people who deliberately took the issue were not beginners.

If you already have some experience, please consider leaving this label. It is meant for beginners in open source or the technology used in the project.

Good Communication and Patience

Always use clear and polite words to communicate with maintainers and other contributors. Remember that async communication is prone to loss in translation and miscommunication.

If you need more clarification on something, ask the maintainers. Don't make assumptions. You can ask questions in the issue or pull request comments. Some communities also have a GitHub discussions board that you can find on the top bar, while some use chat service apps like Slack or Discord to share ideas and ask questions or clarifications.

Discussions tab on GitHub

A maintainer may ask you to fix something in your pull request or ask for clarifications using a straightforward sentence. Short and direct messages mostly happen because they are busy. They must be fast and effective in replying to messages. Don't take it personal as this may lead to poor communication or even lead to losing your chance at contributing.

Most of the maintainers and contributors in open source are volunteers. That said, they have life and other duties outside of the project. So, when you're contributing, you need to have patience. Don't ask maintainers to immediately answer your question or merge your pull request.

Write Issue and Pull Request in a Structured Way

Some open-source communities provide templates on GitHub for opening an issue or creating a pull request. But when they don't, consider writing them in a structured manner. It would be handy for everyone to see the details and help maintainers review and merge pull requests.

How to Write a GitHub Issue

Here are some things to consider when writing an issue:

Use clear and descriptive titles: By reading a clear and descriptive title, everyone can understand the issue. For example, "fix: Link to the About page leads to 404".

Search for similar issues: Check open and closed issues to see if there is a similar or identical issue as yours. If you don't find any, then include in the description that you've checked and did not find any similar issues. This step is essential to avoid any duplication.

Description of the issue: Describe the issue as straightforward as possible.

Expected behavior: Describe the expected behavior of an issue.

Actual behavior: State the actual problematic behavior that causes the issue.

Reproduce the problem: What steps do we need to take to reproduce the problem? It would be helpful for everyone to run the same steps and test it out. Here's an example:

1. Go to this link.
2. Click this button.
3. This is what is happening.

Screenshots or screen recordings: Provide some screenshots or screen recordings if necessary. It is usually beneficial for UI issues.

Suggest a solution: If you have a solution in mind, you can give a suggestion. But if you don't, it's okay too. You are not expected to have a solution when you raise an issue.

Here's an examples that uses the points listed above:

<!-- Issue title -->
# fix: Link to the About page leads to 404

<!-- Issue body -->
## Description

When I went to the About page, I got a 404.
I have searched and didn't find any similar issues.

## Expected Behavior

We should see the About section when we go to the About page.

## Actual Behaviour

When we go to the About page, we see a 404 page.

## How to Reproduce

1. Go to the https://website.com.
2. Click the About tab.
3. You will see the 404.

## Screenshots

![404 in about page](link to the image)

## Suggestion

Fix and use the correct link to the About page.

How to Write a Pull Request

Here are some things to consider when writing a pull request:

Use a short, clear, and informative title**: For example, "fix: Link to About page".

Use a clear description of the fix**: For example, "This pull request fixes the link to the About page that previously led to 404."

Link to the related issue: Include the link to the related issue. For example, "Fixes #123".

Screenshots or screen recordings: Provide some screenshots or screen recordings that shows the issue before and after the fix if necessary.

Here's an example that uses the structure above:

<!-- Pull request title -->
# fix: Link to About page

<!-- Pull request body -->
## Related Issue

Fixes #123

## Description

This PR fixes the link to the About page that previously led to 404.

## Screenshots

### Before

![404 in about page](link to the image)

### After

![About page](link to the image)

Good to Know: Contributing to Open Source is Not All About Code

I often hear that people — especially beginners — hesitate to contribute to open source because they need more skills or time to help with code. However, contributing to an open-source project is involves more than just code.

There are many non-technical ways to contribute to a project and its community, such as:

• Opening an issue when you see a bug or room for improvement.
• Reviewing issues and pull requests.
• Improving the project's documentation.
• Answering questions.
• Throwing ideas around the project.
• Onboarding new contributors.
• Mentoring other contributors.
• Writing a blog post or creating a video about the project.
• Promoting the project on social media, and many more!

Final Words

Contributing to open-source projects is not all about understanding Git and GitHub. Some non-technical things are important for you to know, too. I hope this article helps.😊

If you liked and enjoyed this article, please share it. You can find other works of mine on my blog, and let's connect on X (formerly Twitter) or LinkedIn!

These collaborative inventions bring together people with different skill sets including developers, designers, and tech enthusiasts in general with one goal in mind to build: to improve and share software freely.

The open source movement champions the idea that knowledge should be accessible to all, and fosters a culture of openness, transparency, and cooperation.

Contributing to open source has many benefits not only for those taking part in it but also the community at large.

Now, if you are just a beginner trying to get into the open-source world, you should keep in mind that you are embarking on a journey that will not only improve your technical skills but also open many doors for you and give you multiple opportunities to interact with like-minded individuals.

This is just a portion of what you can achieve. You'll also have an opportunity to:

• Create an impact through your work

• Build your portfolio

• Network and connect with other devs, and

• Give back to the developer community.

This beginner friendly handbook is crafted to be your companion as you begin your journey into the world of open-source. It will cover concepts that will allow a beginner like you to make your mark in the open-source world.

We will start with the fundamentals of open source, and I'll guide you through setting up your development environment, navigating open-source communities, selecting the right projects, and making your first contribution.

Table of Contents

• What is Open-Source Software?

  • Characteristics of Open-Source Software

  • Types of Open-Source Licenses

• Benefits of Contributing to Open-Source Projects

• How to Get Started with Open-Source Contributions

• How to Navigate Open-Source Communities

  • Understanding community dynamics

  • How to Find and Join Open-Source Communities

  • Etiquette, Communication Norms, and Best Practices

• How to Set Up a Development Environment

  • How to Install the Necessary Tools

  • Text Editors and Integrated Development Environments (IDEs)

  • Version control systems

  • How to fork, clone, and set up projects

• Understanding Project Structure and Workflow

• How to Make Your First Contribution

  • Step-by-Step Guide to Making a Contribution

• Collaboration within the Community

• Beyond Code: Non-Coding Contributions

• Best Practices for Quality Contributions

• How to Handle Challenges

• How to Showcase Your Open-Source Contributions

• Conclusion

• Additional Resources

By the end of this guide you will be equipped with the necessary skills to become an active member of the open-source community. This is the beginning of your open source journey where you will get to continuously learn, collaborate with others, and create an impact. Let's get started!

What is Open-Source Software?

In simple words, open source can be described as source code and projects that are made available to the public to view, use, modify, and distribute under a permissive license.

Open-source projects are usually developed in a collaborative manner, mostly by a community of volunteers. Unlike proprietary software, which is usually controlled by a single entity, open source promotes transparency, collaboration, and innovation through community support.

Open-source projects don't only empower their users to use the projects themselves, but also gives them an opportunity to understand how the project works, contribute to its growth, and improve it too.

The main idea behind the open-source software is not only to share the code but create communities with a culture of collaboration, transparency and shared learning.

With this approach in mind, the open-source world has given a rise to some of the most innovative and impactful technologies in use today.

Characteristics of Open-Source Software

• Free to use - users can feely use, modify and redistribute the software.

• Transparent - source code is accessible to all. This promotes trust among the users, as well as openness amongst developers who peer review and fix bugs.

• Collaborative - most open source projects promote collaboration, which enables different people from around the world to contribute their skills, ideas, and expertise.

• Community-driven - open-source projects foster and promote the building of strong communities of like minded individuals with common goals.

• Diversity - brings together people from different backgrounds who share a common goal.

• Continuous Improvement - open source software is continuously evolving. This means that bugs are fixed regularly, new features are added often, and updates are released from time to time.

• Licensing - each open source software has a license that protects the rights of both authors and users, enabling the software's continued openness.

Types of Open-Source Licenses

Open-source licenses protect the rights of both the authors and the users. They also define terms under which the software can be used, modified, and distributed.

Some of the most common licenses are:

• GNU General Public License (GPL) - this guarantees the end user the freedom to run, study, share and modify the software.

• MIT License - originates from the Massachusetts Institute of Technology (MIT). It permits reuse of proprietary software.

• Apache License- commonly used for projects associated with the Apache software Foundation.

• BSD Licenses - they are a family of free software licenses that impose minimal restrictions on the use and distribution of covered software.

• Mozilla Public License (MPL) - this is a copyleft license that will require the authors to share modifications they make on your code.

• Creative Commons Licenses - most commonly used not only in software but for other creative works, too. Used when an author wants to give other people right to share, use, and build upon their work.

Having an understanding of these licenses at an early stage is really important as they dictate how your contributions can be used and distributed.

Benefits of Contributing to Open-Source Projects

Contributing to open source can be a rewarding way to learn, teach, share, and build experience. There are plenty of benefits that extend beyond the contributions you make.

By contributing to open-source projects you can:

• Learn and Grow - It will open different avenues for you by giving you an opportunity to experience real world development practices, code review processes, problem solving techniques, and so on.

• Build a Portfolio - Your contributions serve as a proof of your skills, which can be helpful when applying for jobs.

• Community and Networking - It gives you the opportunity to engage and interact with like-minded individuals from around the world. It opens doors for mentors and professional contacts who can guide you.

• Solving Real Problems - Some projects are targeted at solving problems faced by many people like security and healthcare. Contributing to them means you are making a direct impact in solving issues that matter.

• Improving Software - The contributions you make may help improve the quality, functionality, and usability of software you use or that's used by millions of people. Each contribution you make, whether it's fixing a bug, typo, or adding code potentially benefits countless users.

• Recognition and Respect - As you work your way into the open-source world and become consistent, you will gain recognition and be celebrated for your work.

• Additionally, it's a fun experience and gives you personal satisfaction. And hey, you never know who is watching, maybe it's your next employer or partner 🙂.

How to Get Started with Open-Source Contributions

Before taking a deep dive into the open-source world, it's important to first evaluate your skills and interests.

Reflect on the programming languages you know, your general technical abilities, and your areas of expertise. Identify your strengths and areas where you want to grow.

This self-assessment will help you find projects that align with your skills and passions.

1. Setting Up the Right Mindset

As you may know, contributing to open-source is not only about code – it's more of collaboration that will promote growth, learning and positive community engagement.

Before getting started, having the right mindset will empower you throughout the journey. For that you will need to:

• Understand the value of open-source - the key principle behind the success of open-source projects is collaboration. Each contribution made, no matter how small, adds value. These collective contributions add benefits to the global community.

• Embrace the learning process - not knowing everything is okay, and that's why open-source encourages learning through collaboration. Remember to always do your research and then, if needed, seek help when you are stuck. This is a sign of progress and not weakness.

• There is more than code - as much as code is the core of most open-source projects, it's not the only way to get involved. Before making contributions consider your strengths and interests and then explore non-coding avenues, too.

2. Choosing a Programming Language/Technology

In order for you to make effective contributions, you'll need to decide which programming languages/technologies you feel most comfortable with. And for that you will need to do the following:

• Assess your skillset - assessing your skillset will help you decide whether to leverage the skills you already have or venture into learning new ones.

• Research technologies - consider technologies used in different projects that you are interested in and whether they align with your interests.

• Personal interests - passion fuels contributions, and contributing to projects that resonate with you can be fulfilling and fun.

3. Finding Projects

Identifying the right open-source projects can really enhance your contribution experience. There are a few different ways you can search for projects. Here are a few highlights on that:

• Use Open-Source Directories - explore different platforms that list different open-source projects. Websites like GitHub Explore, GitLab Explore, Open Source Friday and others all list projects, making it easier to search through.

• Source code platforms - platforms such as GitHub and GitLab are central to the open-source world. Search on these platforms using keywords, and filter across different projects to easily find ones that match your interests.

• Project activity - while searching, look for recent commits, open issues, and ongoing discussions. An active community is a positive sign for the success of the project.

• Community engagement - before you begin making contributions, engage with the project's community. This can be through joining forums, a mailing list, or chat channels. Ask questions and interact with others, as this will help you understand the project's dynamics.

4. Choosing the right project

Ensuring that you pick the right project to work on is important, as it will be the first step to achieving all your goals.

In order to more easily navigate the open-source landscape and find the right project to work on, here are a few thing to consider:

• Interest alignment - Make sure you look for projects that align with your technical interests and areas of expertise.

• Project activity - Be sure to check how active the project is. A project with a vibrant community with recent issues and commits indicates it's actively maintained.

• Friendliness - If you are beginner getting into open source for the first time, opt for projects with a reputation of welcoming newcomers.

• Project goals - Have an understanding of the project goals and be sure they align with your values.

After you have found the project you want to contribute to, it's time to do a little vetting. Make sure it meets the following criteria so you know it'll be a good project to work on:

• Check out if it has a license file.

• Look for the number of contributors.

• Check how often people make commits.

• Does it have any open issues? If yes, this might be a good sign – you will have a place to begin.

• How long does it take for maintainers to respond? You can check and see how often issues are closed and PRs are merged.

• Is there an active discussion on an issue?

• Are the issues getting closed regularly?

• How many open pull requests are there?

• How recently was the latest pull requests merged?

• Do the maintainers thank people for contributing?

If this vetting process checks out, then you are probably good to go and start your contributions.

How to Navigate Open-Source Communities

Open-source projects are more than just code repositories. They are communities where developers from around the world collaborate to create something impactful.

In order to contribute effectively, it's essential to understand the dynamics of these communities and engage with them in a meaningful way.

When it comes to building strong, sustainable open-source contributor communities, it's not just about providing robust newcomer support. For many people, getting involved with open-source projects can be intimidating, overwhelming, and frustrating - especially if they lack exposure to and experience with the different tools and workflows commonly used in the open-source world.

But with the right support structures in place, new members can quickly become valuable contributors to any project - bringing fresh perspectives, enthusiasm, and a willingness to learn.

The benefits offered by these communities are 'on another level' as I would say. They have helped people start from scratch and gain new skills, create connections, and even land their dream jobs.

Other benefits include:

• They promote exchange of ideas, solutions, and best practices.

• Overcoming challenges is often easier as a community, and can make problem solving more efficient.

• Peer review from different contributors ensures code quality, and can help you catch bugs and improve the project in general.

• Contributing to open source projects often provides you with networking opportunities.

Understanding community dynamics

Each open source community has its own culture and values. Understanding these dynamics is key to integrating successfully into the project's workflow.

• Project Vision and Goals - In order for you to make an effective and meaningful contribution, make sure you understand the project's vision and objectives.

• Community Norms and Values - Every community has both written and unwritten rules and values that contributors should respect. These can include coding standards, communication etiquette, and diversity and inclusion principles.

• Recognizing Hierarchy and Roles - Open source projects often have a hierarchy of roles, from maintainers to newcomers. Understand these roles and how decisions are made within the community.

How to Find and Join Open-Source Communities

Finding the right community is an important step to ensure you have a meaningful open-source experience. So here are a few tips you can use to discover and join open-source communities.

• Research - use the readily available platforms to search for projects that align with your skillset. As a beginner at first it might not be a walk in the park for you but with enough guidance you will find it easy.

For starters, platforms such as GitHub, Gitlab and Bitbucket can be good platforms to search for projects. One similarity that cuts across all this platforms is that you can use the search functionality to find projects by keywords, technologies used or specific topics.

For example, using GitHub if you are interested in finding Python development projects they you can have your search as shown below and additionally from the left panel further filter the search to suit your desires.

• Forums and mailing lists - many projects use different ways to communicate. By finding the right one you can easily introduce yourself and ask questions. The communications options you choose will also depend with the kind of info you want to get.

If you are interested in just receiving updates and news about a specific project you are interested in, then consider joining the mailing lists which in most cases is weekly, monthly or quarterly. To sign up for a mailing list/newsletter, you can visit either the official site of the project or a related repository.

If you are more into engaging with other contributors, then joining the forum/discussion boards is the right thing to do. These boards enable the maintainers and contributors to have discussions and share knowledge among themselves. Below is section of freeCodeCamp's forum and some of the conversation that take place.

Note the freeCodeCamp forum is subdivided into different sub-forums. This is a very common practice for big projects as it makes it easier for different contributors with questions to know where to ask for help

• Social Media - follow open-source project accounts on platforms such as X (Twitter), LinkedIn, and GitHub to easily get updates. This works best for those who are actively participating on the social media platforms. For quick updates and news regarding a specific project, then this is the right place to get it – plus it also allows you to enage with other people interested with the same project as you.

• Meetups and conferences - start attending local meetups, conferences, and workshops that are related to open-source projects. This may act as a good opportunity to start making connections.

• Online communities - use platforms such as Stack Overflow, Reddit, and Discord to connect with fellow contributors.

Etiquette, Communication Norms, and Best Practices

Once you've found a community to join, it's important to follow etiquette and communication norms. Here's a guide to best practices:

• Read the guidelines - Read and understand the community guidelines. They help ensure that everyone feels equal, safe, and respected.

• Introduce yourself - How we introduce ourselves will often be how others remember us. When you introduce yourself, remember to be respectful and concise.

• Listen and learn - Before you begin making any kind of contributions, take some time to first understand the culture of the community.

• Ask questions - whenever you encounter a challenge, feel free to ask a question and be sure to provide some context to indicate you did attempt to find an answer yourself.

• Accept feedback - whenever you receive feedback of any kind, thank the person and accept their opinion. Remember that continuous learning is key.

• Don't spam - Avoid spamming the communication channels with the same questions. Just use appropriate channels for different topics.

• Be patient - remember that the communities have contributors from different time zones, so give them adequate time to respond.

How to Set Up a Development Environment

A well-configured environment is the foundation not only for open-source contribution but for development in general.

It may sound like a difficult thing to do, but when you are contributing to multiple projects and working on personal projects from your machine, having an environment will be really helpful.

Here are a few things to note when it comes to setting up your development environment:

Install the Necessary Tools

• Local setup - In most projects, they will list all the requirements needed for setup. Just be sure to install them as instructed on the project's documentation.

• Consider using a virtual environment, as this will help in isolating project-specific dependencies.

• Using Docker is a good option, too, as it ensures consistent environments across different machines you might be working with.

Text Editors and Integrated Development Environments (IDEs)

Text Editors and IDEs are the tools that help your write, edit, and manage your code. Depending on your programming language of choice and personal preference, you can choose from different options such as Visual Studio Code, Sublime Text, or JetBrains IDEs like PyCharm or IntelliJ IDEA.

These tools offer features like:

• syntax highlighting,

• auto-completion

• debugging

These features can help enhance your coding experience.

In addition to the regular installation, be sure to install any necessary extensions that will help make your workflow smoother.

Version control systems

Version control is the cornerstone of collaboration in software development. The most commonly known and used one is Git. It allows you as a developer to record changes made to code, create branches to easily add new features without interfering with main code, and allows easy merging of the changes.

But Git by itself can't accomplish all this, so it works together with GitHub.

GitHub is a web-based platform that allows you to host source code in what is referred to as a repository. Together with Git, GitHub offers multiple beneficial features to developers – but the most important one, apart from collaboration, is that it offers a visual interface for managing the repositories. This makes it easier to track issues, merge changes and so on.

You can learn more about the basics of Git and GitHub in this guide.

Moving forward, just like with any other software, to get started using Git you'll first need to download and set it up. But first make sure that you already have a GitHub account created. If not, you can visit github.com and create one, then proceed with the steps below afterwards.

• Step 1: Download Git from the official site.

• Step 2: Run the executable file to install Git locally. If you are on another OS than Windows, be sure to check the specific commands you can use to install Git from the official site.

• Step 3: Configure Git with your details, including your username and email. For that you will need to open the Git terminal and run the commands below:

git config --global user.name "Your name here"
git config --global user.email "your_email@example.com"

For some extra customization, you can run the commands below. The first one will add some color to the output, and the second one will tell Git to use emacs.

git config --global color.ui true
git config --global core.editor emacs

Now you should be ready to use Git. If you want to learn more and dive in deeper, here's a helpful beginner-friendly Git resource for you.

We will be discussing the most common Git commands later on in the upcoming sections.

How to fork, clone, and set up projects

Now we'll cover some of the most important parts of using Git.

First, what is forking? Well, it allows you to make a personal copy of a project's repository to your GitHub account. This step is important mostly when you want to make contribution to a project that you don't have direct access to.

In order to fork a repo, on the GitHub repository page, click Fork, usually on the top right corner.

This will create a copy of the repository under your account, changing the URL of the project to:

https://github.com/<your-user-name>/projectname

Cloning allows you to download a copy of the already forked repo to your own local machine. In order for you to perform this step, you must have Git installed locally in your machine. If you haven't done this yet, check out the Version control systems section above.

First, you will need to navigate to your account and locate the forked repo. Then copy the URL directly from the browser or click the Code button to copy the URL. You'll have three option to choose from: HTTPS, SSH, and GitHub CLI. You can choose either of the first two options.

Next, in your local machine, open the terminal and run this command:

git clone https://github.com/<your-user-name>/<projectname>

Be sure to navigate to where you need the project to be copied to, for example Downloads, Desktop, and so on:

Alternatively, you can opt to use the GitHub Desktop application to perform all the above steps. But first you will need to have it installed and fully configured.

Next, instead of copying the URL and pasting it on your terminal, select the option that says Open with GitHub Desktop.

Now you'll need to know how to set up the project locally. Navigate to the project directory using the terminal and be sure to install dependencies if there are any that are listed.

To check if everything is set up correctly, run the project locally and ensure that it works as expected.

Understanding Project Structure and Workflow

Open-source projects come in various shapes and sizes, but what's common among them all is the structure and workflow. By having a clear understanding of the development process, it will make your contributing process easier.

Overview of a Typical Open-Source Project Structure

A typical open-source project will have the following people associated with it:

• Author - Also referred to as Owner. Represents the person who created the project. They have the power to assign new roles to other members to help with the project's maintenance.

• Maintainers - They are responsible for driving the vision and goals of the project. They're usually responsible for the direction of the project and are committed to improving it.

• Contributors - This represents people like you who add/make changes to the project in one way or another. They follow the same code review process, are subject to the same requirements on code style, and so on.

• Community Members/Users - These valuable members of the community can provide feedback about features, bug reports, and more.

In addition the different roles and people, the structure will usually look like this:

• The Root Directory will consist of important project files, such as the README, license information, and configuration files.

• The Source Code Directory houses the main source code of the project. It can be organized by either libraries, modules or components.

• The Documentation Directory contains user manuals, guides for any APIs to help users and contributors understand the project.

• The Configuration Files contain files with instructions on how to setup the project's build process, dependencies and other helpful configurations.

• The Assets Directory contains no-code files like images and other templates used by the project.

• The Scripts Directory contains automation tools that the project might need.

Below is a section of the freeCodeCamp repository workflow with most of the files listed above:

How to Make Your First Contribution

Before making your first contribution, make sure that you have chosen beginner friendly issues or task to work on. To help you find good beginner friendly issues/tasks, here are a few tips:

• Browse through project issues trackers on platforms such as GitHub. During the search, look for projects labeled "beginner-friendly," "good first issue," or "help wanted." This are usually designed for beginners. Here's a guide that shares more info on this topic.

• Make sure you understand the issue's description before you begin working on the task. This will help you choose a task that aligns with your skills and interests.

• If you are completely new with no prior knowledge, check for projects that offer mentorships to beginners.

For a detailed guide on how to search for issues and repos on GitHub, check out this guide.

Step-by-Step Guide to Making a Contribution

Now that you know how to search for a beginner friendly project – and assuming you have already gotten one that aligns with your skills – the next step is making your contributions.

For a demo, I will be making a non-code contribution (and I'll discuss more about this later).

• Step 1: Fork the repository

• Step 2: Clone the repo onto your local machine.

• Step 3: Create a new branch

To create a branch, run the below command and remember to give your branch a descriptive name:

git checkout -b descriptive name

This will create the branch and switch to it automatically.

• Step 4: Make the necessary changes – this can be fixing typos, fixing a bug, and so on – it all depends with the issue you have chosen.

• Step 5: After making your changes, it's time to add the new changes into the main branch. You can see all changes made by running: git status

You can choose to add each file modified individually using git add file-name or you can add the modified files all at once using: git add *

You will notice that the changes are no longer highlighted in red but instead in green. This means that they are ready to be committed.

To make a commit, we move on to the next step which is adding a commit message. This basically explains the changes we have made: git commit -m "<message here>".

• Step 6: We need to regularly sync the forked repo with the original repo. This incorporates all the changes made by other contributors. To do this, run the commands below one after the other:

git fetch upstream
git rebase upstream/main

• Step 7: Push the changes to GitHub Now that everything is set, it's time to let our maintainer know what we have added. You do this by pushing the changes with this command: git push origin descriptive-branch-name.

• Step 8: This is the last step, where we submit a PR. For this step you will need to go back to GitHub under the repo you had forked earlier. You should be able to see a pop-up with a button saying Compare & pull request – click on it.

Clicking this will allow you to give your PR a name, add a description of what you have done, mark the checklist (if there is one) to ensure that you have fulfilled all the requirements, and then finally clicking on the Create pull request button which is slightly below the description box.

Then the maintainer will merge all your changes into the master branch of this project (unless they need you to make updates first). You will get a notification email once the changes have been merged.

Collaboration Within the Community

Being part of a new community or environment in any kind of setting isn’t easy – and more so for people who refer to themselves as introverts.

When it comes to open-source communities, newcomers often face various challenges that can deter them from feeling comfortable and affect their contributions.

The first step in fixing a problem is to identify it. This will bring you closer to finding a solution. Some of the most common challenges faced by newcomers in OS communities include:

• Feeling overwhelmed/intimidated by the expertise of other community members.

• Struggling to understand the project structure and codebase.

• Lack of clear understanding of the contribution guidelines.

• Encountering an unwelcoming community.

• Lack of recognition and appreciation of contributions.

• Struggling to find tasks that matches your skills/expertise

By addressing the above challenges, we will be one step closer to creating supportive communities which are comfortable for all. As we know collaboration is key for the success of any open-source project and community engagement can play a major role on your career while at the same time shaping you to become a better contributor.

There are different ways to address these common challenges while at the same time engaging with the community to ensure the project's success:

1. Participating in discussions and forums

2. Giving and receiving feedback on contributions

3. Learning from the experienced contributors

4. Mentoring other contributors and taking part in pair programming.

5. Attending and being part of community events.

In addition to this remember to be patient, stay humble, listen actively, celebrate others, and take part in discussions about the future of the project.

Beyond Code: Non-Coding Contributions

The good thing about opens-source projects is that they can often accommodate people with all kinds of skillsets. Contributing extends beyond just writing code. Non-coding skills are also important to the success of the open-source projects.

If you are looking for different ways to get involved in open-source and don't have coding skills, this section is for you.

Update the Documentation

Good documentation is the backbone of any successful project, not only in open-source but even in the real-world products. Clear and detailed documentation will help users and developers understand the project easily.

Some ways you can contribute to the documentation include:

• Writing tutorials - You can opt to write step-by-step tutorials that will guide users through steps such as installation, setup, usage and troubleshooting.

• API Documentation - Document the project's APIs, and provide code examples for the developers who might want to integrate the project.

• User guides - Write user-friendly guides that break down the complex concepts in simple and easy to understand sections.

Contribute to the Design and User Experience (UX)

Any project that is made for an end user will greatly benefit from a well-designed user interface. If you have some skills in the design field, you can contribute by:

• Improving UI/UX - improve the project's look by suggesting more user-friendly designs and creating mockups for the same.

• Creating Icons and Graphics - design logos, icons, banners and other visual assets that will help promote the project's branding.

• User Testing - take part in testing the designs and provide feedback.

Help with Translation and Localization

Many projects are trying to reach a global audience, and as a native speaker of your language you can help with this.

Contribution by translation and localization ensures that the projects can easily be accessible by people from different backgrounds all around the world. As a contributor you can help by:

• Translating Content - you can translate the documentation, user interface, and any other relevant content.

• Cultural Adaptation - whenever you translate a project, be sure that the content is relevant to the culture and aligns with local contexts.

Participate in Quality Assurance and Testing

It may not seem like much, but testing is crucial for maintaining any good open-source project. The good thing about testing is that even though you are not a developer you can contribute by:

• User Testing - this involves testing the projects under different use cases and giving feedback on any encountered bugs, glitches, and issues. This feedback will help make the project better for the next development face.

• Beta Testing - this involves being part of testing products before they are officially released. Help identify any issues that the end user might encounter.

Engage with the Community

Having a strong community creates a safe space where contributors can focus on major things like improving the software's quality and ensuring the long-term sustainability of the project. You can contribute by:

• Moderation - you can offer to moderate discussion forums, chat rooms, and community platforms to ensure a positive and inclusive environment.

• Answering Questions - you can assist other community members by answering any questions that they may have.

Do Marketing and Outreach

The more an open source project is visible to the community, the better - and this includes visibility on social platforms. If you have marketing or communication skills you can contribute by:

• Promoting the projects on social media platforms.

• Writing tutorials and articles that highlight features offered by different projects, along with their importances and use cases.

Help with Fundraising and Donations

Lack of adequate funds to support the project's growth and sustainability may lead to its collapse before you even know it. A good way to address such a problem is by:

• Fundraising initiatives - organizing fundraising campaigns to support the project financially.

• Sponsorship outreach - applying for grants, seeking sponsorship, and joining incubator programs.

Best Practices for Quality Contributions

Contributing to open-source is not just about writing code, it's about creating high-quality and valuable contributions that will make the project easily accessible to others.

Here are some best practices that will help you contribute code that is clean, easy to maintain, and follows the industry standards.

Write Clean and Maintainable Code

Clean code can be described as code that is easy to read, understand, and maintain.

By writing clean code you will not only make it easier for others to read through but also for your future self.

When trying to write clean code, here are some key best practices:

• Use meaningful variable, function, and class names.

• Break down the code into smaller managable sections.

• Make use of comments to provide additional context.

• Maintain consistency in your coding style.

• Don't Repeat Yourself (DRY)

Test and Document Your Code

• Always write unit tests, integration tests, and end-to-end tests to ensure that the code works correctly.

• Remember to always document your development progress. This includes the code's purpose, usage instruction, and so on.

How to Handle Challenges

Being a new person in any field, you are bound to encounter different challenges that may make you question your desire to contribute.

But you can also see the challenges as stepping stones rather than roadblocks, preparing you to be a better contributor.

How to handle rejection and criticism

Rejection and criticism can be tough to handle, especially for beginners. Not everyone in a community can be as welcoming as we'd like, but just remember – this experience is still an opportunity of focus and improvement.

In case you encounter rejection and criticism, here are a few things to help you overcome them:

• Maintain a growth mindset - approach the rejection with an open mind and view it as a chance for you to learn and improve on your skills.

• Ask for feedback - in a case you have made a contribution and it has been rejected, always ask for feedback. This will help guide your future contributions while at the same time improving your skills

• Learn from others - before making your contributions, take time to learn from what other experienced contributors are doing. This can help you know how to structure your code, write documentation, and how to address issues. In return you will be on the safe side while making your contributions.

• Be persistent - use rejection as a motivation to refine your work and resubmit again.

How to ask for help

Many beginners, not only in the open-source world but in other fields as well, may be hesitant to ask for help. This is often because they don't want to appear to be inexperienced.

If you find yourself feeling this way, you may be forgetting that you're new to the field, and asking for assistance is part of the learning process. Even if you're a more seasoned contributor, you may still feel insecure at times (imposter syndrome, anyone?) - and this is ok. Everyone has their doubts at times. Just keep pushing forward.

As a beginner in open-source, to ensure that you receive the help you need, here are some tips:

• Do your research - attempt to solve the issue by yourself first before seeking help. This demonstrates your commitment to learning and problem solving skills.

• Be specific - provide detailed info about the problem you are facing. This can include mentioning the steps you have taken so far, the result you have gotten, highlighting the errors you faced, and so on. The more detailed the question, the easier it is for others to help you.

Strategies for Overcoming Common Challenges

1. Time management - balancing between open-source and personal work can be challenging sometimes. Be sure to set realistic goals and avoid overcommitting.

2. Impostor syndrome - this is where you feel inadequate despite there being solid evidence of your skills. Remember that we all begin somewhere – just try to appreciate your learning journey and focus on your progress.

3. Large code bases can be overwhelming to beginners. As a good practice, start small and work your way up as you gain more confidence and familiarize yourself with the codebase.

4. Burnout prevention - prioritize self-care, take breaks when necessary, and always remember that making small steps is more valuable than overwhelming yourself with a task.

How to Showcase Your Open-Source Contributions

Just like in any other field of work, you need to market yourself. And one of the best ways to do that is by showcasing your projects and contributions online. It's time to shine a spotlight on your work.

In return, this may attract potential employers, collaborators, and give you recognition in the broader tech ecosystem.

Build an online portfolio/profile

The most common way to showcase any form of work online is through personal portfolio and here is how you can achieve this to showcase your open-source contributions:

Begin by selecting a platform that best works for you. This might include GitHub pages, your personal website, and platforms like Behance or Dribbble for designer-related projects.

Now that you have a platform, organize you your work in categories including a brief description, role played, and any challangages you might have encountered.

Remember to add code samples for different projects you have wokred on and a brief explanation of what the project/code does.

Finally, add a short bio that highlights your passion for open source and technology. Make it engaging and relatable.

Highlight your contributions on your résumé/social media platforms

This is mostly helpful when potential employers are reviewing your résumé or GitHub/LinkedIn profile. Your contributions may set you apart from other applicants.

Here is how you can utilize this to stand out:

• Have a dedicated section where you can list all your open-source contributions and a brief description of your involvement.

• Quantify the impact that you contribution played to the success of the project.

• Highlight the skills you gained through contributing to open-source.

• If you have an online profile, be sure to include a link of it on your resume, this will help recruiters explore your contribution in depth.

Networking

Networking can open doors and connect you with multiple opportunities.

Here is how you can leverage your open-source experience for networking purposes:

• Talk about your contributions to open-source projects. This can be through sharing insights, asking questions, and so on.

• Attend meetups and conferences related to technologies you have worked with or have experince in.

• Connect with fellow contributors on platforms such as GitHub.

• Take part in hackathons, workshops, mentorships and collaborative coding events with people os same interest.

• Share your thought by writing tutorials about your open-source experiences, challenges you've overcome, and lessons you've learned.

Conclusion

As you come to the end of this guide, take a moment to reflect on the journey. You have gained valuable insights while at the same time discovering how impactful you contributions can be no matter how small they are.

If you have contributed to open-source before, think back to when you first began your open-source journey. Remember the joy you felt when your first PR was merged, the satisfaction you had when you solved that bug, wrote that line of code, resolved that issue, or updated that documentation.

All this has left a mark on the projects you have worked on. Be proud of yourself 😊.

Remember that the open-source community thrives on diversity, and every contribution, no matter how small, adds value. By participating in open source, you're contributing to a global movement that values transparency, cooperation, and the free exchange of knowledge.

Here's to your continued success in open-source contributions, learning, and making a difference.

Happy coding! 🚀🌍

Additional Resources

• Open Source Projects Every Developer Should Know About

• How to Use GitHub Actions to Automate Open-Source Projects

• GitHub Search Tips – How to Search Issues, Repos, and More Effectively on GitHub

• How to Write a Good README File for Your GitHub Project

• Developer Communities to Join to Help You Grow Your Tech Career

• How to Contribute to Open Source Projects – A Beginner's Guide

It is used in many industries because it is a highly flexible and powerful language.

Learning C is a worthwhile endeavor – no matter your starting point or aspirations – because it builds a solid foundation in the skills you will need for the rest of your programming career.

It helps you understand how a computer works underneath the hood, such as how it stores and retrieves information and what the internal architecture looks like.

With that said, C can be a difficult language to learn, especially for beginners, as it can be cryptic.

This handbook aims to teach you C programming fundamentals and is written with the beginner programmer in mind.

There are no prerequisites, and no previous knowledge of any programming concepts is assumed.

If you have never programmed before and are a complete beginner, you have come to the right place.

Here is what you are going to learn in this handbook:

• Chapter 1: Introduction to C Programming

• Chapter 2: Variables and Data Types in C

• Chapter 3: Operators in C

• Chapter 4: Conditional Statements in C

• Chapter 5: Loops in C

• Chapter 6: Arrays in C

• Chapter 7: Strings in C

• Further learning: Advanced C Topics

Without further ado, let’s get started with learning C!

Chapter 1: Introduction to C Programming

In this introductory chapter, you will learn the main characteristics and use cases of the C programming language.

You will also learn the basics of C syntax and familiarize yourself with the general structure of all C programs.

By the end of the chapter, you will have set up a development environment for C programming so you can follow along with the coding examples in this book on your local machine.

You will have successfully written, compiled, and executed your first simple C program that prints the text "Hello, world!" to the screen.

You will have also learned some core C language features, such as comments for documenting and explaining your code and escape sequences for representing nonprintable characters in text.

What Is Programming?

Computers are not that smart.

Even though they can process data tirelessly and can perform operations at a very high speed, they cannot think for themselves. They need someone to tell them what to do next.

Humans tell computers what to do and exactly how to do it by giving them detailed and step-by-step instructions to follow.

A collection of detailed instructions is known as a program.

Programming is the process of writing the collection of instructions that a computer can understand and execute to perform a specific task and solve a particular problem.

A programming language is used to write the instructions.

And the humans who write the instructions and supply them to the computer are known as programmers.

Low-level VS High-Level VS Middle-level Programming Languages – What's The Difference?

There are three types of programming languages: low-level languages, high-level languages, and middle-level languages.

Low-level languages include machine language (also known as binary) and assembly language.

Both languages provide little to no abstraction from the computer's hardware. The language instructions are closely related to or correspond directly to specific machine instructions.

This 'closeness to the machine' allows for speed, efficiency, less consumption of memory, and fine-grained control over the computer's hardware.

Machine language is the lowest level of programming languages.

The instructions consist of series of 0s and 1s that correspond directly to a particular computer’s instructions and locations memory.

Instructions are also directly executed by the computer’s processor.

Even though machine language was the language of choice for writing programs in the early days of computing, it is not a human-readable language and is time-consuming to write.

Assembly language allows the programmer to work closely with the machine on a slightly higher level.

It uses mnemonics and symbols that correspond directly to a particular machine’s instruction set instead of using sequences of 0s and 1s.

Next, high-level languages, like Python and JavaScript, are far removed from the instruction set of a particular machine architecture.

Their syntax resembles the English language, making them easier to work with and understand.

Programs written in high-level languages are also portable and machine-independent. That is, a program can run on any system that supports that language.

With that said, they tend to be slower, consume more memory, and make it harder to work with low-level hardware and systems because of how abstract they are.

Lastly, middle-level languages, like C and C++, act as a bridge between low-level and high-level programming languages.

They allow for closeness and a level of control over computer hardware. At the same time, they also offer a level of abstraction with instructions that are more human-readable and understandable for programmers to write.

What Is the C Programming Language?

C is a general-purpose and procedural programming language.

A procedural language is a type of programming language that follows a step-by-step approach to solving a problem.

It uses a series of instructions, otherwise known as procedures or functions, that are executed in a specific order to perform tasks and accomplish goals. These intructions tell the computer step by step what to do and in what order.

So, C programs are divided into smaller, more specific functions that accomplish a certain task and get executed sequentially, one after another, following a top-down approach.

This promotes code readability and maintainability.

A Brief History of the C Programming Language

C was developed in the early 1970s by Dennis Ritchie at AT&T Bell Laboratories.

The development of C was closely tied to the development of the Unix operating system at Bell Labs.

Historically, operating systems were typically written in Assembly language and without portability in mind.

During the development of Unix, there was a need for a more efficient and portable programming language for writing operating systems.

Dennis Ritchie went on to create a language called B, which was an evolution from an earlier language called BCPL (Basic Combined Programming Language).

It aimed to bridge the gap between the low-level capabilities of Assembly and the high-level languages used at the time, such as Fortran.

B was not powerful enough to support Unix development, so Dennis Ritchie developed a new language that took inspiration from B and BCPL and had some additional features. He named this language C.

C’s simple design, speed, efficiency, performance, and close relationship with a computer’s hardware made it an attractive choice for systems programming. This led to the Unix operating system being rewritten in C.

C Language Characteristics and Use Cases

Despite C being a relatively old language (compared to other, more modern, programming languages in use today), it has stood the test of time and still remains popular.

According to the TIOBE index, which measures the popularity of programming languages each month, C is the second most popular programming language as of August 2023.

This is because C is considered the "mother of programming languages" and is one of the most foundational languages of computer science.

Most modern and popular languages used today either use C under the hood or are inspired by it.

For example, Python’s default implementation and interpreter, CPython, is written in C. And languages such as C++ and C# are extensions of C and provide additional functionality.

Even though C was originally designed with systems programming in mind, it is widely used in many other areas of computing.

C programs are portable and easy to implement, meaning they can be executed across different platforms with minimal changes.

C also allows for efficient and direct memory manipulation and management, making it an ideal language for performance-critical applications.

And C provides higher-level abstractions along with low-level capabilities, which allows programmers to have fine-grained control over hardware resources when they need to.

These characteristics make C an ideal language for creating operating systems, embedded systems, system utilities, Internet of things (IoT) devices, database systems, and various other applications.

C is used pretty much everywhere today.

How to Set Up a Development Environment for C Programming on Your Local Machine

To start writing C programs on your local machine, you will need the following:

• A C Compiler

• An Integrated Development Environment (IDE)

C is a compiled programming language, like Go, Java, Swift, and Rust.

Compiled languages are different from interpeted languages, such as PHP, Ruby, Python, and JavaScript.

The difference between compiled and interpeted languages is that a compiled language is directly translated to machine code all at once.

This process is done by a special program called a compiler.

The compiler reads the entire source code, checks it for errors, and then translates the entire program into machine code. This is a language the computer can understand and it's directly associated with the particular instructions of the computer.

This process creates a standalone binary executable file containing sequences of 0s and 1s which is a more computer-friendly form of the initial source code. This file contains instructions that the computer can understand and run directly.

An interpeted language, on the other hand, doesn’t get translated into machine code all at once and doesn’t produce a binary executable file.

Instead, an interpreter reads and executes the source code one instruction at a time, line by line. The interpreter reads each line, translates it into machine code, and then immediately runs it.

If you are using a Unix or a Unix-like system such as macOS or Linux, you probably have the popular GNU Compiler Collection (GCC) already installed on your machine.

If you are running either of those operating systems, open the terminal application and type the following command:

gcc --version

If you're using macOS and have not installed the command line developer tools, a dialog box will pop-up asking you to install them – so if you see that, go ahead and do so.

If you have already installed the command line tools, you will see an output with the version of the compiler, which will look similar to the following:

Apple clang version 14.0.0 (clang-1400.0.29.202)

If you are using Windows, you can check out Code::Blocks or look into installing Linux on Windows with WSL. Feel free to pick whatever programming environment works best for you.

An IDE is where you write, edit, save, run, and debug your C programs. You can think of it like a word processor but for writing code.

Visual Studio Code is a great editor for writing code, and offers many IDE-like features.

It is free, open-source, supports many programming languages, and is available for all operating systems.

Once you have downloaded Visual Studio Code, install the C/C++ extension.

It’s also a good idea to enable auto-saving by selecting: "File" -> "Auto Save".

If you want to learn more, you can look through the Visual Studio Code documentation for C/C++.

With your local machine all set up, you are ready to write your first C program!

How to Write Your First C Program

To get started, open Visual Studio Code and create a new folder for your C program by navigating to "File" -> "Open" -> "New Folder".

Give this folder a name, for example, c-practice, and then select "Create" -> “Open".

You should now have the c-practice folder open in Visual Studio Code.

Inside the folder you just created, create a new C file.

Hold down the Command key and press N on macOS or hold down the Control and press N for Windows/Linux to create an Untitled-1 file.

Hold down the Command key and press S on macOS or hold down the Control key and press S for Windows/Linux, and save the file as a main.c file.

Finally, click "Save".

Make sure that you save the file you created with a .c extension, or it won’t be a valid C file.

You should now have the main.c file you just created open in Visual Studio Code.

Next, add the following code:

#include <stdio.h>

int main(void) {

  // output 'Hello, world!' to the console

  printf("Hello, world!\n");
}

Let’s go over each line and explain what is happening in the program.

What Are Header Files in C?

Let’s start with the first line, #include <stdio.h>.

The #include part of #include <stdio.h> is a preprocessor command that tells the C compiler to include a file.

Specifically, it tells the compiler to include the stdio.h header file.

Header files are external libraries.

This means that some developers have written some functionality and features that are not included at the core of the C language.

By adding header files to your code, you get additional functionality that you can use in your programs without having to write the code from scratch.

The stdio.h header file stands for standard input-output.

It contains function definitions for input and output operations, such as functions for gathering user data and printing data to the console.

Specifically, it provides functions such as printf() and scanf().

So, this line is necessary for the function we have later on in our program, printf(), to work.

If you don't include the stdio.h file at the top of your code, the compiler will not understand what the printf() function is.

What is the main() function in C?

Next, int main(void) {} is the main function and starting point of every C program.

It is the first thing that is called when the program is executed.

Every C program must include a main() function.

The int keyword in int main(void) {} indicates the return value of the main() function.

In this case, the function will return an integer number.

And the void keyword inside the main() function indicates that the function receives no arguments.

Anything inside the curly braces, {}, is considered the body of the function – here is where you include the code you want to write. Any code written here will always run first.

This line acts as a boilerplate and starting point for all C programs. It lets the computer know where to begin reading the code when it executes your programs.

What Are Comments in C?

In C programming, comments are lines of text that get ignored by the compiler.

Writing comments is a way to provide additional information and describe the logic, purpose, and functionality of your code.

Comments provide a way to document your code and make it more readable and understandable for anyone who will read and work with it.

Having comments in your source code is also helpful for your future self. So when you come back to the code in a few months and don't remember how the code works, these comments can help.

Comments are also helpful for debugging and troubleshooting. You can temporarily comment out lines of code to isolate problems.

This will allow you to ignore a section of code and concentrate on the piece of code you are testing and working on without having to delete anything.

There are two types of comments in C:

• Single-line comments

• Multi-line comments

Single-line comments start with two forward slashes, //, and continue until the end of the line.

Here is the syntax for creating a single-line comment in C:

// I am a single-line comment

Any text written after the forward slashes and on the same line gets ignored by the compiler.

Multi-line comments start with a forward slash, /, followed by an asterisk, *, and end with an asterisk, followed by a forward slash.

As the name suggests, they span multiple lines.

They offer a way to write slightly longer explanations or notes within your code and explain in more detail how it works.

Here is the syntax for creating a multi-line comment in C:

/*
This is
a multi-line
comment
*/

What is the printf() function in C?

Inside the function's body, the line printf("Hello, World!\n"); prints the text Hello, World! to the console (this text is also known as a string).

Whenever you want to display something, use the printf() function.

Surround the text you want to display in double quotation marks, "", and make sure it is inside the parentheses of the printf() function.

The semicolon, ;, terminates the statement. All statements need to end with a semicolon in C, as it identifies the end of the statement.

You can think of a semicolon similar to how a full stop/period ends a sentence.

What Are Escape Sequences in C?

Did you notice the \n at the end of printf("Hello, World!\n");?

It's called an escape sequence, which means that it is a character that creates a newline and tells the cursor to move to the next line when it sees it.

In programming, an escape sequence is a combination of characters that represents a special character within a string.

They provide a way to include special characters that are difficult to represent directly in a string.

They consist of a backslash, \, also known as the escape character, followed by one or more additional characters.

The escape sequence for a newline character is \n.

Another escape sequence is \t. The \t represrents a tab character, and will insert a space within a string.

How to Compile and Run Your first C Program

In the previous section, you wrote your first C program:

#include <stdio.h>

int main(void) {

  // output 'Hello, world!' to the console

  printf("Hello, world!\n");
}

Any code you write in the C programming language is called source code.

Your computer doesn’t understand any of the C statements you have written, so this source code needs to be translated into a different format that the computer can understand. Here is where the compiler you installed earlier comes in handy.

The compiler will read the program and translate it into a format closer to the computer’s native language and make your program suitable for execution.

You will be able to see the output of your program, which should be Hello, world!.

The compilation of a C program consists of four steps: preprocessing, compilation, assembling, and linking.

The first step is preprocessing.

The preprocessor scans through the source code to find preprocessor directives, which are any lines that start with a # symbol, such as #include .

Once the preprocessor finds these lines, it substitutes them with something else.

For example, when the preprocessor finds the line #include <stdio.h>, the #include tells the preprocessor to include all the code from the stdio.h header file.

So, it replaces the #include <stdio.h> line with the actual contents of the stdio.h file.

The output of this phase is a modified version of the source code.

After preprocessing, the next step is the compilation phase, where the modified source code gets translated into the corresponding assembly code.

If there are any errors, compilation will fail, and you will need to fix the errors to continue.

The next step is the assembly phase, where the assembler converts the generated assembly code statements into machine code instructions.

The output of this phase is an object file, which contains the machine code instructions.

The last step is the linking phase.

Linking is the process of combining the object file generated from the assembly phase with any necessary libraries to create the final executable binary file.

Now, let’s go over the commands you need to enter to compile your main.c file.

In Visual Studio Code, open the built-in terminal by selecting "Terminal" -> "New Terminal".

Inside the terminal, enter the following command:

gcc main.c

The gcc part of the command refers to the C compiler, and main.c is the file that contains the C code that you want to compile.

Next, enter the following command:

ls

The ls command lists the contents of the current directory.

a.out  main.c

The output of this command shows an a.out file – this is the executable file containing the source code statements in their corresponding binary instructions.

The a.out is the default name of the executable file created during the compilation process.

To run this file, enter the following command:

./a.out

This command tells the computer to look in the current directory, ./, for a file named a.out.

The above command generates the following output:

Hello, world!

You also have the option to name the executable file instead of leaving it with the default a.out name.

Say you wanted to name the executable file helloWorld.

If you wanted to do this, you would need to enter the following command:

gcc -o helloWorld main.c

This command with the -o option (which stands for output) tells the gcc compiler to create an executable file named helloWorld.

To run the new executable file that you just created, enter the following command:

./helloWorld

This is the output of the above command:

Hello, world!

Note that whenever you make a change to your source code file, you have to repeat the process of compiling and running your program from the beginning to see the changes you made.

Chapter 2: Variables and Data Types

In this chapter, you will learn the basics of variables and data types – the fundamental storage units that allow you to preserve and manipulate data in your programs.

By the end of this chapter, you will know how to declare and initialize variables.

You will also have learned about various data types available in C, such as integers, floating-point numbers, and characters, which dictate how information is processed and stored within a program's memory.

Finally, you'll have learned how to receive user input in your programs, and how to use constants to store values that you don't want to be changed.

What Is a Variable in C?

Variables store different kind of data in the computer's memory, and take up a certain amount of space.

By storing information in a variable, you can retrieve and manipule it, perform various calculations, or even use it to make decisions in your program.

The stored data is given a name, and that is how you are able to access it when you need it.

How to Declare Variables in C

Before you can use a variable, you need to declare it – this step lets the compiler know that it should allocate some memory for it.

C is a strongly typed language, so to declare a variable in C, you first need to specify the type of data the variable will hold, such as an integer to store a whole number, a floating-point number for numbers with decimal places, or a char for a single character.

That way, during compilation time, the compiler knows if the variable is able to perform the actions it was set out to do.

Once you have specified the data type, you give the variable a name.

The general syntax for declaring variables looks something like this:

data_type variable_name;

Let's take the following example:

#include <stdio.h>

int main(void) {

    int age;
}

In the example above, I declared a variable named age that will hold integer values.

What Are the Naming Conventions for Variables in C?

When it comes to variable names, they must begin either with a letter or an underscore.

For example, age and _age are valid variable names.

Also, they can contain any uppercase or lowercase letters, numbers, or an underscore character. There can be no other special symbols besides an underscore.

Lastly, variable names are case-sensitive. For example, age is different from Age.

How to Initialize Variables in C

Once you've declared a variable, it is a good practice to intialize it, which involves assigning an initial value to the variable.

The general syntax for initialzing a variable looks like this:

data_type variable_name = value;

The assignment operator, =, is used to assign the value to the variable_name.

Let's take the previous example and assign age a value:

#include <stdio.h>

int main(void) {

    int age;

    age = 29;
}

I initialized the variable age by assigning it an integer value of 29.

With that said, you can combine the initialization and declaration steps instead of performing them separately:

#include <stdio.h>

int main(void) {

    // declaration + initialization
    int age = 29;
}

How to Update Variable Values in C

The values of variables can change.

For example, you can change the value of age without having to specify its type again.

Here is how you would change its value from 29 to 30:

#include <stdio.h>

int main(void) {

    // the variable age with its original value
    int age = 29;

    // changing the value of age
    // the new value will be 30
    age = 30;
}

Note that the data type of the new value being assigned must match the declared data type of the variable.

If it doesn't, the program will not run as expected. The compiler will raise an error during compilation time.

#include <stdio.h>

int main(void) {

    int age = 29;

    /*
    trying to assign a floating-point value
    to a variable with type int
    will cause an error in your program
    */
    age = 29.5;
}

What Are the Basic Data Types in C?

Data types specify the type of form that information can have in C programs. And they determine what kind of operations can be performed on that information.

There are various built-in data types in C such as char, int, and float.

Each of the data types requires different allocation of memory.

Before exploring each one in more detail, let’s first go over the difference between signed and unsigned data types in C.

Signed data types can represent both positive and negative values.

On the other hand, unsigned data types can represent only non-negative values (zero and positive values).

Wondering when to use signed and when to use unsigned data types?

Use signed data types when you need to represent both positive and negative values, such as when working with numbers that can have positive and negative variations.

And use unsigned data types when you want to ensure that a variable can only hold non-negative values, such as when dealing with quantities.

Now, let's look at C data types in more detail.

What Is the char Data Type in C?

The most basic data type in C is char.

It stands for "character" and it is one of the simplest and most fundamental data types in the C programming language.

You use it to store a single individual character such as an uppercase and lowercase letter of the ASCII (American Standard Code for Information Interchange) chart.

Some examples of chars are 'a' and 'Z'.

It can also store symbols such as '!', and digits such as '7'.

Here is an example of how to create a variable that will hold a char value:

#include <stdio.h>

int main(void) {

    char initial = 'D';

 }

Notice how I used single quotation marks around the single character.

This is because you can't use double quotes when working with chars.

Double quotes are used for strings.

Regarding memory allocation, a signed char lets you store numbers ranging from [-128 to 127], and uses at least 1 byte (or 8 bits) of memory.

An unsigned char stores numbers ranging from [0 to 255].

What Is the int Data Type in C?

An int is a an integer, which is also known as a whole number.

It can hold a positive or negative value or 0, but it can't hold numbers that contain decimal points (like 3.5).

Some examples of integers are 0, -3,and 9.

Here is how you create a variable that will hold an int value:

#include <stdio.h>

int main(void) {

    int age = 29;
 }

When you declare an int, the computer allocates at least 2 bytes (or 16 bits) of memory.

With that said, on most modern systems, an int typically allocates 4 bytes (or 32 bits) of memory.

The range of available numbers for a signed int is [-32,768 to 32,767] when it takes up 2 bytes and [-2,147,483,648 to 2,147,483,647] when it takes up 4 bytes of memory.

The range of numbers for an unsigned int doesn't include any of the negative numbers in the range mentioned for signed ints.

So, the range of numbers for unsigned ints that take up 2 bytes of memory is [0 to 65,535] and the range is [0 to 4,294,967,295] for those that take up 4 bytes.

To represent smaller numbers, you can use another data type – the short int. It typically takes up 2 bytes (or 16 bits) of memory.

A signed short int allows for numbers in a range from [-32,768 to 32,767].

An unsigned short int allows for numbers in a range from [0 to 65,535].

Use a short when you want to work with smaller integers, or when memory optimisation is critically important.

If you need to work with larger integers, you can also use other data types like long int or long long int, which provide a larger range and higher precision.

A long int typically takes up at least 4 bytes of memory (or 32 bits).

The values for a signed long int range from [-2,147,483,648 to 2,147,483,647].

And the values for an unsigned long int range from [0 to 4,294,967,295].

The long long int data type is able to use even larger numbers than a long int. It usually takes up 8 bytes (or 64 bits) of memory.

A signed long long int allows for a range from [-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807]

And an unsigned long long int has a range of numbers from [0 to 18,446,744,073,709,551,615].

What Is The float Data Type in C?

The float data type is used to hold numbers with a decimal value (which are also known as real numbers).

It holds 4 bytes (or 32 bits) of memory and it is a single-precision floating-point type.

Here is how you create a variable that will hold a float value:

#include <stdio.h>

int main(void) {

   float temperature = 68.5;
 }

A double is a floating point value and is the most commonly used floating-point data type in C.

It holds 8 bytes (or 64 bits) of memory, and it is a double-precision floating-point type.

Here is how you create a variable that will hold a double value:

#include <stdio.h>

int main(void) {

    double number = 3.14159;
 }

When choosing which floating-point data type to use, consider the trade-off between memory usage and precision.

A float has less precision that a double but consumes less memory.

Use a float when memory usage is a concern (such as when working with a system with limited resources) or when you need to perform calculations where high precision is not critical.

If you require higher precision and accuracy for your calculations and memory usage is not critical, you can use a double.

What Are Format Codes in C?

Format codes are used in input and output functions, such as scanf() and printf(), respectively.

They act as placeholders and substitutes for variables.

Specifically, they specify the expected format of input and output.

They tell the program how to format or interpret the data being passed to or read from the scanf() and printf() functions.

The syntax for format codes is the % character and the format specifier for the data type of the variable.

Let's take the following example:

#include<stdio.h>

int main(void)
{
    int age = 29;

    printf("My age is %i\n", age);  // My age is 29
}

In the example above, age is the variable in the program. It is of type int.

The format code – or placeholder – for integer values is %i. This indicates that an integer should be printed.

In the program's output, %i is replaced with the value of age, which is 29.

Here is a table with the format specifiers for each data type:

How to Recieve User Input Using the scanf() Function

Earlier you saw how to print something to the console using the printf() function.

But what happens when you want to receive user input? This is where the scanf() function comes in.

The scanf() function reads user input, which is typically entered via a keyboard.

The user enters a value, presses the Enter key, and the value is saved in a variable.

The general syntax for using scanf() looks something similar to the following:

scanf("format_string", &variable);

Let's break it down:

• format_string is the string that lets the computer know what to expect. It specifies the expected format of the input. For example, is it a word, a number, or something else?

• &variable is the pointer to the variable where you want to store the value gathered from the user input.

Let's take a look at an example of scanf() in action:

#include <stdio.h>

int main(void) {

  int number;

  printf("Please enter your age: ");

  scanf("%i", &number);

  printf("Your age is %i\n", number);
}

In the example above, I first have to include the stdio.h header file, which provides input and output functions in C.

Then, in the main() function, I declare a variable named number that will hold integer values. This variable will store the user input.

Then, I prompt the user to enter a number using the printf() function.

Next, I use scanf() to read and save the value that the user enters.

The format specifier %i lets the computer known that it should expect an integer input.

Note also the & symbol before the variable name. Forgetting to add it will cause an error.

Lastly, after receiving the input, I display the received value to the console using another printf() function.

What are Constants in C?

As you saw earlier on, variable values can be changed throughout the life of a program.

With that said, there may be times when you don’t want a value to be changed. This is where constants come in handy.

In C, a constant is a variable with a value that cannot be changed after declaration and during the program's execution.

You can create a constant in a similar way to how you create variables.

The differences between constants and variables is that with constants you have to use the const keyword before mentioning the data type.

And when working with constants, you should always specify a value.

The general syntax for declaring constants in C looks like this:

const data_type constant_name = value;

Here, data_type represents the data type of the constant, constant_name is the name you choose for the constant, and value is the value of the constant.

It is also best practice to use all upper case letters when declaring a constant’s name.

Let’s see an example of how to create a constant in C:

#include <stdio.h>

int main(void) {

    const int LUCKY_NUM = 7;

    printf("My lucky number is: %i\n", LUCKY_NUM);
}

In this example, LUCKY_NUM is defined as a constant with a value of 7.

The constant's name, LUCKY_NUM, is in uppercase letters, as this is a best practice and convention that improves the readability of your code and distinguishes constants from variables.

Once defined, it cannot be modified in the program.

If you try to change its value, the C compiler will generate an error indicating that you are attempting to modify a constant.

#include <stdio.h>

int main(void) {

    const int LUCKY_NUM = 7;

    printf("My lucky number is: %i\n", LUCKY_NUM);

    LUCKY_NUM = 13; // this will cause an error

}

Chapter 3: Operators

Operators are essential building blocks in all programming languages.

They let you perform various operations on variables and values using symbols.

And they let you compare variables and values against each other for decision-making computatons.

In this chapter, you will learn about the most common operators in C programming.

You will first learn about arithmetic operators, which allow you to perform basic mathematical calculations.

You will then learn about relational (also known as comparisson operators), which help you compare values.

And you will learn about logical operators, which allow you to make decisions based on conditions.

After understanding these fundamental operators, you'll learn about some additional operators, such as assignment operators, and increment and decrement operators.

By the end of this chapter, you will have a solid grasp of how to use different operators to manipulate data.

What Are the Arithmetic Operators in C?

Arithmetic operators are used to perform basic arithmetic operations on numeric data types.

Operations include addition, subtraction, multiplication, division, and calculating the remainder after division.

These are the main arithmetic operators in C:

Let's see examples of each one in action.

How to Use the Addition (+) Operator

The addition operator adds two operands together and returns their sum.

#include <stdio.h>

int main(void) {

    int a = 5;

    int b = 3;

    int sum = a + b;

    printf("Sum: %i\n", sum); // Output: Sum: 8
}

How to Use the Subtraction (-) Operator

The subtraction operator subtracts the second operand from the first operand and returns their difference.

#include <stdio.h>

int main(void) {

    int a = 10; 

    int b = 5;

    int difference = a - b;

    printf("Difference: %i\n", difference); // Output: Difference: 5
}

How to Use the Multiplication (*) Operator

The multiplication operator multiplies two operands and returns their product.

#include <stdio.h>

int main(void) {

    int a = 4;

    int b = 3;

    int product = a * b;

    printf("Product: %i\n", product); // Output: Product: 12
}

How to Use the Division (/) Operator

The division operator divides the first operand by the second operand and returns their quotient.

#include <stdio.h>

int main(void) {

    int a = 10;

    int b = 2;

    int quotient = a / b;

    printf("Quotient: %i\n", quotient); // Output: Quotient: 5
}

How to Use the Modulo (%) Operator

The modulo operator returns the remainder of the first operand when divided by the second operand.

#include <stdio.h>

int main(void) {

    int a = 10;

    int b = 3;

    int remainder = a % b;

    printf("Remainder: %i\n", remainder); // Output: Remainder: 1
}

The modulo operator is commonly used to determine whether an integer is even or odd.

If the remainder of the operation is 1, then the integer is odd. If there is no remainder, then the integer is even.

What Are The Relational Operators in C?

Relational operators are used to compare values and return a result.

The result is a Boolean value. A Boolean value is either true (represented by 1) or false (represented by 0).

These operators are commonly used in decision-making statements such as if statements, and while loops.

These are the relational operators in C:

Let’s see an example of each one in action.

How to Use the Equal to (==) Operator

The equal to operator checks if two values are equal.

It essentially asks the question, "Are these two values equal?"

Note that you use the comparisson operator (two equal signs – ==) and not the assignment operator (=) which is used for assigning a value to a variable.

#include <stdio.h>

int main(void) {

    int a = 5;

    int b = 5;

    int result = (a == b);

    printf("Result: %i\n", result); // Output: Result: 1
}

The result is 1 (true), because a and b are equal.

How to Use the Not equal to (!=) Operator

The not equal to operator checks if two values are NOT equal.

#include <stdio.h>

int main(void) {

    int a = 5; 

    int b = 3;

    int result = (a != b);

    printf("Result: %i\n", result); // Output: Result: 1
}

The result is 1 (true), because a and b are not equal.

How to Use the Greater than (>) Operator

This operator compares two values to check if one is greater than the other.

#include <stdio.h>

int main(void) {

    int a = 10;

    int  b = 5;

    int result = (a > b);

    printf("Result: %i\n", result); // Output: Result: 1
}

The result is 1 (true), because a is greater than b.

How to Use the Less than (<) Operator

This operator compares two values to check if one is less than the other.

#include <stdio.h>

int main(void) {

    int a = 10;

    int b = 5;

    int result = (a < b);

    printf("Result: %i\n", result); // Output: Result: 0
}

The result is 0 (false), because a is not less than b.

How to Use the Greater than or Equal to (>=) Operator

This operator compares two values to check if one is greater than or equal to the other.

#include <stdio.h>

int main(void) {

    int a = 5;

    int  b = 5;

    int result = (a >= b);

    printf("Result: %i\n", result); // Output: Result: 1
}

The result is 1 (true), because a is equal to b.

How to Use the Less than or equal to (<=) Operator

This operator compares two values to check if one is less than or equal the other.

#include <stdio.h>

int main(void) {

    int a = 1;

    int b = 5;

    int result = (a <= b);

    printf("Result: %i\n", result); // Output: Result: 1
}

The result is 1 (true), because a is less than b.

Logical Operators

Logical operators operate on Boolean values and return a Boolean value.

Here are the logical operators used in C:

Let's go into more detail on each one in the following sections.

How to Use the AND (&&) Operator

The logical AND (&&) operator checks whether all operands are true.

The result is true only when all operands are true.

Here is the truth table for the AND (&&) operator when you are working with two operands:

Let's take the following example:

The result of (10 == 10) && (20 == 20) is true because both operands are true.

Let's look at another example:

The result of (10 == 20) && (20 == 20) is false because one of the operands is false.

When the first operand is false, the second operand is not evaluated (since there's no point - it's already determined that the first operand is false, so the result can only be false).

How to Use the OR (||) Operator

The logical OR (||) operator checks if at least one of the operands is true.

The result is true only when at least one of the operands is true.

Here is the truth table for the OR (||) operator when you are working with two operands:

Let's look at an example:

The result of (10 == 20) || (20 == 20) is true because one of the operands is true.

Let's look at another example:

The result of (20 == 20) || (10 == 20) is true because one of the operands is true

If the first operand is true, then the second operator is not evaluated.

How to Use the NOT (!) Operator

The logical NOT (!) operator negates the operand.

If the operand is true, it returns false.

And if it is false, it returns true.

You may want to use the NOT operator when when you want to flip the value of a condition and return the opposite of what the condition evaluates to.

Here is the truth table for the NOT(!) operator:

Let's look at an example:

The result of !(10 == 10) is false.

The condition 10 == 10 is true, but the ! operator negates it so the result is false.

And let's look at another example:

The result of !(10 == 20) is true.

The condition 10 == 20 is false, but the ! operator negates it.

What Is the Assignement Operator in C?

The assignment operator is used to assign a value to a variable.

#include <stdio.h>

int main(void) {

    // declare an integer variable named num
    int num;

    // assign the value 10 to num
    num = 10;

    printf("num: %i\n", num); // Output: num: 10

}

In the example above, the value 10 is assigned to the variable num using the assignment operator.

The assignment operator works by evaluating the expression on the right-hand side and then storing its result in the variable on the left-hand side.

The type of data assigned should match the data type of the variable.

How to Use Compound Assignment Operators

Compound assignment operators are shorthand notations.

They allow you to modify a variable by performing an operation on it and then storing the result of the operation back into the same variable in a single step.

This can make your code more concise and easier to read.

Some common compound assignment operators in C include:

• +=: Addition and assignment

• =: Subtraction and assignment

• =: Multiplication and assignment

• /=: Division and assignment

• %=: Modulo and assignment

Let’s see an example of how the += operator works:

#include <stdio.h>

int main(void) {

  int num = 10;

  num += 5; 

  printf("Num: %i\n", num); // Num: 15
}

In the example above, I created a variable named num and assigned it an initial value of 10.

I then wanted to increment the variable by 5. To do this, I used the += compound operator.

The line num += 5 increments the value of num by 5, and the result (15) is stored back into num in one step.

Note that the num += 5; line works exactly the same as doing num = num + 5, which would mean num = 10 + 5, but with fewer lines of code.

What Are the Increment and Decrement Operators in C?

The increment ++ and decrement -- operators increment and decrement a variable by one, respectively.

Let’s look at an example of how to use the ++ operator:

#include <stdio.h>

int main(void) {

  int num = 10;
  num++;

  printf("Num: %i\n", num); // Num: 11

}

The initial value of the variable num is 10.

By using the ++ increment operator, the value of num is set to 11.

This is like perfoming num = num + 1 but with less code.

The shorthand for decrementing a variable by one is --.

If you wanted to decrement num by one, you would do the following:

#include <stdio.h>

int main(void) {

  int num = 10;
  num--;

  printf("Num: %i\n", num); // Num: 9

}

The initial value of the variable num is 10.

By using the -- increment operator, the value of num is now set to 9.
This is like perfoming num = num - 1.

Chapter 4: Conditional Statements

The examples you have seen so far all execute line by line, from top to bottom.

They are not flexible and dynamic and do not adapt according to user behavior or specific situations.

In this chapter, you will learn how to make decisions and control the flow of a program.

You get to set the rules on what happens next in your programs by setting conditions using conditional statements.

Conditional statements take a specific action based on the result of a comparisson that takes place.

The program will decide what the next steps should be based on whether the conditions are met or not.

Certain parts of the program may not run depending on the results or depending on certain user input. The user can go down different paths depending on the various forks in the road that come up during a program's life.

First, you will learn about the if statement – the foundational building block of decision-making in C.

You will also learn about the else if and else statements that are added to the if statement to provide additional flexibility to the program.

You will then learn about the ternary operator which allows you to condense decision-making logic into a single line of code and improve the readability of your program.

How to Create an if statement in C

The most basic conditional statement in C is the if statement.

It makes a decision based on a condition.

If the given condition evaluates to true only then is the code inside the if block executed.

If the given condition evaluates to false, the code inside the if block is ignored and skipped.

The general syntax for an if statement in C is the following:

if (condition) {
  // run this code if condition is true
}

Let's look at an example:

#include <stdio.h>

int main(void) {

    // variable age
   int age;

   // prompt user to enter their age
   printf("Please enter your age: ");

   // store user's answer in the variable
   scanf("%i", &age);

    // check if age is less than 18
    // if it is, then and only then, print a message to the console

   if (age < 18) {
       printf("You need to be over 18 years old to continue\\n");
   }
}

In the above code, I created a variable named age that holds an integer value.

I then prompted the user to enter their age and stored the answer in the variable age.

Then, I created a condition that checks whether the value contained in the variable age is less than 18.

If so, I want a message printed to the console letting the user know that to proceed, the user should be at least 18 years of age.

When asked for my age and I enter 16, I'd get the following output:

#output

Please enter your age: 16
You need to be over 18 years old to continue

The condition (age < 18) evaluates to true so the code in the if block executes.

Then, I re-compile and re-run the program.

This time, when asked for my age, say I enter 28, but I don't get any output:

#output

Please enter your age: 28

This is because the condition evaluates to false and therefore the body of the if block is skipped.

I have also not specified what should happen in the case that the user's age is greater than 18.

To specify what happens in case the user's age is greater than 18, I can use an if else statement.

How to Create an if else statement in C

You can add an else clause to an if statement to provide code that will execute only when the if statement evaluates to false.

The if else statement essentially means that "if this condition is true do the following thing, else do this thing instead".

If the condition inside the parentheses evaluates to true, the code inside the if block will execute.

But if that condition evaluates to false, the code inside the else block will execute.

The else keyword is the solution for when the if condition is false and the code inside the if block doesn't run. It provides an alternative.

The general syntax looks like this:

if (condition) {
  // run this code if condition is true
} else {
  // if the condition above is false, run this code
}

Now, let's revisit the example from the previous section, and specify what should happen if the user's age is greater than 18:

#include <stdio.h>

int main(void) {
   int age;

   printf("Please enter your age: ");

   scanf("%i", &age);


    // if the condition in the parentheses is true the code inside the curly braces will execute
    // otherwise it is skipped
    // and the code in the else block will execute

   if (age < 18) {
       printf("You need to be over 18 years old to continue\n");
   } else {
      printf("You are over 18 so you can continue \n");
  }

   }

If the condition is true the code in the if block runs:

#output

Please enter your age: 14
You need to be over 18 years old to continue

If the condition is false the code in the if block is skipped and the code in the else block runs instead:

#output

Please enter your age: 45
You are over 18 so you can continue

How to Create an else if statement in C

But what happens when you want to have more than one condition to choose from?

If you wish to chose between more than one option you can introduce an else if statement.

An else if statement essentially means that "If this condition is true, do the following. If it isn't, do this instead. However, if none of the above are true and all else fails, finally do this."

The general syntax looks something like the following:

if (condition) {
   // if condition is true run this code
} else if(another_condition) {
   // if the above condition was false and this condition is true,
   // run the code in this block
} else {
   // if the two above conditions are false run this code
}

Let's see how an else if statement works.

Say you have the following example:

#include <stdio.h>

int main(void) {
   int age;

   printf("Please enter your age: ");

   scanf("%i", &age);

   if (age < 18) {
       printf("You need to be over 18 years old to continue\n");
   }  else if (age < 21) {
       printf("You need to be over 21\n");
   } else {
      printf("You are over 18 and older than 21 so you can continue \n");
  }

   }

If the first if statement is true, the rest of the block will not run:

#output

Please enter your age: 17
You need to be over 18 years old to continue

If the first if statement is false, then the program moves on to the next condition.

If that is true the code inside the else if block executes and the rest of the block doesn't run:

#output

Please enter your age: 20
You are need to be over 21

If both of the previous conditions are all false, then the last resort is the else block which is the one to execute:

#output

Please enter your age: 22
You are over 18 and older than 21 so you can continue

How to Use the Ternary Operator in C

The ternary operator (also known as the conditional operator) allows you to write an if else statement with fewer lines of code.

It can provide a way of writing more readable and concise code and comes in handy when writing simple conditional expressions.

You would want to use it when you are making making simple decisions and want to keep your code concise and on one line.

However, it's best to stick to a regular if-else statement when you are dealing with more complex decisions as the ternary operator could make your code hard to read.

The general syntax for the ternary operator looks something similar to the following:

condition ? expression_if_true : expression_if_false;

Let's break it down:

• condition is the condition you want to evaluate. This condition will evaluate to either true of false

• ? separates the condition from the two possible expressions

• expression_if_true is executed if the condition evaluates to true

• : separates the expression_if_true from the expression_if_false

• expression_if_false is executed if the condition evaluates to false.

Let's take a look at an example:

#include <stdio.h>

int main(void) {

    int x = 10;

    int y = (x > 5) ? 100 : 200;

    printf("x: %i\n", x); // x: 10

    printf("y: %i\n", y);  // y: 100
   }

In the example above, the condition is (x > 5).

If x is greater than 5, the condition evaluates to true. And when the condition is true, the value assigned to y will be 100.

If the condition evaluates to false, the value assigned to y will be 200.

So, since x is greater than 5 (x = 10), y is assigned the value 100.

Chapter 5: Loops

In this chapter you will learn about loops, which are essential for automating repetitive tasks without having to write the same code multiple times.

Loops allow you to execute a specific block of code instructions repeatedly over and over again until a certain condition is met.

You will learn about the different types of loops, such as the for , while and do-while loops, and understand their syntax and when you should use each one.

You will also learn about the break statement, which allows you to control the execution flow within loops in specific ways.

How to Create a for Loop in C

A for loop allows you to execute a block of code repeatedly based on a specified condition.

It's useful when you know how many times you want to repeat a certain action.

The general syntax for a for loop looks like this:

for (initialization; condition; increment/decrement) {
    // Code to be executed in each iteration
}

Let's break it down:

• initialization is the step where you initialize a loop control variable. It's typically used to set the starting point for your loop.

• condition is the condition that is evaluated before each iteration. If the condition is true, the loop continues. If it's false, the loop terminates. The loop will run as long as the condition remains true.

• increment/decrement is the part responsible for changing the loop control variable after each iteration. It can be an increment (++), a decrement (--), or any other modification.

• Code to be executed in each iteration is the block of code inside the for loop's body that gets executed in each iteration if the condition is true.

Let's see an example of how a for loop works.

Say you want to print the numbers from 1 to 5 to the console:

#include <stdio.h>

int main() {

    for (int i = 1; i <= 5; i++) {
        printf("Iteration %i\n", i);
    }

}

Output:

Iteration 1
Iteration 2
Iteration 3
Iteration 4
Iteration 5

In the example above, I first initialize the loop control variable i with a value of 1.

The condition i <= 5 is true, so the loop's body is executed and "Iteration 1" is printed.

After each iteration, the value of i is incremented by 1. So, i is incremented to 2.

The condition is still true, so "Iteration 2" is printed.

The loop will continue as long as i is less than or equal to 5.

When i becomes 6, the condition evaluates to false and the loop terminates.

How to Create a while Loop in C

As you saw in the previous section, a for loop is used when you know the exact number of iterations you want the loop to perform.

The while loop is useful when you want to repeat an action based on a condition but don't know the exact number of iterations beforehand.

Here is the general syntax of a while loop:

while (condition) {
    // Code to be executed in each iteration
}

With a while loop, the condition is evaluated before each iteration. If the condition is true, the loop continues. If it's false, the loop terminates.

The while loop will continue as long as the condition evaluates to true.

Something to note with while loops is that the code in the loop's body is not guaranteed to run even at least one time if a condition is not met.

Let's see an example of how a while loop works:

#include <stdio.h>

int main() {

    int count = 1;

    while (count <= 5) {

        printf("Iteration %i\n", count);

        count++;
    }

}

Output:

Iteration 1
Iteration 2
Iteration 3
Iteration 4
Iteration 5

In the example above, I first initialize a variable count with a value of 1.

Before it runs any code, the while loop checks a condition.

The condition count <= 5 is true because count is initially 1. So, the loop's body is executed and "Iteration 1" is printed.

Then, count is incremented to 2.

The condition is still true, so "Iteration 2" is printed.

The loop will continue as long as count is less than or equal to 5.

This process continues until count becomes 6, at which point the condition becomes false, and the loop terminates.

Something to be aware of when working with while loops is accidentally creating an infinite loop:

#include <stdio.h> 

int main(void)
{

    while(true)
    {
        printf("Hello world");
    }
}

In this case the condition always evaluates to true.

After printing the line of code inside the curly braces, it continuously checks wether it should run the code again.

As the answer is always yes (since the condition it needs to check is always true each and every time), it runs the code again and again and again.

The way to stop the program and escape from the endless loop is running Ctrl C in the terminal.

How to Create a do-while Loop in C

As mentioned in the previous section, the code in the while loop's body is not guaranteed to run even at least one time if the condition is not met.

A do-while loop executes a block of code repeatedly for as long as a condition remains true.

However, in contrast to a while loop, it is guaranteed to run at least once, regardless of whether the condition is true or false from the beginning.

So, the do-while loop is useful when you want to ensure that the loop's body is executed at least once before the condition is checked.

The general syntax for a do-while loop looks like this:

do {
    // Code to be executed in each iteration
} while (condition);

Let's take a look at an example that demonstrates how a do-while loop works:

#include <stdio.h>

int main() {

    int count = 1;

    do {
        printf("Iteration %i\n", count);

        count++;

    } while (count <= 5);

}

Output:

Iteration 1
Iteration 2
Iteration 3
Iteration 4
Iteration 5

In the example above I initialize a variable count with a value of 1.

A do-while loop first does something and then checks a condition.

So, the block of code inside the loop is executed at least one time.

The string "Iteration 1" is printed and then count is incremented to 2.

The condition count <= 5 is then checked and it evaluates to true, so the loop continues.

The loop will continue as long as count is less than or equal to 5.

After the iteration where count is 6, the condition becomes false, and the loop terminates.

How to Use the break Statement in C

The break statement is used to immediately exit a loop and terminate its execution.

It's a control flow statement that allows you to interrupt the normal loop execution and move on to the code after the loop.

The break statement is especially useful when you want to exit a loop under specific conditions, even if the loop's termination condition hasn't been met.

You might use it when you encounter a certain value, or when a specific condition is met.

Here's how to use a break statement in a loop:

#include <stdio.h>

int main() {
    int target = 5;

    for (int i = 1; i <= 10; i++) {
        printf("Current value: %i\n", i);

        if (i == target) {
            printf("Target value reached. Exiting loop.\n");
            break; // Exit the loop
        }
    }

}

Output:

Current value: 1
Current value: 2
Current value: 3
Current value: 4
Current value: 5
Target value reached. Exiting loop.

In the example above, a for loop is set to iterate from 1 to 10.

Inside the loop, the current value of i is printed on each iteration.

There is also an if statement that checks if the current value of i matches the target value, which is set to 5.

If i matches the target value, the if statement is triggered and a message is printed.

As a result, the break statement exits the current loop immediately and prematurely.

The program will continue executing the code that is after the loop.

Chapter 6: Arrays

Arrays offer a versatile and organized way to store multiple pieces of related data that are arranged in an ordered sequence.

They allow you to store multiple values of the same data type under a single identifier and perform repetitive tasks on each element.

In this chapter, you will learn how to declare and initialize arrays. You will also learn how to access individual elements within an array using index notation and modify them.

In addition, you will learn how to use loops to iterate through array elements and perform operations on each element.

How to Declare and Initialize an Array in C

To declare an array in C, you first specify the data type of the elements the array will store.

This means you can create arrays of type int, float, char, and so on.

You then specify the array's name, followed by the array's size in square brackets.

The size of the array is the number of elements that it can hold. This number must be a positive integer.

Keep in mind that arrays have a fixed size, and once declared, you cannot change it later on.

Here is the general syntax for declaring an array:

data_type array_name[array_size];

Here is how to declare an array of integers:

#include <stdio.h>

int main() {

   int grades[5];
}

In the example above, I created an array named grades that can store 5 int numbers.

After declaring an array, you can initialize it with initial values.

To do this, use the assignment operator, =, followed by curly braces, {}.

The curly braces will enclose the values, and each value needs to be separated by a comma.

Here is how to initialize the grades array:

#include <stdio.h>

int main() {

   int grades[5] = {50, 75, 100, 67, 90};
}

Keep in mind that the number of values should match the array size, otherwise you will encounter errors.

Something to note here is that you can also partially initialize the array:

#include <stdio.h>

int main() {

   int grades[5] = {50, 75, 100};
}

In this case, the remaining two elements will be set to 0.

Another way to initialize arrays is to omit the array's length inside the square brackets and only assign the initial values, like so:

#include <stdio.h>

int main() {

   int grades[] = {50, 75, 100, 67, 90};
}

In this example, the array's size is 5 because I assigned it 5 values.

How to Find the Length of an Array in C Using the sizeof() Operator

The sizeof operator comes in handy when you need to calculate the size of an array.

Let's see an example of the sizeof operator in action:

#include <stdio.h>

int main() {

    int grades[] = {50, 75, 100, 67, 90};

    // calculate the size of the array
    int array_size = sizeof(grades);

    printf("Size of array: %i bytes\n", array_size);
}

Output:

Size of array: 20 bytes

In the example above, sizeof(grades) calculates the total size of the array in bytes.

In this case, the array has five integers.

As mentioned in a previous chapter, on most modern systems an int typically occupies 4 bytes of memory. Therefore, the total size is 5 x 4 = 20 bytes of memory for the entire array.

Here is how you can check how much memory each int occupies using the sizeof operator:

#include <stdio.h>

int main() {

    int grades[] = {50, 75, 100, 67, 90};

    // calculate the size of a single array element
    int element_size = sizeof(grades[0]);

    printf("Size of a single element: %i bytes\n", element_size);

}

Output:

Size of a single element: 4 bytes

The sizeof(grades[0]) calculates the size of a single element in bytes.

By dividing the total size of the array by the size of a single element, you can calculate the number of elements in the array, which is equal to the array's length:

#include <stdio.h>

int main() {

    int grades[] = {50, 75, 100, 67, 90};

     int array_size = sizeof(grades);

     int element_size = sizeof(grades[0]);

     // calculate the length of the array
     int length = array_size / element_size;

    printf("Length of the array: %i elements\n", length);

}

Output:

Length of the array: 5 elements

How to Access Array Elements in C

You can access each element in an array by specifying its index or its position in the array.

Note that in C, indexing starts at 0 instead of 1.

So, the index of the first element is 0, the index of the second element is 1, and so on.

The last element in an array has an index of array_size - 1.

To access individual elements in the array, you specify the array's name followed by the element's index number inside square brackets ([]).

array_name[index];

Let's take a look at the following example:

#include <stdio.h>

int main() {

   int grades[] = {50, 75, 100, 67, 90};

   // Access each array element using index notation

   printf("Element at index 0: %i\n", grades[0]);  

   printf("Element at index 1: %i\n", grades[1]);  

   printf("Element at index 2: %i\n", grades[2]); 

   printf("Element at index 3: %i\n", grades[3]); 

   printf("Element at index 4: %i\n", grades[4]); 
}

Output:

Element at index 0: 50
Element at index 1: 75
Element at index 2: 100
Element at index 3: 67
Element at index 4: 90

In the example above, to access each item from the integer array grades, I have to specify the array's name along with the item's position in the array inside square brackets.

Remember that the index starts from 0, so grades[0] gives you the first element, grades[1] gives you the second element, and so on.

Note that if you try to access an element with an index number that is higher than array_size - 1, the compiler will return a random number:

#include <stdio.h>

int main() {

    int grades[] = {50, 75, 100, 67, 90};


    printf("Element at index 5: %d\n", grades[5]);  

}

Output:

Element at index 5: 220312136

How to Modify Array Elements in C

Once you know how to access array elements, you can then modify them.

The general syntax for modifying an array element looks like this:

array_name[index] = new_value;

You can change the value of an element by assigning a new value to it using its index.

Let's take the grades array from earlier on:

#include <stdio.h>

int main() {

   int grades[] = {50, 75, 100, 67, 90};
}

Here is how you would change the value 75 to 85:

#include <stdio.h>

int main() {

   int grades[] = {50, 75, 100, 67, 90};

   grades[1] = 85; // changing the value at index 1 to 85

   printf("Element at index 1: %i\n", grades[1]); 
}

Output:

Element at index 1: 85

When modifying arrays, keep in mind that the new value must match the declared data type of the array.

How to Loop Through an Array in C

By looping through an array, you can access and perform operations on each element sequentially.

The for loop is commonly used to iterate through arrays.

#include <stdio.h>

int main() {

    int grades[] = {50, 75, 100, 67, 90};

    for (int i = 0; i < 5; i++) {
        printf("Element at index %i: %i\n", i, grades[i]);
    }
}

Output:

Element at index 0: 50
Element at index 1: 75
Element at index 2: 100
Element at index 3: 67
Element at index 4: 90

When using a for loop to loop through an array, you have to specify the index as the loop variable, and then use the index to access each array element.

The %i placeholders are replaced with the current index i and the value at that index in the grades array, respectively.

You can also use a while loop to iterate through an array:

#include <stdio.h>

int main() {

    int grades[] = {50, 75, 100, 67, 90};

    int i = 0;

    while (i < 5) {

        printf("Element at index %i: %i\n", i, grades[i]);
        i++;
    }
}

Output:

Element at index 0: 50
Element at index 1: 75
Element at index 2: 100
Element at index 3: 67
Element at index 4: 90

When using a while loop to loop through an array, you will need an index variable, int i = 0, to keep track of the current position in the array.

The loop checks the condition (i < 5) and prints the index of the grade as well as the actual grade value.

After each grade is shown, the variable i is increased by one, and the loop continues until it has shown all the grades in the list.

A do-while works in a similar way to the while loop, but it is useful when you want to ensure that the loop body is executed at least once before checking the condition:

#include <stdio.h>

int main() {

     int grades[] = {50, 75, 100, 67, 90};

    int i = 0;

    do {
        printf("Element at index %i: %i\n", i, grades[i]);

        i++;
    } while (i < 5);
}

You can also use the sizeof operator to loop through an array.

This method is particularly useful to ensure your loop doesn't exceed the array's length:

#include <stdio.h>

int main() {

    int grades[] = {50, 75, 100, 67, 90};

    int length = sizeof(grades) / sizeof(grades[0]);

    for (int i = 0; i < length; i++) {
        printf("Element at index %i: %i\n", i, grades[i]);
    }

}

The line int length = sizeof(grades) / sizeof(grades[0]); calculates the length of the grades array.

The length is calculated by dividing the total size (in bytes) of the array by the size of a single element grades[0]. The result is stored in the length variable.

The loop then iterates through the array using this length value.

For each iteration, it prints the index i and the value of the grade at that index grades[i].

Chapter 7: Strings

In the previous chapter, you learned the basics of arrays in C.

Now, it's time to learn about strings – a special kind of array.

Strings are everywhere in programming. They are used to represent names, messages, passwords, and more.

In this chapter, you will learn about strings in C and how they are stored as arrays of characters.

You'll also learn the fundamentals of string manipulation.

Specifically, you will learn how to find a string's length and how to copy, concatenate, and compare strings in C.

What Are Strings in C?

A string is a sequence of characters, like letters, numbers, or symbols, that are used to represent text.

In C, strings are actually arrays of characters. And each character in the string has a specific position within the array.

Another unique characteristic of strings in C is that at the end of every one, there is a hidden \0 character called the 'null terminator'.

This terminator lets the computer know where the string ends.

So, the string 'Hello' in C is stored as 'Hello\0' in memory.

How to Create Strings in C

One way to create a string in C is to initialize an array of characters.

The array will contain the characters that make up the string.

Here is how you would initialize an array to create the string 'Hello':

#include <stdio.h>

int main() {
  char word[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

}

Note how I specified that the array should store 6 characters despite Hello being only 5 characters long. This is due to the null operator.

Make sure to include the null terminator, \0, as the last character to signify the end of the string.

Let's look at how you would create the string 'Hello world':

#include <stdio.h>

int main() {
  char phrase[12] = {'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '\0'};
}

In this example, there is a space between the word 'Hello' and the word 'world'.

So, the array must include a blank space character.

To print the string, you use the printf() function, the %s format code and the name of the array:

#include <stdio.h>

int main() {
  char phrase[] = {'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '\0'};

  printf("%s\n", phrase);

}

Another way to create a string in C is to use a string literal.

In this case, you create an array of characters and then assign the string by enclosing it in double quotes:

#include <stdio.h>

int main() {
  char word[] = "Hello";

}

With string literals, the null terminator (\0) is implied.

Creating strings with string literals is easier, as you don't need to add the null terminator at the end. This method is also much more readable and requires less code.

However, you may want to use character arrays when you want to modify the string's content. String literals are read-only, meaning the content is fixed.

How to Manipulate Strings in C

C provides functions that allow you to perform operations on strings, such as copying, concatenating, and comparing, to name a few.

To use these functions, you first need to include the string.h header file by adding the line #include <string.h> at the top of your file.

How to Find the Length of a String in C

To calculate the length of a string, use the strlen() function:

#include <stdio.h>
#include <string.h>

int main() {
  char phrase[] = "Hello";

  int length = strlen(phrase);

  printf("String length: %i\n", length);

}

Output:

String length: 5

The strlen() function will return the number of characters that make up the string.

Note that the result does not include the null terminator, \0.

How to Copy a String in C

To copy one string into another one, you can use the strcpy() function.

You may want to copy a string in C when you need to make changes to it without modifying it. It comes in handy when you need to keep the original string's content intact.

The general syntax for the strcpy() function looks like this:

strcpy(destination_string, original_string);

The strcpy() function copies original_string into destination_string, including the null terminator ('\0').

One thing to note here is that you need to make sure the destination array has enough space for the original string:

#include <stdio.h>
#include <string.h>

int main() {

    char original[] = "Hello";

    char destination[20]; // Make sure this array is big enough

    strcpy(destination, original);

    printf("Copied string: %s\n", destination);
}

Output:

Copied string: Hello

The strcpy() function copies the original string into an empty array and returns the copied string, which also includes the null terminator character ('\0').

How to Concatenate Strings in C

You can concatenate (add) two strings together by using the strcat() function.

The general syntax for the strcat() function looks something like the following:

strcat(destination_string, original_string);

The strcat() function takes the original string and adds it to the end of destination string.

Make sure that the destination_string has enough memory for the original_string.

Something to note here is that strcat() does not create a new string.

Instead, it modifies the original destination_string, by including the original_string at the end.

Let's see an example of how strcat() works:

#include <stdio.h>
#include <string.h>

int main(void) {

  char greeting[50] = "Hello, ";

  char name[] = "Dionysia";

  strcat(greeting, name);

  printf("Message: %s\n", greeting);

}

Output:

Message: Hello, Dionysia

How to Compare Strings in C

To compare two strings for equality, you can use the strcmp() function.

The general syntax for the strcmp() function looks like this:

strcmp(string1, string2);

The strcmp() function compares string1 with string2 and returns an integer.

If the return value of strcmp() is 0, then it means the two strings are the same:

#include <stdio.h>
#include <string.h>

int main() {

  char word1[] = "apples";
  char word2[] = "apples";

  int result = strcmp(word1, word2);

  printf("Result: %i\n", result); // Result: 0

}

If the return value of strcmp() is less than 0, then it means the first word comes before the second:

#include <stdio.h>
#include <string.h>

int main() {

  char word1[] = "apples";
  char word2[] = "bananas";

  int result = strcmp(word1, word2);

  printf("Result: %i\n", result); // Result: -1

}

And if the return value of strcmp() is greater than 0, then it means the first word comes after the second one:

#include <stdio.h>
#include <string.h>

int main() {

  char word1[] = "bananas";
  char word2[] = "apples";

  int result = strcmp(word1, word2);

  printf("Result: %i\n", result); // Result: 1

}

Further learning: Advanced C Topics

While this handbook has covered a wide range of topics, there is still so much to learn, as programming is so vast.

Once you have built a solid foundation with the basics of C programming, you may want to explore more advanced concepts.

You may want to move on to learning about functions, for example. They allow you to write instructions for a specific task and reuse that code throughout your program.

You may also want to learn about pointers. Pointers in C are like arrows that show you where a specific piece of information is stored in the computer's memory.

Then, you may want to move on to learning about structures. They're like custom data containers that allow you to group different types of information under one name.

Lastly, you may want to learn how to work with files. Working with files in C allows you to read from and write to files. This is useful for tasks like saving user data, reading configuration settings, or sharing data between different programs.

These suggestions are not a definitive guide – just a few ideas for you to continue your C programming learning journey.

If you are interested in learning more, you can check out the following freeCodeCamp resources:

• C Programming Tutorial for Beginners

• Learn C Programming Using the Classic Book by Kernighan and Ritchie

• Unlock the Mysteries of Pointers in C

Conclusion

This marks the end of this introduction to the C programming language.

Thank you so much for sticking with it and making it until the end.

You learned how to work with variables, various data types, and operators.

You also learned how to write conditional statements and loops. And you learned the basics of working with arrays and strings.

Hopefully, you have gained a good understanding of some of the fundamentals of C programming, got some inspiration on what to learn next, and are excited to continue your programming journey.

Happy coding!

Have you ever wondered how programs remember things and do tasks over and over again? Well, that's where functions and scope come into play.

Whether you're a curious beginner or someone looking to strengthen your coding skills, get ready to unlock the secrets of functions and scope.

By the end of this tutorial, you'll be equipped with the knowledge to create more organized, efficient, and dynamic code.

If you're new to JavaScript, I suggest reading my guide to JavaScript Basics before diving into this one.

Now, let's get into the fun stuff! 🚀

Table of Contents:

1. Introduction to JavaScript Functions and Scope

2. How to Declare and and Define Functions

3. Function Parameters and Arguments

4. Return Statements and Values in Functions

5. What are Anonymous Functions?

6. What are Function Expressions?

7. Arrow Functions and Their Impact on "this"

8. How Does Function and Variable Hoisting Work?

9. What is an IIFE (Immediately Invoked Function Expression)?

10. How to Use Default Parameters in a JavaScript Function

11. How to Use Rest Parameters and the Spread Operator in JavaScript Functions

12. How to Destructure Function Parameters

13. What are JavaScript Recursive Functions?

14. Function Scope and Closures in JavaScript

15. What are Lexical Scope and Closures?

16. Execution Context and the Call Stack

17. Debugging and Troubleshooting in JavaScript

18. Conclusion

Introduction to JavaScript Functions and Scope

Functions let you group lines of code together and give them a name. They're like special tools that help you organize your code and perform specific actions whenever you need them.

Instead of writing the same code over and over, you can use functions to make your life easier. Consider functions as mini-programs that you can use and reuse to make your code more organized and efficient.

Scope is another fascinating concept that affects how your code works. It's like a set of rules that determine where your variables are allowed to hang out. Sometimes they're free to roam anywhere, and other times they're only allowed to stay within certain boundaries.

Don't stress if it sounds a little fancy. I'm here to explain everything clearly with examples that make sense.

How to Declare and and Define Functions

Declaring a function is like announcing its name. Defining it is like giving it a purpose, this is where you put the code that the function will execute.

Here's an example of a simple function:

// This code is a function 

function greet(name) {
  console.log(`Hello, ${name}!`);
}

greet("Cas"); // Output: Hello, Cas!

In the above example, function called greet takes a name parameter and logs a greeting message using a template literal. Then, it calls the greet function with the argument "Cas" and outputs "Hello, Cas!".

Function Parameters and Arguments

Imagine functions as machines that take inputs (parameters) and produce outputs.

Parameters are like placeholders for these inputs. Arguments are the actual values you give the function.

Here's a code example:

function addNumbers(a, b) {  //a, b are parameters
  return a + b;
}

const result = addNumbers(5, 7);  //5,7 are arguments
console.log(result); // Output: 12

Return Statements and Values in Functions

Assume you're sending your friend on a quest. They head out, complete the task, and return with a valuable item. In the world of functions, this "item" is what we call the return value. They're not just doing tasks – they deliver gifts! 🎉

It's the answer, the result, the prize that your function hands over once it's done with its mission.

Let's break it down with an example:

function multiply(a, b) {
  const result = a * b;
  return result;  // The function gives back the 'result' as a gift
}

const product = multiply(3, 5);  // The function is called, and the return value is captured
console.log(product);  // Output: 15

In the above example, the multiply function does its math, packages up the answer (the product of 3 and 5), and hands it over using the return statement.

Whether it's calculations, data processing, or generating valuable information,
return values allow your functions to contribute more to your overall code. So, get ready to embrace this concept as you continue your journey through JavaScript functions.

What are Anonymous Functions?

Sometimes you don't need a named function. An anonymous function doesn't have a name – instead, it's defined directly where it's assigned. Anonymous functions are often used as callbacks or one-time-use functions.

Here's a code example:

const multiply = function(x, y) {
  return x * y;
}

This code defines an anonymous function assigned to the variable multiply, which takes two parameters x and y and returns their product when the function is called.

What are Function Expressions?

These come to play when assigning functions to variables, pass functions as arguments to other functions, or return functions from other functions. It's an alternative to the more common function declaration.

Here's a code example:

const add = function(a, b) {
  return a + b;
};

const result = add(5, 3);  // Call the function
console.log(result);  // Output: 8

In this example, a function expression named add was defined and assigned to the variable add. The function takes two parameters a and b, and it returns the sum of these two numbers.

Arrow Functions and Their Impact on "this"

This function behaves differently when it comes to the this keyword. Unlike regular functions, arrow functions don't create their own this context. Instead, they inherit the this value from their surrounding code.

Here's a code example showing that:

function regularFunction() {
  console.log(this);  // Refers to the caller
}

const arrowFunction = () => {
  console.log(this);  // Inherits from where it's defined
};

const obj = {
  regular: regularFunction,
  arrow: arrowFunction
};

obj.regular();  // 'this' refers to 'obj'
obj.arrow();    // 'this' still refers to 'obj', despite being in an arrow function

This code demonstrates the difference between regular functions and arrow functions regarding the usage of the this keyword. Arrow functions inherit the this context from where they are defined, while regular functions refer to the caller.

Another benefit of arrow functions is that they bring concise elegance to JavaScript. They're like a shorthand way of writing functions, perfect for simple tasks. When combined with default parameter values, they make your code even more streamlined.

Here's a code example of an arrow function with a default parameter:

const greet = (name = "friend") => {
  console.log(`Hello, ${name}!`);
};

greet();        // Output: Hello, friend!
greet("Cas"); // Output: Hello, Cas!

In this example, the name parameter has a default value of "friend".

Arrow functions are especially handy when you want a quick way to define a function with default parameters.

How Does Function and Variable Hoisting Work?

Hoisting is like setting up the stage before the play begins.

In JavaScript, function declarations are hoisted (raised) to the top of their containing scope. This means you can call a function before it's defined in your code.

Here's a code example:

// Function declaration (can be called anywhere)
sayHello(); // This code works

function sayHello() {
  console.log("Hello!");
}

The above code snippet works due to hoisting.

However, hoisting doesn't apply to function expressions:

// Function expreesion (called before defined)
sayHi();  // Error

const sayHi = function() {
  console.log("Hi!");
};


// Function expression (should be defined before calling)
const sayHello = function() {
  console.log("Hello!");
};

sayHello(); // This works

The sayHi function throws an error. Why? Because it's called before defined. This means that you must define a function expression before you attempt to call it.

Hoisting with the let and const Keywords has a slightly different behavior. They experience a temporal dead zone, just like the dancers waiting for their turn backstage.

The temporal dead zone in JavaScript refers to the period between the creation of a variable using the let or const keywords and the point where the variable is actually declared in the code.

During this period, if you try to access the variable, you'll get a reference error. This behavior is a result of how JavaScript's variable hoisting works with these block-scoped declarations.

Here's a code example:

console.log(myName);  // Throws an error - myName is not defined
let myName = "Cas";

In the above code, myName is hoisted, but trying to access it before the actual
declaration results in an error due to the temporal dead zone.

Note: While function hoisting can be helpful, it's a good practice to define your functions before using them to make your code more readable.

What is an IIFE (Immediately Invoked Function Expression)?

Ever wanted to execute a function right after defining it? That's where IIFEs come into play. They're like the express lane of JavaScript.

All you need to do is to define the function, wrap it in parentheses, and then add another pair of parentheses to call it immediately. You can personalize your IIFE by adding a parameter.

Here's a code example:

(function(name) {
  console.log(`Hello, ${name}!`);
})("Cas");

In this example, the IIFE takes the name "Cas" as a parameter and dances with it right away.

How to Use Default Parameters in a JavaScript Function

In the world of JavaScript functions, flexibility is key. Sometimes, you want your function to handle missing or undefined values without causing errors. That's where default parameter values come to the rescue.

Here's a code example:

function greet(name = "Guest") {
  console.log(`Hello, ${name}!`);
}

greet();          // Output: Hello, Guest!
greet("Cas");   // Output: Hello, Cas!

In the greet function, the name parameter has a default value of "Guest". If you call the function without providing an argument for name, it will use the default value. If you provide an argument, it will override the default value

How to Use Rest Parameters and the Spread Operator in JavaScript Functions

The Rest Parameter and the Spread Operator are two related concepts in JavaScript that deal with handling and manipulating function arguments and arrays.

Imagine you're hosting a party, and you want to gather all the dishes your guests are bringing. The rest parameter is like a magical dish collector that grabs all the items your guests bring and puts them into an array for you to enjoy.

Here's a code example:

function partyPlanner(mainDish, ...sideDishes) {
  console.log(`Main dish: ${mainDish}`);
  console.log(`Side dishes: ${sideDishes.join(', ')}`);
}

partyPlanner( "Jollof rice", "Fufu", "Pizza", "Salad", "Kpomo", "Fries");
// Output:
// Main dish: Jollof rice
// Side dishes: Fufu, Pizza, Salad, Kpomo, Fries

In this example, the ...sideDishes parameter collects all the extra values and packs them into an array, making it easy to work with varying numbers of inputs.

How to Destructure Function Parameters

Let's say you receive a gift box with various items, and you want to unpack them and select the items you need immediately.

Destructuring helps you unpack and use the parts you need from complex data, like objects or arrays.

Here's a code example:

function printPersonInfo({ firstName, lastName, age }) {
  console.log(`First Name: ${firstName}`);
  console.log(`Last Name: ${lastName}`);
  console.log(`Age: ${age}`);
}

const person = {
  firstName: 'Cas',
  lastName: 'Nuel',
  age: 30
};

printPersonInfo(person);
// Output:
// First Name: Cas
// Last Name: Nuel
// Age: 30

In this example, the printPersonInfo function takes an object parameter. Instead of accessing the object properties using person.firstName, person.lastName, person.Age, we use destructuring within the function parameter list to directly extract the properties. This makes the code cleaner and more readable. When you call printPersonInfo(person), the function will destructure the person object and print out its properties.

What are JavaScript Recursive Functions?

This is where a function calls itself to solve a problem by breaking it down into smaller, similar sub-problems.

Recursion involves two main components: a base condition that defines when the recursion should stop, and a recursive case where the function calls itself with modified parameters.

Here's a code example of a recursive function that calculates the factorial of a number:

function factorial(n) {
  // Base condition: factorial of 0 or 1 is 1
  if (n === 0 || n === 1) {
    return 1;
  }

  // Recursive case: call the function with a smaller sub-problem
  return n * factorial(n - 1);
}

const num = 5;
const result = factorial(num);
console.log(`Factorial of ${num} is ${result}`);

In this example, the factorial function calculates the factorial of a number n. The base condition checks if n is 0 or 1. If it is, the function immediately returns 1, as the factorial of 0 or 1 is 1. The recursive case multiplies n with the result of calling the factorial function with n - 1.

This creates a chain of recursive calls, each reducing the problem by one and stops when it reaches the base condition. The calculated values are returned up the chain.

For example, when calling factorial(5):

• factorial(5) returns 5 * factorial(4)

• factorial(4) returns 4 * factorial(3)

• factorial(3) returns 3 * factorial(2)

• factorial(2) returns 2 * factorial(1)

• factorial(1) returns 1

These values are then multiplied together, and the final result, which is 120, is obtained.

Recursion is a powerful technique, but it's essential to have a well-defined base condition to avoid infinite loops. Each recursive call should move towards the base case, ensuring that the problem gets smaller with each iteration.

Function Scope and Closures in JavaScript

With scope and closures you can organize your code, create private data, and build powerful functionalities.

It's like having little compartments in your coding toolbox that help you keep things tidy and efficient.

Global vs. Local Scope

You can think of global scope as the entire neighborhood where all your houses (variables) live. Variables declared here are accessible from anywhere in your code.

Here's a code example:

const globalVariable = "I'm global!";

function globalScopeExample() {
  console.log(globalVariable);  // Accessing the global variable
}

globalScopeExample();  // Output: I'm global!

This code defines a global variable globalVariable with a string value. Then, there's a function globalScopeExample that logs the value of globalVariable. The function is called, resulting in the output of the global variable's value.

On the other hand, local scope is like rooms within your houses. Variables declared inside functions or code blocks are local and can only be accessed within that function or block.

Here's a code example:

function localScopeExample() {
  const localVariable = "I'm local!";
  console.log(localVariable);  // Accessing the local variable
}

localScopeExample();  // Output: I'm local!
// console.log(localVariable);  // This would result in an error

This code defines a function localScopeExample that creates a variable localVariable inside the function and then prints its value. When the function is called, it outputs the value of the localVariable. Attempting to access localVariable outside the function will result in an error

What are Lexical Scope and Closures?

Lexical scope is a bit like those Russian nesting dolls. Each doll can access the dolls inside it, but not the other way around.

Similarly, in programming, it means an inner function can access variables from its outer function, but not vice versa.

Here's a code example:

function outer() {
  const outerVar = "I'm from outer function!";

  function inner() {
    console.log(outerVar);  // Accessing the outer variable
  }

  inner();
}

outer();  // Output: I'm from outer function!

This code defines an outer function outer which contains a variable outerVar. Inside outer, there's an inner function inner that logs the value of outerVar. When outer is called, it also calls inner, resulting in the output "I'm from outer function!".

How Closures Work and Why They're Important

Closures are like time capsules that hold onto variables even after their functions have finished running. They're a combination of a function and the environment in which it was created.

Here's a code example:

function rememberMe() {
  const secret = "I'm a secret!";
  return function() {
    console.log(secret);  // This inner function remembers the 'secret'
  };
}

const myClosure = rememberMe();
myClosure();  // Output: I'm a secret!

The code defines a function rememberMe() that creates and returns another function. This returned function, known as a closure, has access to the secret variable from its parent function's scope. When the myClosure function is invoked, it logs the value of the secret variable

Closures are great for creating private data or functions that only a specific part of your code can access.

Let's take another practical example of a closure:

function counter() {
  let count = 0;
  return function() {
    return ++count;
  };
}

const increment = counter();
console.log(increment());  // Output: 1
console.log(increment());  // Output: 2

The code creates a counter function that generates an incrementing counter each time it's called, demonstrating closure usage.

Execution Context and the Call Stack

Every time a function is called, JavaScript creates an execution context. A sort of environment for that function to run in. It keeps track of variables, references, and where the function was called from.

Think of it as a backstage area where the function's code runs. All the variables, functions, and parameters are stored here.

Here's a code example:

function first() {
  console.log("Hello from first!");
  second();  // Calling another function
}

function second() {
  console.log("Hello from second!");
}

first();  // Output: Hello from first! Hello from second!

In the above example, function first calls function second, creating a new execution context for second.

The Call Stack is like a to-do list of functions waiting to be executed. When a function is called, it's added to the top of the stack. When it's done, it's removed.
This stack of contexts is what keeps track of where your code is.

Debugging and Troubleshooting in JavaScript

While sailing the seas of JavaScript, you're bound to encounter tricky issues
that can make your code behave unexpectedly.

But fret not, for I'm here to equip you with the tools, techniques, and strategies needed to steer your ship through these stormy waters.

Let's look at some common bugs and errors.

Accidental Global Variables

Look at this code example:

function oops() {
  myVariable = "I'm global!";  // Oops, forgot 'var', 'let', or 'const'!
}

oops();
console.log(myVariable);  // Output: I'm global!

In this example, myVariable becomes global because you didn't use var, let, or const to declare it.

Shadowing

Look at this code example:

const x = 10;

function shadowExample() {
  const x = 5;  // This 'x' is different from the outer 'x'
  console.log(x);  // Output: 5
}

shadowExample();
console.log(x);  // Output: 10

In this example, the inner x shadows the outer one, leading to different values within and outside the function.

Debugging Tools and Techniques

Modern browsers like Chrome come equipped with developer tools that let you set breakpoints, inspect variables, and step through your code line by line.

Setting breakpoints involves using the browser's developer tools to pause your code at specific points (breakpoints) and examine the values of variables. This helps you pinpoint where things are going awry.

Console logging involves inserting console.log() statements to print variable values or messages to the console. This can help you trace the flow of your code and identify unexpected behavior.

Strategies for Identifying and Resolving Errors

Dealing with scope issues requires a methodical approach. Here's your compass:

• Start Local: When debugging, start by checking the scope of variables.
  Are they in the right place? Are they shadowing other variables?

• Step by Step: Use a debugger like browsers Dev tools, Visual Studio Code debugger, Node.js inspector to go through your code step by step. This helps you catch variables at different stages and spot any unexpected changes.

• Isolate the Issue: If a function isn't behaving as expected, isolate it and test it separately. This can help you focus on the problematic part.

• Review Your Code: Take a fresh look at your code, a second glance may reveal something you missed the first time.

• Ask for Help: Don't be afraid to ask for help. Sometimes another set of eyes can spot what you've been missing.

Navigating scope issues might feel like untangling a knot, but with practice, debugging becomes a skill that empowers you to conquer even the trickiest bugs.

Conclusion

In this tutorial, we've explored how functions can act as powerful tools and allow you to create organized and reusable code.

You also learned about scope, which is like a set of rules and dictates where variables can roam freely or stay within boundaries.

From basic function declarations to more advanced concepts like closures and arrow functions, you've also delved into how JavaScript functions work and the nuances of scope.

You've learned about execution context, the call stack, the quirks of hoisting, the use of default parameters, rest parameters, destructuring, and recursive function.

We also discussed debugging, a crucial skill, which equips you to navigate through errors, accidental global variables, and shadowing.

Armed with these insights and strategies, you're now well-prepared to craft more efficient and organized JavaScript code. You should be ready to conquer challenges and create dynamic applications.

To be more equipped on functions, I recommend you watch this Mastering JavaScript Functions for Beginners YouTube video.

If you found this guide helpful and enjoyable, please give it a like. For more insightful tutorials, follow me on X for updates 🙏.

Thanks to its popularity, video and written resources about Python are plentiful. This handbook, however, tries to be a bit different by not being a definitive guide to the language.

Instead you'll learn about all the topics that I consider to be the language fundamentals with a lot of code examples.

I haven't discussed object-oriented programming in this handbook because I believe it to be a very broad subject deserving of its own separate handbook.

Near the end, I've also listed out some learning resources to further your knowledge of Python and programming in general.

Without any further ado, let's jump in!

Table of Contents

• Prerequisites
• How to Setup Python on Your Computer
• How to Install a Python IDE on Your Computer
• How to Create a New Project on PyCharm
• How to Write the Hello World Program in Python
• How to Initialize and Publish a Git Repository From PyCharm
• How to Work With Variables and Different Types of Data in Python
• How to Work With Simple Numbers in Python
• How to Take Inputs From Users in Python
• How to Work With Strings in Python
• What Are the Sequence Types in Python?
  • Lists in Python
  • Tuples in Python
  • Ranges in Python
  • How Indexing Works in Python
• What Are the Iterable Types and How to Use them for Loops in Python
• How to Use While Loops in Python
• How to Write Nested Loops in Python
• What Are Some Common Sequence Type Operations in Python?
  • How to Use the in Operator in Python
  • How to Use the + and * Operators with Sequence Types in Python
  • How to Use the len(), min(), and max() Functions in Python
• What Are Some String Type Operations in Python?
  • How to Capitalize Strings in Python
  • How to Convert Strings to Lower Case or Upper Case in Python
  • How to Count the Number of Occurrences of a Substring in a String in Python
  • How to Split and Join Strings in Python
• How to Write Conditional Statements in Python
• What are Relational and Logical Operators in Python?
• What Are Assignment Operators in Python?
• What Is the Set Type in Python?
• What Is the Mapping Type in Python?
  • What Are Dictionary View Objects in Python?
• How to Write Functions in Python
  • How to Write Anonymous or Lambda Functions in Python
  • How to Work with local, nonlocal and global Variables in Python
  • How to Pass a Variable Number of Arguments to a Function Using args and *kwargs in Python
• What Are Modules in Python?
• How to Use the Python Documentation Efficiently
• What's Next?
  • Object Oriented Programming
  • Algorithms and Data Structures
  • Django
  • Qt
  • PyGame
  • Data Science
• Conclusion

Prerequisites

You don't need to know any other programming language for this book, but knowing one may help you understand the basics of Python.

Other than that you'll need to be efficient enough with your choice of operating system to download and install new software, and gain administrative access if needed.

How to Setup Python on Your Computer

Installing Python on your computer is a very straightforward process. In fact, if you're on a Linux system, Python should already be installed.

Open up your terminal window and execute the following command:

python --version

If Python is installed on your system, you'll get an output like Python 3.10.4 or some other minor version.

Although most of the modern Linux distribution use Python 3 as default, some of the older distributions may still use Python 2 by default.

So if the aforementioned command refers to Python 2, try out the following command:

python3 --version

I'd also suggest that you check for updates on your Linux distribution and install any new updates for Python.

Although Python comes preinstalled with macOS as well, I'd suggest that you follow this article by Dillion Megida and install a more recent version.

Finally, for Windows, I'd suggest you follow an article by Md. Fahim Bin Amin and properly install the latest version of Python.

As long as you have a Python 3 version installed, you're good to go.

How to Install a Python IDE on Your Computer

Much of your experience as a developer will depend on what program you've chosen to write your code in. A good integrated development environment (IDE) or Code Editor can really boost your productivity.

These days Visual Studio Code has become the go to code editor for all languages and platforms. But for the sake of simplicity, we'll use PyCharm in this book.

If you'd like to use VS Code, have written a full-length article on how to configure Visual Studio Code for Python development. Feel free to check that out if you do not mind configuring your editor manually.

The professional edition of the IDE can cost you $89.00 per year but there is also a free and open-source community edition. Head over to the PyCharm download page.

Download PyCharm page

Use the black "Download" button to download the community edition. The file size should be a little larger than 350 megabytes.

On Windows you'll get an executable installer, on macOS you'll get an Apple disc image, and on Linux you'll get a TAR archive.

I won't demonstrate the installation process in this book since it's similar to installing any other software on your machine.

Once installed, you can start the IDE from your start menu/app launcher. On your first launch, you'll be given the chance to configure a few things. I'd suggest you keep the defaults.

Once the configuration wizard ends, you should see the following welcome window:

Welcome to PyCharm screen - with options to start a new project, open a project, or get one from your VCS

Picking one IDE or code editor instead of the other one will not affect your experience with following this handbook, so feel free to use whatever you feel comfortable with.

How to Create a New Project on PyCharm

If you have the welcome window open from the previous section, click on the "New Project" button.

Start a new project in PyCharm

In the next step, pick a location to store your project:

In the location input box, the HelloWorld part is the name of the project. Then make sure you have "New environment using Virtualenv" selected. Then, make sure that the correct version of Python is selected from the "Base interpreter" dropdown.

Virtualenv is a program that can create isolated Python environments from a given base interpreter. This is very helpful because later on when you'll work on multiple Python projects, their dependencies may conflict with each other.

Creating isolated environments for each project will solve that issue and it'll also keep your global Python installation free from any unnecessary package installation.

Since this may be your first Python project, I'd suggest you leave the "Create a main.py welcome script" option checked. Once you're happy with your choices, click the "Create" button.

The project creation process shouldn't take very long. Once it's done, the IDE should open the project automatically for you.

You can use the play button at the top right corner to run the code. The button is configured to run the "main.py" file by default.

That's why you can see "main" written by its side. You can write your custom configuration as well, but that's a topic for a later section.

You can see the output of your program at the bottom of the IDE. PyCharm comes with support for TODO comments, a built in terminal and more. You'll learn about a bunch of these features as you go forward.

How to Write the Hello World Program in Python

Continuing on from the last section, open up the "main.py" file and replace all the preexisting code with the following line of code:

print('Hello, World!')

# Hello, World!

The print() function prints out anything that you pass into the set of parenthesis. You don't have to name your Python file "main.py" specifically. It's just a way to let you know that this is the entry point to this program.

That's all you need to write the simplest executable program in Python. But there is even a better way to do it. Update the code as follows:

def main():
    print('Hello, World!')


if __name__ == '__main__':
    main()

# Hello, World!

As you keep working on bigger projects, you'll eventually have more than one Python file in your project and this way of writing a script can be useful.

To simulate a bigger project, create another Python file by right clicking on the "HelloWorld" project name and selecting "Python File" under the "New" sub menu.

Name your file something like "library" and press enter while "Python file" is highlighted in the list of file types.

A new file with the name "library.py" will show up on your project folder. Put the following line of code inside the file:

def greet():
    print('Hello, World!')

This is a very simple function that prints out "Hello, World!" on the console. You can import and use this function in your "main.py" file.

To do so, update the code for "main.py" file as follows:

from library import greet


def main():
    greet()


if __name__ == '__main__':
    main()

# Hello, World!

You're importing the greet() function from the "library.py" file and executing that inside the main() function.

Right now in your project, you have two types of Python file. You have the "main.py" file which is a script. In other words, you can run this file.

Then you have the "library.py" file which is a library. In other words, it houses a number of useful functions and variables that you can import inside other Python files.

Now imagine you have hundreds of files in your project and they more or less look the same. How would someone else find the entry point to the program?

The easiest way would be to perform a search for the line if __name__ == '__main__' on the entire project. This makes your code a lot more readable.

Now that I have you convinced that this is the way to go, let me explain what is actually going on here.

The __name__ is a special Python variable. In case of a script, the value of this variable will be __main__ and in case of a library, its value will be the name of that file.

So in the aforementioned program, the value of __name__ inside the "main.py" file will be __main__ and library inside the "library.py" file.

If you change the name of then "main.py" file to something else, the value will still be __main__ because it's a script.

Nothing is stopping the "library.py" file from being a script, though. If you run that file instead, it'll become a script.

In languages like C/C++/Go/Java, you'll have a specified main function. That function will be the entry point to the program.

Since Python doesn't have anything like that, the usage of the if __name__ == '__main__' expression enforces a sense of a specified entry point to your program.

It tells the programmer and the IDE that this script is for execution (not for importing inside other Python files).

How to Initialize and Publish a Git Repository From PyCharm

You may already be familiar with Git and know how to initialize a new repository. If you prefer using some other Git client, that's totally fine.

However I think knowing how to make commits right from your IDE can boost your productivity.

Keep in mind you'll need to have Git installed and configured on your system. If you don't have that, this article by Bolaji Ayodeji may come in handy.

Now, continuing on from the last section, if you look at the bottom of your IDE, you should see a "Version Control" tab.

Click on it and you should switch to the version control tab. Now click on the "Create Git repository..." link.

PyCharm will ask you where you want to initialize the new repository. Make sure you're picking the right folder.

As soon as you press the "OK" button, the "Version Control" tab will change to a "Git" tab.

At it's current state, there are no commits. Before you make your first commit, I'd suggest you add a ".gitignore" file so that no unwanted file gets to the repository.

To generate a new gitignore file, head over to gitignore.io website. You can generate gitignore files for a large number of technologies from this website.

You write the name of the technologies that you want to generate the file for. I usually go with "Python", "PyCharm" and hit the "Create" button.

The website will display the content of your desired ".gitignore" file. Select and copy everything from there and go back to PyCharm.

To simulate that, create a new file in your project by right clicking on the "HelloWorld" project name and selecting "File" under the "New" sub menu.

Name your file ".gitignore" and press enter. PyCharm will ask whether you want to add this file to Git or not. Click on Add and then paste the copied content.

At this moment, your repository doesn't have any commits. To create a new commit, click on the "Commit local changes" link or switch to the "Commit" tab.

Since this is your first commit, check all "Changes" and "Unversioned Files" from the commit tab.

Since this is your first commit, put a descriptive commit message such as "Initial commit" and press the "Commit" button to finalize.

You've successfully made a commit to your local repository. You can now see all the commits under the master branch in detail.

Now it's time to publish this repository on GitHub. To do so, create a new repository under your GitHub account.

Then copy the SSH link to this repository. If you do not have SSH configured for your project, you may use the HTTPS link but I'd highly recommend SSH.

Now go back to PyCharm and look at the top right corner. Besides where it says Git, you'll find a few signs.

The downwards blue arrow will pull code from your remote repository, the tick sign will create a new commit, the upwards green arrow will push code.

The clock icon will show your commit history and finally the looped back arrow will revert your changes. Click on the push arrow and a new window will pop up.

Click on the "Define remote" link and inside the URL input box, paste the link you've copied from GitHub. Press the OK button and wait until the process ends.

If everything goes fine, PyCharm will give you a "Push" button. It shouldn't take more than a few seconds to push the code to your remote repository.

If you're using HTTPS instead of SSH, you may have to provide your GitHub email and password on every push.

Once done, visit your remote repository and refresh the page to see if the changes have been pushed correctly or not.

Now you can commit and push your code to GitHub right from your IDE every time you make any significant change.

For example, delete the "library.py" file and update the code inside the "main.py" file to print out "Hello, World!" on the console.

def main():
    print("Hello, World!")


if __name__ == '__main__':
    main()

# Hello, World!

Once you've made the changes, switch to the commit tab and you'll see all the uncommitted changes.

Make sure you've checked all the changes you want to commit. Write a descriptive commit message.

Then instead of just committing, try the "Commit and Push..." button this time. A new window will show up.

If everything looks good to you, click on the Push button and wait for the process to finish.

Remember, if you're using HTTPS you may have to reenter your email and password on every push.

You can check your remote repository on GitHub to make sure that the push has been done correctly.

You can do a lot more in terms of version controlling within PyCharm such as handling pull requests, but I'll leave those out for a later time.

How to Work With Variables and Different Types of Data in Python

A variable is an entity that can take on different values of different types. It's a named location in your computer's memory.

To create a new variable in Python, you just need to type out the name of the variable, followed by an equal sign and the value.

def main():
    book = 'Dracula'
    author = 'Bram Stoker'
    release_year = 1897
    goodreads_rating = 4.01

    print(book)
    print(author)
    print(release_year)
    print(goodreads_rating)


if __name__ == '__main__':
    main()

# Dracula
# Bram Stoker
# 1897
# 4.01

When it comes to naming your variable, the PEP 8 - Style Guide for Python says:

Function names should be lowercase, with words separated by underscores as necessary to improve readability.

And

Variable names follow the same convention as function names.

The guide also says:

Never use the characters ‘l’ (lowercase letter el), ‘O’ (uppercase letter oh), or ‘I’ (uppercase letter eye) as single character variable names. In some fonts, these characters are indistinguishable from the numerals one and zero. When tempted to use ‘l’, use ‘L’ instead.

As long as you're keeping these guidelines in mind, declaring variables in Python is very straightforward.

Instead of declaring the variables in separate lines, you can declare them in one go as follows:

def main():
    book, author, release_year, goodreads_rating = 'Dracula', 'Bram Stoker', 1897, 4.01

    print(book)
    print(author)
    print(release_year)
    print(goodreads_rating)


if __name__ == '__main__':
    main()

# Dracula
# Bram Stoker
# 1897
# 4.01

All you have to do is write the individual variable names in a single line using commas as separators.

Then after the equal sign you have to write the corresponding values in the same order as their names again using commas as separators.

In fact, you can also print them all out in one go. The print() method can take multiple parameters separated by commas.

def main():
    book, author, release_year, goodreads_rating = 'Dracula', 'Bram Stoker', 1897, 4.01

    print(book, author, release_year, goodreads_rating)


if __name__ == '__main__':
    main()

# Dracula Bram Stoker 1897 4.01

These parameters are then printed on the terminal in a single line using spaces for separating each of them.

Speaking of the print() method, you can use the + sign to add variables with strings inside a print method:

def main():
    book, author, release_year, goodreads_rating = 'Dracula', 'Bram Stoker', 1897, 4.01

    print(book + ' is a novel by ' + author + ', published in ' + release_year + '. It has a rating of ' + goodreads_rating + ' on goodreads.')


if __name__ == '__main__':
    main()


# TypeError: can only concatenate str (not "int") to str

If you try to run this code you'll get a TypeError that says Python can concatenate or add together strings not integers.

In the code snippet above, book, author, release_year, and goodreads_rating are all variables of different types.

The book and author variables are strings. The release_year is an integer and finally the goodreads_rating variable is a floating point number.

Whenever Python encounters a + sign in front of a numeric type, it assumes that the programmer may be performing an arithmetic operation.

The easiest way to solve this problem is to convert the numeric types to strings. You can do that by calling the str() method on the numeric variables.

def main():
    book, author, release_year, goodreads_rating = 'Dracula', 'Bram Stoker', 1897, 4.01

    print(book + ' is a novel by ' + author + ', published in ' + str(release_year) + '. It has a rating of ' + str(goodreads_rating) + ' on goodreads.')


if __name__ == '__main__':
    main()

# Dracula is a novel by Bram Stoker, published in 1897. It has a rating of 4.01 on goodreads.

That's better – but you can make that line of code even more readable by using a f string.

def main():
    book, author, release_year, goodreads_rating = 'Dracula', 'Bram Stoker', 1897, 4.01

    print(f'{book} is a novel by {author}, published in {release_year}. It has a rating of {goodreads_rating} on goodreads.')


if __name__ == '__main__':
    main()

# Dracula is a novel by Bram Stoker, published in 1897. It has a rating of 4.01 on goodreads.

You can turn a regular string to a f string by putting a f in front of it and suddenly you can write variable names inside curly braces right within the string itself.

There is one last thing that's bugging me, and that's the length of the line of code itself. Fortunately you can split long strings into multiple shorter ones as follows:

def main():
    book, author, release_year, goodreads_rating = 'Dracula', 'Bram Stoker', 1897, 4.01

    print(f'{book} is a novel by {author}, published in {release_year}.'
          f' It has a rating of {goodreads_rating} on goodreads.')


if __name__ == '__main__':
    main()

# Dracula is a novel by Bram Stoker, published in 1897. It has a rating of 4.01 on goodreads.

Now that's how a good piece of Python code should look. I'd suggest you try to make your code readable from the very beginning – you'll thank me later for that.

Other than int and float, there is another numeric type called complex in Python. It was specifically designed for dealing with numbers like 500+2j.

There are also boolean data that can hold the value True or False and nothing else. You can actually ask Python questions and it'll answer in boolean.

Throughout this book you'll not see complex numbers in action and booleans will come into play much later. So for now, lets focus on simple numbers and strings.

How to Work With Simple Numbers in Python

Simple numbers in Python are of two types. Whole numbers are integers and numbers with floating points in them are floats.

In Python, you can represent integers using four different bases. These are decimal, hexadecimal, octal, and binary.

So you can represent the value of 404 in hexadecimal, octal, or binary by prefixing the corresponding value with 0x, 0o, or 0b respectively.

On the other hand you can represent floats with the precision of up to 15 significant digits in Python. Any digit after the 15th place may be inaccurate.

There are six different arithmetic operations that you can perform on any of the simple numeric types. The simplest of the bunch are addition and subtraction.

def main():
    num_1 = 15
    num_2 = 12

    print(f'sum of num_1 and num_2 is: {num_1 + num_2}')
    print(f'difference of num_1 and num_2 is: {num_1 - num_2}')

if __name__ == '__main__':
    main()

# sum of num_1 and num_2 is: 27
# difference of num_1 and num_2 is: 3

In case of a subtraction operation, the result will be negative if the second operand is larger than the first one.

def main():
    num_1 = 15
    num_2 = 12

    print(f'difference of num_2 and num_1 is: {num_2 - num_1}')

if __name__ == '__main__':
    main()

# difference of num_2 and num_1 is: -3

Similarly you can perform multiplication and division operations using their corresponding operators.

def main():
    num_1 = 15
    num_2 = 12

    print(f'product of num_1 and num_2 is: {num_1 * num_2}')
    print(f'quotient of num_1 and num_2 is: {num_1 / num_2}')
    print(f'floored quotient of num_1 and num_2 is: {num_1 // num_2}')


if __name__ == '__main__':
    main()

# product of num_1 and num_2 is: 180
# quotient of num_1 and num_2 is: 1.25
# floored quotient of num_1 and num_2 is: 1

Keep in mind that you can not divide a number by zero in Python. If you attempt that, you'll get a ZeroDivisionError error (more on that later).

Output from a division operation will always be a float value, unless you perform a floored division by using two division operators.

def main():
    num_1 = 15
    num_2 = 12

    print(f'floored quotient of num_1 and num_2 is: {num_1 // num_2}')


if __name__ == '__main__':
    main()

# floored quotient of num_1 and num_2 is: 1

In this case the result will be rounded off to the nearest integer low – so, for example, 0.25 will be lost. So only perform this operation when such loss of data is permissible.

The last operation to discuss is finding the remainder of a division operation.

def main():
    num_1 = 15
    num_2 = 12

    print(f'remainder of num_1 / num_2 is: {num_1 % num_2}')


if __name__ == '__main__':
    main()

# remainder of num_1 / num_2 is: 3

This operation is also called a modulo or modulus operation. So if someone mentions the modulo or modulus operator, they're referring to the percent sign.

You can turn an unsigned number into a negative one just by adding a - sign in front of it. You can also freely convert between integer to float and vice versa.

def main():
    float_variable = 1.25
    integer_variable = 55

    print(f'{float_variable} converted to an integer is: {int(float_variable)}')
    print(f'{integer_variable} converted to a float is: {float(integer_variable)}')


if __name__ == '__main__':
    main()

# 1.25 converted to an integer is: 1
# 55 converted to a float is: 55.0

Loss of data in case of a float to integer conversion is inevitable, so be careful. You can use the int() and float() methods on strings as well (more on that later).

Any arithmetic operation involving a float operand will always produce a float result, unless converted to integer explicitly.

def main():
    float_variable = 5.0
    integer_variable = 55

    print(f'the sum of {float_variable} and {integer_variable} is: {float_variable + integer_variable}')
    print(f'the sum of {float_variable} and {integer_variable} '
          f'converted to integer is: {int(float_variable + integer_variable)}')


if __name__ == '__main__':
    main()

# the sum of 5.0 and 55 is: 60.0
# the sum of 5.0 and 55 converted to integer is: 60

If you ever want to get the absolute value of a signed value you can do so using the abs() method.

def main():
    num_1 = -5.8

    print(f'the absolute value of {num_1} is: {abs(num_1)}')


if __name__ == '__main__':
    main()

# the absolute value of -5.8 is: 5.8

There is a similar method pow(x, y) that you can use to apply x as the power of y like this.

def main():
    x = 2
    y = 3

    print(f'{2} to the power of {3} is: {pow(2, 3)}')
    print(f'{2} to the power of {3} is: {2 ** 3}')


if __name__ == '__main__':
    main()

# 2 to the power of 3 is: 8
# 2 to the power of 3 is: 8

You can perform the same operation using two multiplication operators but I always prefer the pow() method.

Finally there is the divmod() method that you can use to combine the division and modulo operation.

def main():
    num_1 = 8
    num_2 = 2

    print(f'division and modulus of {num_1} and {num_2} is: {divmod(num_1, num_2)}')


if __name__ == '__main__':
    main()

# division and modulus of 8 and 2 is: (4, 0)

The method returns a tuple of numbers (more on that later). The first one is the result of the division and the second one is the result of the modulo operation.

These are the basic operations you can perform on simple numbers right from the get go. But you can do much more once you start to pull in the built-in modules.

How to Take Inputs From Users in Python

Learning how to take input from a user is an important milestone because it lets you create programs that a human being can interact with.

Unlike many other programming languages, taking user inputs in Python is very straightforward.

def main():
    name = input('What is your name? ')

    print(f'Nice to meet you {name}')


if __name__ == '__main__':
    main()

# What is your name? Farhan
# Nice to meet you Farhan

The built-in input() method does exactly what it sounds like. The method accepts a single parameter prompt which is of string type.

Whatever you write as the value of this parameter will be shown in the console – like in this case, "What is your name?" is the prompt.

Once the user writes something on the console and presses enter, the input method will return that as a string.

You can save that string to any variable like I've saved the name inside the name variable. Even if the user inputs a number, input() will return that as a string.

def main():
    name = input('What is your name? ')
    age = input(f'How old are you {name}? ')
    current_year = input(f'What year is this again? ')

    print(f'If my calculations are right, you were born in {current_year - age}')


if __name__ == '__main__':
    main()

# What is your name? Farhan
# How old are you Farhan? 27
# What year is this again? 2023
# TypeError: unsupported operand type(s) for -: 'str' and 'str'

Even though Python is taking all the user inputs correctly, it fails to calculate the user's birth year because arithmetic operations are not a good fit for strings.

To solve this problem, you just have to convert the user inputs to numeric types using the int() or float() functions as needed.

def main():
    name = input('What is your name? ')
    age = int(input(f'How old are you {name}? '))
    current_year = int(input(f'What year is this again? '))

    print(f'If my calculations are right, you were born in {current_year - age}')


if __name__ == '__main__':
    main()

# What is your name? Farhan
# How old are you Farhan? 27
# What year is this again? 2023
# If my calculations are right, you were born in 1996

There you go, works like a charm. You can perform this conversion at any point in the code. It's not mandatory to convert them right at the beginning.

def main():
    temperature_in_celsius = input('What is the temperature in celsius? ')

    temperature_in_fahrenheit = (float(temperature_in_celsius) * 1.8) + 32

    print(f'{temperature_in_celsius} degree celsius is equivalent to {temperature_in_fahrenheit} degree fahrenheit.')


if __name__ == '__main__':
    main()

# What is the temperature in celsius? 32
# 32 degree celsius is equivalent to 89.6 degree fahrenheit.

This program can convert temperature from Celsius to Fahrenheit. In this program, I didn't convert the input from string to a numeric type right away.

I performed the conversion during the calculation leaving the original input variable intact. Also notice the use of float() instead of the int() function.

How to Work With Strings in Python

You've already seen examples of strings in the previous sections – but there is a lot more that you need to learn about strings.

In Python, anything enclosed within a set of single, double, or triple quotes is a string. These are sequences of bytes representing Unicode characters.

def main():
    book = 'Dracula'
    author = "Bram Stoker"

    print('Title:', book)
    print('Author:', author)


if __name__ == '__main__':
    main()

# Title: Dracula
# Author: Bram Stoker

Declaring a string with single or double quotes makes no difference whatsoever. But based on the scenario, you may have to choose on over the other.

For example, if you have an apostrophe within your sentence, you may want to use double quotes.

def main():
    question = "What's your name?"

    print(question)


if __name__ == '__main__':
    main()

# What's your name?

The opposite can also occur. For example, when you have a direct quote within your string:

def main():
    sentence = 'Harriet Jacobs writes, "She sat down, quivering in every limb"'

    print(sentence)


if __name__ == '__main__':
    main()

# Harriet Jacobs writes, "She sat down, quivering in every limb"

You can also go for escape sequences if you want to, but the PEP 8 - Style Guide for Python Code recommends avoiding the usage of back slashes within strings.

Triple quotes are a different case altogether. You can put multi-line strings within triple quotes and Python will preserve the white spaces as well.

def main():
    synopsis = """Dracula comprises journal entries, letters, and telegrams written by the main characters.
It begins with Jonathan Harker, a young English lawyer, as he travels to Transylvania.
Harker plans to meet with Count Dracula, a client of his firm, in order to finalize a property transaction.
When he arrives in Transylvania, the locals react with terror after he discloses his destination: Castle Dracula.
Though this unsettles him slightly, he continues onward.
The ominous howling of wolves rings through the air as he arrives at the castle.
When Harker meets Dracula, he acknowledges that the man is pale, gaunt, and strange.
Harker becomes further concerned when, after Harker cuts himself while shaving, Dracula lunges at his throat.
Soon after, Harker is seduced by three female vampires, from whom he barely escapes.
He then learns Dracula’s secret—that he is a vampire and survives by drinking human blood.
Harker correctly assumes that he is to be the count’s next victim.
He attacks the count, but his efforts are unsuccessful.
Dracula leaves Harker trapped in the castle and then, along with 50 boxes of dirt, departs for England."""

    print('Synopsis:', synopsis)


if __name__ == '__main__':
    main()

# Synopsis: Dracula comprises journal entries, letters, and telegrams written by the main characters.
# It begins with Jonathan Harker, a young English lawyer, as he travels to Transylvania.
# Harker plans to meet with Count Dracula, a client of his firm, in order to finalize a property transaction.
# When he arrives in Transylvania, the locals react with terror after he discloses his destination: Castle Dracula.
# Though this unsettles him slightly, he continues onward.
# The ominous howling of wolves rings through the air as he arrives at the castle.
# When Harker meets Dracula, he acknowledges that the man is pale, gaunt, and strange.
# Harker becomes further concerned when, after Harker cuts himself while shaving, Dracula lunges at his throat.
# Soon after, Harker is seduced by three female vampires, from whom he barely escapes.
# He then learns Dracula’s secret—that he is a vampire and survives by drinking human blood.
# Harker correctly assumes that he is to be the count’s next victim.
# He attacks the count, but his efforts are unsuccessful.
# Dracula leaves Harker trapped in the castle and then, along with 50 boxes of dirt, departs for England.

So if you ever want to print out a multi line string while preserving the white spaces, go for triple quotes.

You can declare a triple quoted string using three single quotes but the PEP 8 - Style Guide for Python Code recommends the usage of three double quotes.

There is a lot more to learn about strings, but I'd like to introduce you to some other sequence types in Python.

What Are the Sequence Types in Python?

In Python, there are three sequence types. They are lists, tuples, and ranges. I'll start with the lists because it's probably the most utilized sequence type in Python.

Lists in Python

A list in Python is exactly what it sounds like: a collection of data stored sequentially on the computer's memory.

You can create a new list in Python by writing out its name followed by an equal sign, followed by the values to store enclosed in square brackets:

def main():
    horror_books = ['Dracula', 'Carmilla', 'The Imago Sequence']

    print(horror_books)


if __name__ == '__main__':
    main()

# ['Dracula', 'Carmilla', 'The Imago Sequence']

In this example, horror_books is a list of strings. But you can create lists of integers, floats, or even of mixed types.

def main():
    a_random_list = ['Dracula', 1, 5.7, 'Carmilla']

    print(a_random_list)


if __name__ == '__main__':
    main()

# ['Dracula', 1, 5.7, 'Carmilla']

Though this is perfectly valid, you may find yourself creating lists of the same types more often.

Lists in Python are mutable. This means you can modify a list after its creation. For example, you can use the pop() method to get rid of the last value in a list.

def main():
    horror_books = ['Dracula', 'Carmilla', 'The Imago Sequence']

    print(horror_books.pop())
    print(horror_books)


if __name__ == '__main__':
    main()

# The Imago Sequence
# ['Dracula', 'Carmilla']

As you can see, the pop() method returns the last value from the list and gets rid of it. Like pop() there is the append() method for inserting new item to the list.

def main():
    horror_books = ['Dracula', 'Carmilla', 'The Imago Sequence']

    print(horror_books)

    horror_books.append('The Exorcist')

    print(horror_books)


if __name__ == '__main__':
    main()

# ['Dracula', 'Carmilla', 'The Imago Sequence']
# ['Dracula', 'Carmilla', 'The Imago Sequence', 'The Exorcist']

As you can see from the method name, it adds the new item at the end of the list. Given their mutable nature, lists can also be sorted.

Feel free to check out the following article written by my colleague Dionysia Lemonaki here on freeCodeCamp about how to sort lists in Python:

Tuples in Python

Lists are not the only sequence type in Python. The closest sibling of lists in Python are tuples.

You can create a new tuple in Python by writing out its name followed by an equal sign, then enclosing inside a pair of parenthesis the values you want to store.

def main():
    horror_books = ('Dracula', 'Carmilla', 'The Imago Sequence')

    print(horror_books)


if __name__ == '__main__':
    main()

# ('Dracula', 'Carmilla', 'The Imago Sequence')

Just like lists, you can also mix and match different types of data within a single tuple as you see fit.

def main():
    a_random_list = ('Dracula', 1, 5.7, 'Carmilla')

    print(a_random_list)


if __name__ == '__main__':
    main()

# ('Dracula', 1, 5.7, 'Carmilla')

The most glaring dissimilarity between a list and a tuple is the fact that a tuple is immutable. So there's no popping and appending for us this time.

Ranges in Python

The final sequence type that you're going to learn about in this section is a range. A range in Python is just a range of numbers.

You can create a range by calling the range() method and it'll return a range of numbers. You can call the method in a few different ways.

The most common is by passing a single number as a parameter. In this case, the method will treat that number as the end of the range and 0 as the start.

def main():
    a_range = range(10)

    print(a_range)

    list_a_range = list(a_range)

    print(list_a_range)


if __name__ == '__main__':
    main()

# range(0, 10)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

Printing out a range as is won't give you much information. You'll have to convert the range to a list or a tuple by either calling the list() or tuple() method.

Once converted, you can then print out the entire range to the console. Notice how 10 or the number passed to the range() method is not included in the range.

The second way of calling the method is by supplying both the starting and ending numbers for the range.

def main():
    a_range = range(5, 15)

    print(a_range)

    list_a_range = list(a_range)

    print(list_a_range)

    tuple_a_range = tuple(a_range)

    print(tuple_a_range)


if __name__ == '__main__':
    main()

# range(5, 15)
# [5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
# (5, 6, 7, 8, 9, 10, 11, 12, 13, 14)

Once again, the number you pass as the ending for the range will not be included in the resultant range.

The third and final way to call the method is by also defining a step. For example, imagine you want a range comprising of all the odd numbers within 1 to 10.

def main():
    a_range = range(1, 10, 2)

    print(a_range)

    list_a_range = list(a_range)

    print(list_a_range)

    tuple_a_range = tuple(a_range)

    print(tuple_a_range)


if __name__ == '__main__':
    main()

# range(1, 10, 2)
# [1, 3, 5, 7, 9]
# (1, 3, 5, 7, 9)

Since the value of step is 2 in this case, the range will begin with 1 but then skip every second number.

It may take some time to wrap your head around this concept but practicing with different step values will help.

Or you can read the following article written by Bala Priya C:

How Indexing Works in Python

One of the most important concepts regarding sequence types that you need to understand is indexing.

You see, each element in a sequence has a number attached to it that expresses its position in the list called an index. These indices are 0 based.

This diagram represents our list of horror books. The index of the first book is 0 – this means that the first element is at the 0th place.

The second one is at the 1st place and the third one is at the 2nd place. This zero-based indexing is may seem confusing at first but you'll get the hang of it.

The most basic usage of a index is to access its corresponding value from the sequence.

def main():
    horror_books = ['Dracula', 'Carmilla', 'The Imago Sequence']

    print(horror_books[0])
    print(horror_books[1])
    print(horror_books[2])


if __name__ == '__main__':
    main()

# Dracula
# Carmilla
# The Imago Sequence

You can also use negative numbers as indices but in that case the counting will start from the end.

def main():
    books = ['Dracula', 'Frankenstein', 'The Omen', 'The Exorcist', 'The Legend of Sleepy Hollow',
             'And Then There Were None', 'The ABC Murders', 'The Valley of Fear']

    print(books[0])

    print(books[1])
    print(books[-1])

    print(books[2])
    print(books[-2])


if __name__ == '__main__':
    main()

# Dracula

# Frankenstein
# The Valley of Fear

# The Omen
# The ABC Murders

The 0th element in a list will always be the first one. Now if you access the element on the 1st position you get "Frankenstein".

But if you try to access the element on the -1st position, you get "The Valley of Fear" because that's the second item in reverse.

The element on the 2nd position is "The Omen" but the element at the -2nd position is "The ABC Murders" because that's the third item in reverse.

If you're finding it hard to wrap your head around, imagine the list like a clock.

Zero-based indexing represented as a circular diagram like a clock

Here the outer number is the negative index and the inner number is the positive index. If you try to match the outputs against this imaginary clock, it should be easier to understand.

What Are the Iterable Types and How to Use them for Loops in Python

So far you've learned about creating collections of data and accessing them one by one. That's cool but there is something cooler.

Imagine you have a list or some other type of that contains a bunch of numbers.

Now you want to multiply each number in that list by two, insert the multiplied numbers in a new list, and print out the list on the terminal.

This is an excellent use case for the for statement in Python. Let's begin by first iterating through each number in a given list.

def main():
    random_numbers = [6, 1, 3, 8, 0, 9, 12, 3, 4, 0, 54, 8, 100, 55, 60, 70, 85]

    for number in random_numbers:
        print(number)

if __name__ == '__main__':
    main()

# 6
# 1
# 3
# 8
# 0
# 9
# 12
# 3
# 4
# 0
# 54
# 8
# 100
# 55
# 60
# 70
# 85

You start by writing out the word for followed by a variable name. I've used number but you can use anything that makes sense to you.

Although you write it as for number, Python reads it as for each number and wonders where are these numbers staying?

That's when you say in followed by the name of the sequence, random_numbers in this case.

Now Python understands that you want to do something with each number in the random_numbers sequence, but what?

That's what you have to write out after the colon and be very careful about the indentation. Anything indented one level after the for loop declaration is considered the loop body.

Inside the for loop you can write whatever you want to do with the current value of the number variable.

Since there are 17 numbers in the sequence, the loop will run 17 times and each time it'll have a new value.

It'll start at index 0 which has the value of 6 and go through index 1, 2, 3, 4, 5, and so on.

On each iteration, it'll save the value of the index it's currently working on inside the number variable and print it out. Hence you get the long list of numbers.

Instead of printing out the original value, you can multiply it by 2 and print out the resultant value instead.

def main():
    random_numbers = [6, 1, 3, 8, 0, 9, 12, 3, 4, 0, 54, 8, 100, 55, 60, 70, 85]

    for number in random_numbers:
        print(number * 2)

if __name__ == '__main__':
    main()

# 12
# 2
# 6
# 16
# 0
# 18
# 24
# 6
# 8
# 0
# 108
# 16
# 200
# 110
# 120
# 140
# 170

Now you're getting the multiplied values. The final task is to insert these multiplied values in a new list and print out the new list itself.

def main():
    random_numbers = [6, 1, 3, 8, 0, 9, 12, 3, 4, 0, 54, 8, 100, 55, 60, 70, 85]
    multiplied_random_numbers = []

    for number in random_numbers:
        multiplied_random_numbers.append(number * 2)

    print(multiplied_random_numbers)

if __name__ == '__main__':
    main()

# [12, 2, 6, 16, 0, 18, 24, 6, 8, 0, 108, 16, 200, 110, 120, 140, 170]

For that you'll need an empty list. Then, after multiplying the number, you can simply call the append() method on the new list and pass the multiplied value.

Finally, make sure that you're putting the print statement outside of the loop body otherwise you'll end up printing out the list 17 times.

The for loop works with all the sequence types and any iterable type in the Python language. What is an iterable type, I hear you ask.

Well, any object that has the __iter__() method is considered an iterable in Python.

You can call the dir() function on any object to list out all its methods and properties. Take the random_numbers list as an example.

def main():
    random_numbers = [6, 1, 3, 8, 0, 9, 12, 3, 4, 0, 54, 8, 100, 55, 60, 70, 85]

    print(dir(random_numbers))

if __name__ == '__main__':
    main()

# ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

You can see some familiar methods such as append, count, and index but most importantly it has the __iter__ method.

As you keep working in Python you'll eventually remember the types supported by the for loop but you can always use the dir() method on a object to find out.

How to Use While Loops in Python

There is another type of loop in Python known as the while loop. Unlike for, a while loop can execute a statement as long as a given condition evaluates to true.

def main():
    number = 1
    while number < 11:
        print(number)
        number += 1

if __name__ == '__main__':
    main()

# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9
# 10

Here you have a variable number with the value 11 and a while loop that prints out the value of number, then increases it by 1.

A while loop starts by writing out while followed by the condition. Then you write the loop body starting from the next line after the colon.

for loops are useful when you're trying to access every element inside an iterable. while loops are useful when you want to repeat the same set of instructions an arbitrary number of times.

The line number += 1 is another way to write number = number + 1 and it's very commonly used by programmers across different programming languages.

How to Write Nested Loops in Python

You can also nest one loop inside another. For example, look at the following code that prints out multiplication tables:

def main():
    for x in range(1, 6):
        print()
        for y in range(1, 11):
            print(f"{x} x {y} = {x * y}")


if __name__ == '__main__':
    main()

#
# 1 x 1 = 1
# 1 x 2 = 2
# 1 x 3 = 3
# 1 x 4 = 4
# 1 x 5 = 5
# 1 x 6 = 6
# 1 x 7 = 7
# 1 x 8 = 8
# 1 x 9 = 9
# 1 x 10 = 10
#
# 2 x 1 = 2
# 2 x 2 = 4
# 2 x 3 = 6
# 2 x 4 = 8
# 2 x 5 = 10
# 2 x 6 = 12
# 2 x 7 = 14
# 2 x 8 = 16
# 2 x 9 = 18
# 2 x 10 = 20
#
# 3 x 1 = 3
# 3 x 2 = 6
# 3 x 3 = 9
# 3 x 4 = 12
# 3 x 5 = 15
# 3 x 6 = 18
# 3 x 7 = 21
# 3 x 8 = 24
# 3 x 9 = 27
# 3 x 10 = 30
#
# 4 x 1 = 4
# 4 x 2 = 8
# 4 x 3 = 12
# 4 x 4 = 16
# 4 x 5 = 20
# 4 x 6 = 24
# 4 x 7 = 28
# 4 x 8 = 32
# 4 x 9 = 36
# 4 x 10 = 40
#
# 5 x 1 = 5
# 5 x 2 = 10
# 5 x 3 = 15
# 5 x 4 = 20
# 5 x 5 = 25
# 5 x 6 = 30
# 5 x 7 = 35
# 5 x 8 = 40
# 5 x 9 = 45
# 5 x 10 = 50

To be honest, this is a very simple bit of code that makes use of a lot of the things you've already learned in this handbook.

To create a multiplication table we need two operands: one remains constant for the entire table and the other increases by 1 until it reaches 10.

Here, x represents the left operand or the constant one and y represents the right operand or the variable one.

The first loop iterates through a range of 1 to 5 and the second loop iterates through a range of 1 to 10.

Since the ending number of a range is exclusive, you need to put a number that is 1 higher than the desired ending number.

First the Python interpreter encounters the outer loop and starts executing it. While inside that loop, the value of x is 1.

The interpreter then encounters the inner loop and starts executing that. While inside the inner loop, the value of x remains 1 but the value of y increases in each iteration.

The inner loop is the body of the outer loop in this case, so the first iteration of the outer loop lasts until the inner loop finishes.

After finishing 10 iterations of the inner loop, the interpreter comes back to the outer loop and starts executing it once again.

This time the value of x becomes 2 since that's what comes next in the range.

Just like that, the outer loop executes 5 times and the inner loop executes 10 times for each of those iterations.

Like a lot of other concepts, wrapping your head around nested loops can be difficult, but practice will make things easier.

I'd suggest you go ahead and implement this program using while loops to test your understanding.

You can also take the two numbers from the user and print the multiplication table within that range.

For example, if the user puts 5 and 10 as inputs, then you'll print out the multiplication tables of all the numbers from 5 to 10.

You can nest loops to even deeper levels, but going deeper than two loops may cause performance issues so be careful with that.

What Are Some Common Sequence Type Operations in Python?

Assuming you remember the text sequence type (strings), you're now familiar with the four most popular Python sequence types.

So I think it's time for you to learn some common operations that you can perform on them. Let's begin, shall we?

How to Use the in Operator in Python

The in operator is the most common way of checking for any object's existence. For example, assume that you have a string and you want to check if it contains the word "red" or not.

def main():
    a_string = 'Little Red Riding-Hood comes to me one Christmas Eve to give me information of the cruelty and ' \
               'treachery of that dissembling Wolf who ate her grandmother. '

    print('Red' in a_string)


if __name__ == '__main__':
    main()

# True

It's literally like asking Python, if the word Red is in the a_string variable. And Python will give you either True or False as an answer.

The in operator is not exclusive to strings. You can actually use it on any other collection type such as lists, tuples, and ranges.

def main():
    books = ['Dracula', 'Frankenstein', 'The Omen', 'The Exorcist', 'The Legend of Sleepy Hollow']
    movies = ('A Christmas Carol', 'The Sea Beast', 'Enchanted', 'Pinocchio', 'The Addams Family')
    numbers = range(10)

    print('A Christmas Carol' in books)
    print('Enchanted' in movies)
    print(5 in numbers)


if __name__ == '__main__':
    main()

# False
# True
# True

A Christmas Carol doesn't exist in the books list so it's a False statement. The other two statements are right, so they're True.

You may also want to find out about the absence of an object. For that, you can use the not operator in conjunction with the in operator.

def main():
    books = ['Dracula', 'Frankenstein', 'The Omen', 'The Exorcist', 'The Legend of Sleepy Hollow']
    movies = ('A Christmas Carol', 'The Sea Beast', 'Enchanted', 'Pinocchio', 'The Addams Family')
    numbers = range(10)

    print('A Christmas Carol' not in books)
    print('Enchanted' not in movies)
    print(15 not in numbers)


if __name__ == '__main__':
    main()

# True
# False
# True

A Christmas Carol doesn't exist in the books list, so the first statement evaluates to true. The second one evaluates to false because Enchanted is present in the movies list.

The last one is self explanatory at this point. The in and not in operators come in very handy when working with conditional statements.

How to Use the + and * Operators with Sequence Types in Python

You've already learned about + and * as arithmetic operators – but in the case of sequence types, they play a very different role.

The + operator lets you merge two sequences together.

def main():
    books = ['Dracula', 'Frankenstein', 'The Omen', 'The Exorcist', 'The Legend of Sleepy Hollow']
    more_books = ['And Then There Were None', 'The ABC Murders', 'The Valley of Fear', 'The Hound of the Baskervilles', 'The Chestnut Man']


    print(books + more_books)


if __name__ == '__main__':
    main()

# ['Dracula', 'Frankenstein', 'The Omen', 'The Exorcist', 'The Legend of Sleepy Hollow', 'And Then There Were None', 'The ABC Murders', 'The Valley of Fear', 'The Hound of the Baskervilles', 'The Chestnut Man']

As you can see, the operator has appended the content of the books list to the content of the more_books list.

The * operator, on the other hand, makes multiple copies of a given sequence.

def main():
    books = ['Dracula', 'Frankenstein', 'The Omen', 'The Exorcist', 'The Legend of Sleepy Hollow']


    print(books * 2)


if __name__ == '__main__':
    main()

# ['Dracula', 'Frankenstein', 'The Omen', 'The Exorcist', 'The Legend of Sleepy Hollow', 'Dracula', 'Frankenstein', 'The Omen', 'The Exorcist', 'The Legend of Sleepy Hollow']

So multiplying the books list by 2 gives us all the 5 books in the list twice. These operators work the same for tuples, strings, ranges or any other sequence types.

How to Use the len(), min(), and max() Functions in Python

The len() function can return the length of a given sequence. And the min() and max() functions can return the minimum and maximum value in a given sequence, respectively.

def main():
    random_numbers = [6, 1, 3, 8, 0]


    print(len(random_numbers))
    print(min(random_numbers))
    print(max(random_numbers))


if __name__ == '__main__':
    main()

# 5
# 0
# 8

Since there are 5 elements in the list, 5 is the output from the len() function call.

The smallest value in the list is 0 and the largest value is 8 which are the outputs from the min() and max() function calls, respectively.

Depending on the type of programs you end up writing in the future, these three functions can prove to be some of the most useful ones.

What Are Some String Type Operations in Python?

In the previous section, you've learned about some common operations that you can perform on any sequence type including strings.

However, the text sequence type aka strings have some special operations available to them.

In this chapter I'll introduce you to some of the most common string methods. Keep in mind that this is not a definitive list.

Although each of the methods I'm going to teach you performs a different task, they have one thing in common. None of them modifies a given string variable in place, but rather returns a new, modified copy.

If you want to learn about all the available string methods, feel free to consult the official Python documentation.

Also remember it's not a matter of just going through each method and memorizing their usage.

It's about knowing what works best in a given scenario and coming up with clever solutions. And that requires practice.

How to Capitalize Strings in Python

The first method you're going to learn is called capitalize() and it does what it sounds like.

def main():
    country_name = 'bangladesh'

    print(country_name.capitalize())


if __name__ == '__main__':
    main()

# Bangladesh

As you can see from the code snippet above, the capitalize() method turns the first letter of the word to a capital letter.

This is simple, but let's try this on a string with multiple words in it – a sentence perhaps.

def main():
    book_name = 'the house of silk'

    print(book_name.capitalize())


if __name__ == '__main__':
    main()

# The house of silk

Although the method did its job, there is slight problem. Depending on what you're trying to achieve, you may expect the first letter of each word to be capitalized.

That's where the title() method comes in. This method returns a title cased version of a given string.

def main():
    book_name = 'the house of silk'

    print(book_name.title())


if __name__ == '__main__':
    main()

# The House Of Silk

But there is still an issue. Take the following string with apostrophes for example.

def main():
    book_name = "alice's adventures in wonderland"

    print(book_name.title())


if __name__ == '__main__':
    main()

# Alice'S Adventures In Wonderland

As you can see, the title() method treats the s following the apostrophe as a separate word and capitalizes it.

Regarding this issue, the official documentation states:

The algorithm uses a simple language-independent definition of a word as groups of consecutive letters. The definition works in many contexts but it means that apostrophes in contractions and possessives form word boundaries.

The capwords() helper function can solve this issue. This function breaks the string into multiple words based on the spaces between them, capitalizes the words, joins them back into a string and returns that to the user.

from string import capwords


def main():
    book_name = "alice's adventures in wonderland"

    print(capwords(book_name))


if __name__ == '__main__':
    main()

# Alice's Adventures In Wonderland

Pay attention to the import statement at the top. The capwords() function is not a method within the string type but a function that resides inside the string module.

You'll learn about modules and imports in more details later on. For now, just roll with it. Although the function uses spaces to split words, you can overwrite it.

from string import capwords


def main():
    address = 'house 42, road 02, wonderland'

    print(capwords(address, ', '))


if __name__ == '__main__':
    main()

# House 42, Road 02, Wonderland

As you can see, in this case the string has multiple parts divided by a comma followed by a space.

The capwords() function can take a custom delimiter as its second parameter. You can pass any string as the delimiter.

Finally, there is the istitle() method that can check whether a given string is in title case or not.

def main():
    book_name = 'hearts in atlantis'

    print(f'Is "{book_name}" in title case? {book_name.istitle()}')
    print(f'Is "{book_name.title()}" in title case? {book_name.title().istitle()}')


if __name__ == '__main__':
    main()

# Is "hearts in atlantis" in title case? False
# Is "Hearts In Atlantis" in title case? True

However, keep in mind that the istitle() method doesn't work with the capwords() helper function.

How to Convert Strings to Lower Case or Upper Case in Python

Apart from capitalization, you may want to convert an entire string to upper case or lower case. You can do that by using the upper() and lower() methods in Python.

def main():
    book_name = 'moriarty'

    print(book_name.upper())

    another_book_name = 'DRACULA'

    print(another_book_name.lower())


if __name__ == '__main__':
    main()

# MORIARTY
# dracula

There are also the isupper() and islower() methods to check whether a given string is already in either of the letter cases or not.

def main():
    book_name = 'moriarty'

    print(book_name)
    print(f'Is {book_name} in upper case? {book_name.isupper()}')
    print(f'Is {book_name} in lower case? {book_name.islower()}')

    another_book_name = 'DRACULA'

    print(another_book_name)
    print(f'Is {another_book_name} in upper case? {another_book_name.islower()}')
    print(f'Is {another_book_name} in lower case? {another_book_name.isupper()}')


if __name__ == '__main__':
    main()

# moriarty
# Is moriarty in upper case? False
# Is moriarty in lower case? True
# DRACULA
# Is DRACULA in upper case? True
# Is DRACULA in lower case? False

There is one last method called casefold() which is kind of a more aggressive version of the lower() method.

According to the official documentation:

Casefolding is similar to lowercasing but more aggressive because it is intended to remove all case distinctions in a string. For example, the German lowercase letter 'ß' is equivalent to "ss". Since it is already lowercase, lower() would do nothing to 'ß'; casefold() converts it to "ss".

The usage of this method is identical to the lower() method.

def main():
    book_name = 'DRACULA'

    print(book_name.casefold())


if __name__ == '__main__':
    main()

# dracula

These three methods are fine and dandy, but what if you don't want to use any of these particular methods and just want to switch the case of a given string?

The swapcase() method can do just that.

def main():
    book_name = 'HEARTS IN ATLANTIS'

    print(book_name.swapcase())


if __name__ == '__main__':
    main()

# hearts in atlantis

As you can see, the method has converted the book name into lower case from upper case.

How to Count the Number of Occurrences of a Substring in a String in Python

If you want to find out the number of occurrences of a substring within a string, you can use the count() method in Python.

def main():
    paragraph = '''At three in the morning the chief Sussex detective, obeying the urgent call from Sergeant Wilson of 
    Birlstone, arrived from headquarters in a light dog-cart behind a breathless trotter. By the five-forty train in 
    the morning he had sent his message to Scotland Yard, and he was at the Birlstone station at twelve o'clock to 
    welcome us. White Mason was a quiet, comfortable-looking person in a loose tweed suit, with a clean-shaved, 
    ruddy face, a stoutish body, and powerful bandy legs adorned with gaiters, looking like a small farmer, 
    a retired gamekeeper, or anything upon earth except a very favourable specimen of the provincial criminal 
    officer.'''

    substring = 'morning'

    print(f'The substring "{substring}" shows up {paragraph.count(substring)} times in the paragraph.')


if __name__ == '__main__':
    main()

# The substring "morning" shows up 2 times in the paragraph.

If you call the count() method without passing anything to it, the method will return the number of empty spaces in the given string.

How to Split and Join Strings in Python

You can actually break a string into a list of words or join a list of words in a string in Python.

def main():
    string = 'Holmes was certainly not a difficult man to live with'

    word_list = string.split()

    print(word_list)


if __name__ == '__main__':
    main()

# ['Holmes', 'was', 'certainly', 'not', 'a', 'difficult', 'man', 'to', 'live', 'with']