DEV Community: Chiranjeevi Tirunagari

Azure AD intro with Terraform examples

Chiranjeevi Tirunagari — Tue, 20 Jun 2023 16:25:16 +0000

Introduction

Azure Active Directory (Azure AD) offers organizations a comprehensive cloud-based solution for efficient directory and identity management. With its array of features, including username and password management, role and permissions control, multi-factor authentication, and application monitoring, Azure AD is an indispensable tool for businesses of all sizes. This article explores the key aspects of Azure AD, starting with user management, followed by administrative units, and concluding with group management.

Terraform setup for Azure AD

First, we need to specify the providers that we are going to use so that Terraform knows which providers it needs to download.

terraform {
    required_providers {
        azuread = {
            source  = "hashicorp/azuread"
            version = "~> 2.15.0"
        }
    }
}

provider "azuread" {
    tenant_id = "<your_azure_account_tenant_id>"
}

If we run terraform init command after adding the above code to any of the files ( providers.tf is a preferred name ) in the terraform directory, it downloads the required providers.

For whatever code we use in this article to work, we need to authenticate to our Azure account so that the changes we create in code will actually happen. The easiest and recommended way to authenticate for Terraform is through service principal and client secret.

To create one service principal, we need to have a Contributor role for Azure AD. If we have that, we can create a service principal using the command az ad sp create-for-rbac --role="Contributor" --scopes="/subscriptions/<your-subscription-number>" in Azure CLI which can be downloaded from https://learn.microsoft.com/en-us/cli/azure/install-azure-cli here if you haven't already. This will return a response containing 4 important fields which we want. They are id ( subscription_id ), tenant_id, client_id, and client_secret. It is better to create a bash file which contains the following contents.

export ARM_CLIENT_ID="<client_id>"
export ARM_CLIENT_SECRET="<client_secret>"
export ARM_TENANT_ID="<tenant_id>"
export ARM_SUBSCRIPTION_ID="subscription_id"

Run this script before running any plan. Now, we have the setup ready and we can move on. If you get any error during the creation of the service principal, check your permissions and if your permissions are fine, it might have created the principal but still threw the error as happened in my case.

Managing Users in Azure AD

Azure AD provides robust user management capabilities that enable organizations to efficiently create and oversee user identities in the cloud. Here are some essential aspects of managing users in Azure AD:

User Properties

User Profile: Each user has a profile that contains basic information such as their name, email address, and contact details.
Assigned Roles: Users can be assigned specific roles within the organization, granting them access to various resources and services based on their responsibilities.
Administrative Units: Azure AD allows for the grouping of users based on geographical or organizational units, facilitating streamlined user management. Administrative Units (AUs) enable organizations to assign specific administrators to oversee users from particular regions or units.
Group Membership: Users can be part of different groups within Azure AD, allowing for efficient management of permissions and access rights.
Applications: Azure AD enables the assignment of applications to users, granting them access to specific software and services.
Licenses: Users can be assigned licenses that provide access to specific features or services within Azure AD.
Devices: Azure AD associates devices with user accounts, providing information about the devices and their join type, such as Azure AD join or hybrid Azure AD join.
Role Assignments: User roles define the resources to which a user has access, specifying their permissions and privileges.
Authentication Methods: Azure AD supports various authentication methods, allowing users to choose the method that best suits their needs.

Creating a user with Terraform

resource "random_password" "test" {
    length           = 16
    special          = true
    override_special = "!#$%^&*[]{}()"
}

resource "azuread_user" "test" {
    user_principal_name   = "<email-format-with-domain-specific-to-your-azure-account>"
    display_name          = "test"
    password              = random_password.test.result
    force_password_change = true
    given_name            = "article"
    surname               = "terraform"
}

Terraform forces us to provide a password for every user. So, I am using this random password generator first, getting a random password from it https://registry.terraform.io/providers/hashicorp/random/3.0.0/docs/resources/password and passing it to the user. I am also forcing the user to change the password when they first try to log in so that no one can see the password from the terraform state. Only the first 3 fields in the above "azuread_user" block are necessary and others are optional. I added "given_name" and "surname" blocks to help in the group creation which is coming next.

You can check more options that can be provided while creating the user here https://registry.terraform.io/providers/hashicorp/azuread/latest/docs/resources/user .

Streamlining User Management with Administrative Units

Azure AD introduces the concept of Administrative Units (AUs) to simplify user management and enable efficient delegation of administrative responsibilities. AUs are particularly useful for grouping users based on specific regions or organizational units. Here's what you need to know about Azure Administrative Units:

Efficient User Grouping: AUs help organize users based on geographical or organizational criteria, allowing administrators to manage users from specific regions or units more effectively.
Assigning Administrators: Within each Administrative Unit, administrators can be assigned specific roles to perform tasks relevant to their areas of responsibility. These roles include Authentication admin, Groups admin, Help desk admin, License admin, Password admin, and User admin.

By utilizing Azure Administrative Units, organizations can streamline user management, delegate administrative responsibilities, and ensure efficient control over user access and permissions based on specific regions or organizational units.

AUs require a premium tier account and I don't have one. So I m not able to show you a tested terraform example here.

Simplifying User Collaboration with Azure AD Groups

Azure AD groups provide a convenient way to manage and organize users within an organization, promoting collaboration and resource sharing. There are two primary types of groups in Azure AD:

Security Groups: Security groups are used to grant permissions to a set of users for specific cloud resources. They streamline access control and simplify user management by providing a collective set of permissions to a group of users.
Microsoft 365 Groups: Microsoft 365 groups facilitate collaboration by providing access to shared resources such as calendars, mailboxes, and more. They enable users to work together seamlessly on projects and initiatives.

Azure AD allows for different methods of grouping users into security groups:

Assigned Grouping: Users can be manually assigned to a group, providing direct control over group membership.
Dynamic User Grouping: Grouping users dynamically involves setting parameters based on user properties, and automatically adding or removing users from the group based on predefined criteria.
Dynamic Device Grouping: Similar to dynamic user grouping, dynamic device grouping involves setting parameters based on device properties, and automatically grouping devices based on predefined criteria.

Azure AD group properties and functionalities include:

Overview: Basic information about the group, including membership type and unique identifier.
Properties: Group details such as name, type, description, and other relevant attributes.
Members: Users who are part of the group.
Owners: Administrators with control over the group and its settings.
Administrative Units: Association of groups with specific AUs for streamlined management.
Group Memberships: Hierarchical grouping of groups within other security groups.
Applications: Assignment of applications to groups for collective access to services.
Licenses: Group-level assignment of licenses for consistent access to licensed features.
Role Assignments: Resources accessible to group members, defining permissions and privileges.
Dynamic Membership Rules: Configuration rules for automatic group membership updates based on criteria and properties.

Creating groups with Terraform

resource "azuread_group" "test" {
    display_name     = "test"
    security_enabled = true
    dynamic_membership {
        enabled = true
        rule    = "user.surname -eq \"terraform\""
    }
}

The "display_name" and either "security_enabled" or "mail_enabled" being true are required and all others are optional. To add users to a group depending on a condition, we use "dynamic_membership" which takes a rule according to which it groups users. Here, I am grouping users whose "surname" is equal to "terraform" and hence it adds only the user which we created before to this group.

This also requires a premium plan to work. We can manually add users to a group in the basic tier.

data "azuread_client_config" "current" {}

resource "azuread_group" "test" {
    display_name     = "test"
    security_enabled = true
    members = [
        azuread_user.test.object_id,
        data.azuread_client_config.object_id
    ]
}

This way, we can add users manually to a group by specifying their "object_id" in the members list. The way we fetch already existing data from the cloud to the terraform just to use some details on our current is through a "data" block like how we did in the first line above. In the above code, I am getting the current user who is applying the Terraform plan which is the user associated with the service principal that we created earlier to use with Terraform. And then, I added the object_id of it in the members list. So, this time, the group contains two users. One is the Terraform user, and the other is the user we created above with Terraform code.

Conclusion

Azure Active Directory (Azure AD) provides a robust and comprehensive solution for directory and identity management in the cloud. By effectively managing users, leveraging Administrative Units, and harnessing the power of Azure AD groups, organizations can streamline user management, delegate administrative responsibilities, and enhance collaboration among users. Azure AD offers a seamless and secure identity management solution that empowers businesses to embrace the cloud and unlock their full potential.

If you find this article helpful and informative, please don't forget to like and share it. Also, follow Chiranjeevi Tirunagari for more such articles. Consider connecting with me on socials at https://www.linkedin.com/in/vchiranjeeviak/ and https://twitter.com/vchiranjeeviak . Thank you.

Number types extended... ( in RUST )

Chiranjeevi Tirunagari — Wed, 05 Apr 2023 07:08:54 +0000

Introduction

Welcome back to this article in which we are going to see more things about number types in Rust. If you haven't seen the previous article where we discussed the basics of number types in Rust, please check that out first.

Note: This article comprises examples that are inspired by Rust in Action book by Tim McNamara.

A little bit about me...

Hi reader 🖐. I am Chiranjeevi Tirunagari and I am a software engineer. You can find more about me on Linkedin and Twitter. Also, subscribe to my youtube channel if you are interested in Rust, DevOps, and tech in general.

Now, let's get started.

Comparing values

We often must compare multiple values and do something accordingly in the code. We check if one value is smaller, greater, equal, or not equal to the other. In Rust, we can compare values if they belong to the same type. That's obvious. That happens in most languages, right? We can't compare an integer with a string in Java. Yeah, but it is much stricter in Rust. We can't compare one integer type ( like a u16 ) with another integer type ( like a u64 ).

For example,

fn main() {
    let num1 = 13_u16;
    let num2 = 300_u64;

    if num1 < num2 {
        println!("Went through!");
    }
}

If you try to compile this program, it throws an error saying "Types mismatched". But, we can't keep using the same type for all variables. Some variables may require less space when compared to others. We can't just use the bigger type just for the sake of comparison.

But, what we can do is that, we can cast one type to the other just while comparing without affecting the actual type of the variable. So, we can get rid of the error to do what we wanted in the above program by

fn main() {
    let num1 = 13_u16;
    let num2 = 300_u64;

    if (num1 as u64) < num2 {
        println!("Went through!");
    }
}

If you run it, you should see the "Went through!" output.

If you observe, we typecasted the smaller type into the larger one, not the other way around. That is because we get runtime issues when we try to typecast a larger type to a smaller one. Try to cast a bigger u128 number to the u8 type while printing to see that in action. You will see the change in values. This is because u8 can't accommodate bigger numbers that require u128 and so it wraps around.

Problem with floating-points

Floating points are the numbers that are represented in base 10. But anything that is being stored in computer memory is stored in base 2. This is where the problems arise. This makes the numbers lose precision when dealing with floating points. The following program throws an error which is unexpected generally.

fn main() {
    // assert_eq! checks if both arguments are equal
    // If not, the program panics (throws runtime error and crashes)
    assert_eq!(0.1 + 0.2, 0.3);
}

And the error looks like this:

As you can see, it evaluated 0.1 + 0.2 as 0.30000000000000004.

What can we do about this?

We can avoid comparisons between floating points.
Ignore the small difference that we got.

The small difference that we got in the above calculation is called epsilon. And we can write programs in such a way that epsilon is ignored when comparing. The program for the same is below.

fn main() {
    let sum: f32 = 0.1 + 0.2;
    let expected: f32 = 0.3;
    let absolute_difference = (expected - sum).abs();

    // assert! panics if the expression inside evaluates to false
    assert!(absolute_difference <= f32::EPSILON);
    // EPSILON is a constant available for both f32 and f64 types
}

There shouldn't be any error in this as we are accounting for the epsilon now.

Not a Number

Not a Number (NAN) is also a floating point number that doesn't have any value. This usually is resulted when we try to do operations that result in undefined. Examples include taking square root for negative numbers, etc. To see this, let's write a program.

fn main() {
    let root = (-56_f32).sqrt(); // sqrt function returns the square root
    assert_eq!(root, f32::NAN);
}

This program panics even though both the arguments for assert_eq! are NAN. This is because NAN is not equal to NAN. You can confirm this using the following program.

fn main() {
    assert_eq!(f32::NAN, f32::NAN);
}

Even this panics, which confirms our statement that NAN is not equal to NAN. How do we confirm if a result is NAN or not? We have a function called is_nan() for this purpose. Let's change our program to use that function.

fn main() {
    let root = (-42.0_f32).sqrt();
    assert!(root.is_nan());
}

This program shouldn't panic. We have a function called is_infinity() to deal with infinity cases like dividing with zero, etc. An example of that is below.

fn main() {
    let result: f64 = 11.0 / 0.0;
    assert!(result.is_infinite());
}

Conclusion

I hope this article helped you understand something that you already don't know.

If you find this read-worthy, please don't forget to like, share your thoughts and share this article with your friends and community because that encourages me a lot. Also, don't forget to connect with me on the socials I mentioned in the intro. Subscribe to my youtube channel as well for similar content if you are a visual learner. Let's meet in the next article, bye-bye 👋 until then.

Number types ( in RUST )

Chiranjeevi Tirunagari — Mon, 03 Apr 2023 06:50:04 +0000

Introduction

Welcome to this article in which we are going to cover what is called number datatypes in Rust. Most of the things we will discuss in this article are not just confined to Rust, but they are also evident in other programming languages. But, if you are here to learn Rust, then make sure you take a look at the previous 2 articles in this series which teach writing "Hello World" in 2 different ways.

So, let's get started.

A little bit about me...

Now, let's really get started.

Datatype

No matter which programming language you are dealing with, you must have heard one thing definitely which is Datatype. I am not getting into explaining data now. If you don't know what data is, then this is probably not for you. Usually, we are required to store some data as part of the application or program that we are writing. This data can be of many types. The names, addresses, and all other text data belong to some types. Numbers belong to some other types. We can create our own types, etc.

What we will see in this article is about Numbers related datatypes that are present in Rust.

Numbers

There are different types of numbers in general when it comes to Mathematics. In programming, we usually have 3 types of numbers. They are integers (without a fractional part), floating-point (with a fractional part) numbers, and complex (with an imaginary part) numbers.

In most applications, we don't need to use numbers with sharp precision or complex numbers or numbers with huge values. We can use Rust's default numbers. If you think, you need all of these, then it is recommended to use this crate called num. Okay, what is a crate? Good question. The simplest answer can be a package which provides some functionality out of the box for which we don't need to write code. We will discuss these in future articles.

Now let's see the default number types provided by Rust. But, before that, keep in mind that no matter what type it is, everything is going to be stored inside memory and it occupies some space in the memory.

Integers

As the name suggests, these are the numbers which can be 0, positive or negative. These numbers don't consist of a fractional part. Examples can be -100, 0, 34, etc. Depending on the range that the value can possess, integers can be classified into two types.

Signed Integers - values can be either positive or negative.
Unsigned Integers - values can only be positive.

Depending on the space required to store in the memory, integers are classified into multiple types such as 8-bit, 16-bit, 32-bit, 64-bit and 128-bit, the max. So, a 16-bit integer only occupies 16 bits in the memory. That is how it works. But, how does the space required affect the type? It affects the range of the type.

For example, let's consider an integer of 8 bits. We know that a bit can accommodate either 0 or 1. There are 2 possibilities to fill a bit. Then, how many possibilities are there in filling 8 bits?

0 or 1 0 or 1 0 or 1 0 or 1 0 or 1 0 or 1 0 or 1 0 or 1

_____ _____ _____ _____ _____ _____ _____ _____

2^8 !

which is equal to 256. That means an 8-bit integer's capacity is 256. If it is an unsigned integer, it can hold from 0 to 255 ( total 256 values ). If it is a signed number, it can hold from -128 to 127 ( total 256 values ).

We denote a signed integer with i and an unsigned integer with u. Usually, these letters are followed by their sizes. For example, i8, i16, u32, u64, i128, etc.

There are two other types of integers. They are usize and isize. u and i denote the same as before, but the size depends on the architecture of the system they are running in. If it is a 32-bit system, it will be of size 32. If it is a 64-bit system, it will be of size 64.

Variables

Usually, we assign values to variables. Variables are just names which are bonded with some values. The syntax to create a variable is let <variable-name>: <datatype> = <value>. The data type is not necessary when we are initialising it with some value. If we are just declaring the variable, then it is necessary to specify the datatype that the variable is going to accept.

All the variables in Rust are immutable ( value can't be changed ) by default. But, we can make them mutable using the mut ( call it mutt or mute, I like to call it mute, because that makes sense ) keyword. So, the syntax looks like let mut <variable-name> = <value>.

Size interpretation

When we are not initialising a variable along with its data type, then the compiler can interpret the type depending on the value. We can give values like 29u32 or 30_i64 etc. The compiler can parse these and can interpret the values accordingly. Similarly in the case with other datatypes as well. Even if we don't add suffixes like the above, the compiler can still do the job of interpreting the type when the variable or the value inside it is used to do operations such as arithmetic operations, comparisons etc. with other variables or values.

Floating-Point Numbers

Floating-point numbers consist of a fractional part. For example, 100.45, -56.32, 20.0 are considered a floating-point number. There are two variants of floats in Rust. They are f32 and f64. These types are associated with some constants like Infinity, Negative infinity, Max, Min, etc. for ease. They are also associated with some functions like sqrt(), floor(), etc.

Conclusion

In this article, we have just seen the theory part of it. For most of us, this is just basic. In the next article, we will see some code around it.

Traditional Hello World ( in RUST )

Chiranjeevi Tirunagari — Fri, 31 Mar 2023 10:13:27 +0000

Introduction

If you are new to Rust and you are here to know how to write "Hello World", I recommend you to check Simplest Hello World Ever ( in RUST ) first and then check this one. Even if you are new to programming, please check the above-mentioned article up to the Installation (rustup) part because that install rust compiler which is necessary for this article as well.

A little bit about me...

Hi reader 🖐. I am Chiranjeevi Tirunagari and I am a software engineer. You can find more about me on Linkedin and Twitter. Also, subscribe to my youtube channel if you are interested in Rust, DevOps and tech in general.

Context

Okay so now that we have everything ( just the rust compiler ) setup, we can start.

A tradition that is being followed from the ages while learning a new programming language is to write a Hello World program that prints the text "Hello World" in the console or terminal from where you have run it.

This is usually the easiest program to write in any language as is in the case of Rust. So, let's do that.

Hello World

To write a program, we need a file. And, this file's name should end with .rs extension which denotes the rust file. We can create files in multiple ways. But, as a programmer ( new or experienced ), it is our birthright to use terminal commands. The command to create a file is touch <file-name>. Feel free to name it whatever you want. I am going to name it hey.rs . So, the actual command that I need to use is touch hey.rs. This will create the file and you can open it using your favourite code editor ( vim/neovim users, I m watching you 😅 ).

Functions

We will discuss functions in detail in future articles, but let's understand what functions are at the basic level. Functions contain some code and we can run that code by calling these functions. In other words, when we call a function, it means that we are running code living inside that function. Different functions can have different names.

But, how do we define a function with a name? write code inside it? and call it?

Definition

To define a function, we need to use the keyword fn which denotes function and we specify the name using the syntax fn <function-name>() {}. We will see about the parenthesis "()" later in some other article but this is how we define a function.

Let's define a function with your name. I will do it with my name "Chiranjeevi" 👇

fn chiranjeevi() {}

Code

For this article's purpose, we just need to know coding how to print "Hello World". So, let's just do that.

To print anything to the terminal, the easiest way is to use print!() or println!() macros. We will see what macros are and how they are different from functions later. But, for now, what we need to know is that whatever we give inside the parenthesis () for print! and println! is printed to the terminal. The only difference is that println! shifts the cursor to the next line and print! keeps it in the same line.

Now, let's try to print "Hello World" using print! 👇

fn chiranjeevi() {
    print!("Hello World");
}

You might have observed those quotes " inside parenthesis () and surrounding our message. So, that's how we do to pass static ( which don't need to change anytime you run ) strings ( spoiler alert: slice / literal ).

And the lines are terminated with the semi-colon ; .

Function Call

To do what we are expecting our function to do which is printing "Hello World", we need to call it. Otherwise, no matter how many functions you write, they are useless and don't do anything unless you call them. We call functions with the syntax <function-name>();. So, to call the above function, we have to do chiranjeevi().

But, where do we do it? Let's see now 👇

Main

main is also a function whose name happens to be main which contains the code that needs to be run when the application starts running. This code inside the main can call other functions too which will run some other code and so on. But the important point here is that the main function is where the code execution starts when an application is started running.

Whatever "Hello World" program we are gonna write now is also an application (app). So, it needs to have a main function.

Now you might have understood that we need to call the above-created function inside the main. Let's do that.

fn chiranjeevi() {
    print!("Hello World");
}

fn main() {
    chiranjeevi();
}

Compilation

To convert the code that we have written in Rust into an executable file which can be run to perform what we have written as code, we need to compile the program. The command to compile a program is rustc <file-name>. In my case, it is going to be rustc hey.rs.

This will generate one or two files depending on your OS. In windows, there will be 2 or 1 in Mac/Unix with the name the same as the file you created. These are the binary files of program that we have written. To run these we need to do ./hey in Mac/Unix or .\hey.exe in windows.

You will see output something like this 👇

Try to see what the output looks like when println! is used instead of print!, you will get the difference.

Small change...

If you see, we don't actually need another function which runs print line. We can directly write that line inside main instead of writing in another function and calling that function. There won't be any change in the output, but we can reduce a function call.

So the final program should look like 👇

fn main() {
    print!("Hello World");
}

Conclusion

Whoaaa!!!! We just completed our "Hello World" without the help of cargo. But, please don't work without cargo when you are dealing with Rust.

Simplest Hello World Ever ( in RUST )

Chiranjeevi Tirunagari — Thu, 30 Mar 2023 05:05:46 +0000

Introduction

If this is not your first "Hello World" tutorial, then you probably already know how they start.

Creating a file.
Writing main function (in some languages).
Writing print statement with "Hello World".
Run it and claps 👏👏👏.

This is not going to be one of those. That kind of "Hello World" is coming in the next article, but for this one, it is going to be different and simpler.

A little bit about me...

Setting up

If you check any computer system which is being used by a software engineer for a long period, it is more probable to find a JDK ( may god bless if you don't know what it is, it is worth doing a google search if you don't know ) installed already. Because it is tried by almost everyone in tech at least once.

It is not the case with Rust 🦀 ( this is the last time, I m going to use this emoji, I promise ) though. It is pretty new and only a handful of people got hands-on with it. Hence, you need to install the rust compiler (rustc) to continue from here. If you already have one, feel free to skip this part.

How do you check if it is already there? Execute rustc -V in your terminal or command prompt. If you get some version numbers, you are good to go. If you see an error then you need to install it.

Installation (rustup)

If you go here: https://rustup.rs/ , you will see the command 👇

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Execute this command in your terminal or command prompt which will install rustup which is an installer for rust compiler and other rust tools.

After this, you should be able to get your compiler version using rustc -V.

Cargo

rustup installs something called cargo along with rustc. To put it in simple terms, cargo is a package manager ( helps manage packages also called crates in rust ) and a build tool ( helps convert rust code to binary ) for rust. More about the cargo on some other day. Let's concentrate on the goal of this article which is 👇.

Hello World

Now that we have our setup ready, let's start with our actual motive. For that, we need to create a project. To do that, we have a cargo command cargo new <project name>. Use this command in the terminal to create the project with the name you want. I am creating a project with the name hello. So, my command looks like cargo new hello.

If you do ls in unix/Mac or dir in windows, you should see a directory with the name hello or whatever name you have given. This directory contains some files which we will discuss in future articles.

For now, let's change to that directory using cd command. I am doing cd hello.

Now run cargo run in the terminal and Tada!! ✨✨

I hope you have seen "Hello, world!" in the terminal. The code for this is written inside main.rs file inside src sub-directory. When we run cargo run, cargo automatically compiles all the rust files in the project and starts running the project. Since, we have only one rust file which prints "Hello, world!", it did just that.

Thoughts...

We can do the same thing without using cargo by writing a rust file by ourselves without any project and writing the basic code that is required and compiling it and then running it. The reason why I started with cargo is that it is such a useful and powerful tool, so to show the taste of it. The only time I did everything manually without cargo is when I wrote my first hello world ( I m not experienced in rust, lol 😅 ) in Rust. But, it is good to know how things work. So, we will do it in the next article.

Conclusion

If you find this read-worthy, please don't forget to like, share your thoughts and share this article with your friends and community because that encourages me a lot. Also, don't forget to connect with me on the socials I mentioned in the intro. Subscribe to my youtube channel as well for similar content if you are a visual learner. Let's meet in the next article, bye-bye 👋 until then.

Essential prerequisites for programming

Chiranjeevi Tirunagari — Mon, 19 Dec 2022 16:35:46 +0000

Context

When starting to code, most beginners do the same mistake of diving right into it without having a context. Whenever we are starting something, we should start from a context just like this article that gives us a high-level overview, which helps us in deciding if we want to continue on that path or if it is something that doesn't excite us.

By the way, I am Chiranjeevi Tirunagari, working as a Product Engineer at Oslash. When I started to code, I didn't have much context on anything related to coding for many reasons. I did it anyway since it was my major in college. But, having the right context could have made me a better coder/programmer/engineer than I was, a lot faster.

The motive of this article is to provide the right context before someone starts their coding journey for which I am going touch on 4 topics which are:

What does exactly programming mean in the context of computers?
Code vs Program vs Software.
The basic architecture of computers.
How does program execution work?

1. What does exactly programming mean in the context of computers?

Telling a computer to do a specific task is called programming. Yes, that's exactly what it is. It can be anything from asking a computer to "tell an answer to a complex arithmetic operation" or "send some data or a set of files to another computer over the internet, also called web development" or "analyze past data and predict the future, also called machine learning". The task can be anything that is done by the computer, but one thing is common, being a programmer it is our task to tell the computer how to do that task, and that is called programming.

Since the computer is a machine that runs on electricity, all that is understood by a computer is a 0 or a 1 (binary language) under the hood, we need to program in such a way that the computer understands what we are programming. So, do we need to program in binary? Fortunately no. There are two things called compiler/interpreter (converts programming language code into machine level code) and operating system (converts machine level code into binary) which we will talk about later which do all the hard work to make the computer understand our program written in a language that we can understand by translating it into binary.

2. Code vs Program vs Software.

These are the words that people often use interchangeably even though they are not the same. The difference between these 3 is not something straightforward. It depends on the person's perspective on these words. Here, I will try to convey my perspective on all three of these.

Converting a word from one language to another is what actually coding is. A code in terms of computers is something we write in a language we understand and can be converted into something a computer can also understand. A code can exist without a purpose. This can be understood by the following example. Telling a computer to ask the user to tell their name is a code. Just taking the name from the user is not at all useful from any angle. But still, it is a code because we can tell the computer to do that even though it is not useful.
A program is something that is written to serve a purpose. All programs consist of code but do meaningful things. Considering the previous example again. If addition to taking the name from the user, if we are greeting the user with their name, then it is something meaningful. Here the purpose is to greet the user and not just do something that is useless. All programs are coded, but not all that are coded are programs.
Finally, the software is a collection of programs that aims to solve a problem. Let us consider an example here too. The program to greet a user is meaningful but not solving any problem. Nobody uses something just to greet them. If we have a set of programs that are helping the users pay their bills, of which the greeting program is also a part, then this set of programs can be called software as it is solving a problem. An operating system that we saw before is also software that solves the problem of dealing with the low-level implementation of other software executions to make computers understand them.

3. The basic architecture of computers.

The idea here is to show how the most important parts of a computer are connected together. The parts here don't mean devices like keyboards, mice, etc. A computer can still work without them and do the task it is supposed to do (alexa, smart homes, etc). Here the intention is to show the things which are absolutely necessary for every computer to function.
The two most important parts of a computer are CPU and memory.

A CPU is a chip that actually performs the execution of code/program/software on it. It is usually referred to as the brain of the computer.
Though the CPU is what performs the execution, there should be programs existing somewhere to make it available to the CPU to run and memory is what does that for the CPU. The memory stores the programs and passes them to the CPU whenever required to be run.

4. How does program execution work?

All that is there above this point just provides context for this section. This is the most important part of this article at least from my perspective.
As seen in the previous section, memory is one of the most important parts of a computer. There are 2 types of memory. They are primary memory and secondary memory. Primary memory devices are designed in such a way that the exchange of data between primary memory devices and CPU is much faster when compared to secondary memory devices.
But the primary memory is volatile in nature which means that once the power supply is off to the computer, the data in primary memory is gone and becomes empty whereas the data in secondary memory is non-volatile and stays even if the power supply is off.

This is the reason why the programs and software are stored in the secondary memory initially. When these programs are executed by the CPU, the code for the program is loaded into the primary memory and executed line by line.

Conclusion

What I have mentioned here is just the outline of what actually happens. There are lot more low-level things like PC, MAR, and MDR involved in this process and maybe they are topics for some other day. But, this is the bare minimum that we need before starting to learn to program. This feels very basic and intuitive if you already know it. But, most people don't know these basics and jump right into coding and struggle to understand.

That's it for this one. If you find this helpful, do share it with others. Please like and comment if you have any suggestions.

Make sure you follow me on Youtube and other social media platforms for more such content.
Youtube
LinkedIn
Twitter

Go - Defer, Panic and Recover

Chiranjeevi Tirunagari — Wed, 28 Sep 2022 17:48:41 +0000

Introduction

With the previous part (6), we finished basics in Go. Most of the topics covered in those parts are common in most programming languages. By hearing the topics covered in previous parts, we can relate them with other programming languages if we know any. The topics we are going to discuss in this part are Defer, Panic and Recover. I am not sure about the people reading this, but I haven't heard them before learning Go. But panic and recover are available in other programming languages as well but with different names. We will talk more about this later. Let's get into this one.

Defer

The functionality of defer is simple. It just delays the execution of a line for some time. Okay....How much time? It delays until all other lines in the function in which the defer line is residing are finished executing.

The syntax to use defer is defer <any valid line>.'

Basic example to illustrate defer functionality

package main

import "fmt"

func main() {
    defer fmt.Println("First line code, but comes last in output")
    fmt.Println("Second line in code")
    fmt.Println("Last line in code")
}

Output:

If you see the output, the line having defer printed last even though it is the first line in the function. That is what defer does. It delays the specified line of code until all other lines are executed in that function scope.

Program to illustrate multiple defer statements in same function

We saw how defer works. What if there are more than one defer statements in a function? Which line executes first and which one executes last?

To answer this, we need to understand what actually is happening when the defer line is being delayed. So, when we use defer before a line, when the control of program comes there, it pushes the defer line into a stack to store it temporarily. When the function execution comes to end, before it finishes, the lines pushed into the stack are popped out and executed one by one.

If you are aware how a stack works, it is a Last-In-First-Out data structure. Meaning, whichever item is pushed last into it, comes out first. So, in our context, the line which gets pushed into stack last, will get popped out first and executed first. See below code and output to see it practically.

package main

import "fmt"

func main() {
    defer fmt.Println("First line") // goes first into defer stack
    defer fmt.Println("Second line") // goes last into defer stack
    fmt.Println("Third line")
    fmt.Println("Last line")
}

Output:

In the above program, "First line" goes first into defer stack and "Second line" goes last. But in the output, after "Third line" and "Last line" got executed, "Second line" is executed first because it is the last line pushed into the stack.

Program to illustrate the variable values evaluation at defer line

I know the heading of this section is confusing. Even I don't understand what I have written. But just bear with me for this section.

Consider this situation where there is a variable in a function and that is being printed in a line. But there is a defer keyword before that line. After that line, we are changing the value of that variable. So, what value does the defer line prints? Initial value or Changed value? The line is using variable before changing the value. But also the line is being executed after changing the value. So, what value does it print?

The simple answer is when a defer line is pushed into the defer stack, it pushed along with the values of variables it is using but not the actual variable itself. So, no matter what happens to that variable after the line, the initial value is already pushed into defer stack along with defer line. Hence, it prints initial value.

I hope you understand the heading for this section a bit now.

package main

import "fmt"

func main() {
    testVar := 10
    defer fmt.Println("The value is: ", testVar) // should print 10 because the value is already evaluated
    testVar += 1
}

Output:

Panic

This word is something unique to this Go language but the concept is not. We call these as exceptions in other languages. Yeah so, basically if any runtime error happens while executing a code, it creates panic in the execution and the executions terminates abruptly.

If you are already familiar with runtime errors, then fine. If not, just consider them as unexpected errors those may occur while program is running. A simple such error can be occurred during dividing two numbers. Consider a situation where we are taking input from user for two number and divide one with the other. If the user gives denominator as 0 and we divide with 0, it throws a runtime error. This creates panic in the execution and execution stops no matter if there is code after it.

Program to create panic by dividing with 0

package main

import "fmt"

func main() {

    var a int
    var b int
    fmt.Scan(&a) // input 1
    fmt.Scan(&b) // input 2
    c := a / b   // division

    fmt.Println(c)
}

Output:

As you can see, since I have give second input as 0 and it divides with 0, the execution panics. Even though there is a print statement after that line, it won't execute it.

So, can a runtime error only create panic? No, we can create panic on our own using panic keyword. This is just like throwing errors in other languages.

Program to illustrate panic keyword

package main

import "fmt"

func main() {
    fmt.Println("This line prints fine since it is before panic")
    panic("Panicking just for fun")
    fmt.Println("This line won't get printed since it is after panic")
}

Output:

Why are we creating panic for fun? We definitely don't do it for fun. But, I am not getting any idea on top of my head to justify that we don't do it for fun. I will write another article if I find one. Or you can comment down if you have ever thrown an error in code in a serious use-case.

Recover

In real world code bases, there are multiple functions running one after the other. If we some panic is being created in one function stops entire code execution, the next functions won't even run. We don't want it in most situations. For that we need a way to avoid stoppage of code execution even if panic happens.

This is where recover comes into picture. Just for comparison, this can be mapped to catch in other languages, but not exactly same.

recover is a function which returns why the panic is created if there is one or returns nil if no panic is there. We have to handle the situation depending on the return value of return function.

Program to illustrate how not to use recover

The motive of this program is to show how beginners may use recover in a wrong way. The recover in this program is totally useless.

package main

import "fmt"

func main() {
    fmt.Println("This line prints fine since it is before panic")
    panic("You thought recover under me can help you? Hahaha!!")
    a := recover()
    if a != nil {
        fmt.Println("After recovery")
    }
}

Output

Since, the nothing after panic can run and execution stops there, recover is useless in the above case.

Program to illustrate correct usage of recover

Okay fine, if we can't use recover after panic, there is only chance to use it before panic. But before panic, recover returns nil since there is won't be any panic at that time which is also of no use. Then how do we actually handle panic? This is where defer comes in handy.

Write the recover and other panic handling code inside a function and call the function before panic line with defer keyword. So, technically it is before panic, so executes and also executes after panic so that recover does not return nil

package main

import "fmt"

func catch() {
    a := recover()
    if a != nil {
        fmt.Println("There is a panic, no worries, we handled it.")
    }
}

func panicking() {
    defer catch()
    panic("I am afraid, I might get caught!")
}

func random() {
    fmt.Println("Just there to show that program still continues")
}

func main() {
    panicking()
    random()
}

Output:

Conclusion

I hope you liked it. Next part will be on interfaces in go.

Do follow me to see them. Make sure you like and share if you felt this good.

Let's connect on: Twitter LinkedIn Showwcase

Go - Use-cases of non-primitive datatypes

Chiranjeevi Tirunagari — Wed, 21 Sep 2022 17:43:32 +0000

Introduction

Welcome to the part 7 of Go series. In the previous part (part 6): https://dev.to/vchiranjeeviak/go-maps-structs-485c, we saw what Maps and Structs are and how different operations like creating, adding, deleting etc can be done on them. In this one, lets see how we can iterate through them and the use-cases of these non-primitive datatypes.

Iterating through non-primitive datatypes

Arrays, Slices and Maps are some sort of collection of some similar type of values. There might be many situation where we want to go through each of these collections, do some computation or update the values. No matter what we do, going through the entire collection is the point to note here. We use loops to do this. Revisit this https://dev.to/vchiranjeeviak/go-conditionals-and-loops-5f1g loops article if haven't already for more context on loops.

Using normal for loop to iterate

Run a "for" loop from 0 until length of collection and do any operation on each item inside collection using index operator.

Program to print all items in a slice in new line

package main

import "fmt"

func main() {
    arr := []string{"one", "two", "three", "four"}

    for i := 0; i < len(arr); i++ {
        fmt.Println(arr[i])
    }
}

Output:

We can iterate through an array in the similar way. But in case of maps, this way of iteration is possible only if the keys in the map are of the int type. If it is not of int type, we can't use integer indices inside index operator.

Program to add all items in an array

package main

import "fmt"

func main() {
    arr := [5]int{1, 2, 3, 4, 5}
    sum := 0
    for i := 0; i < len(arr); i++ {
        sum = sum + arr[i]
    }
    fmt.Println("Sum = ", sum)
}

Output:

Using for-each loop to iterate

We now know why iterating using normal "for" loop is not always possible in case of maps. It is because maps don't guarantee that they always have int keys and while iterating using a normal "for" loop give us only integer value.

for-each loop lets us overcome this issue. If we use for-each loop with array or slice, it gives us 2 values, which are position and value. If we use for-each loop with maps, it gives us 2 values again, which are key and value.

The syntax to use it is for <pos/key>, <value> := range collection { }.

Program to print key and value combined as a string in a string-string map

package main

import "fmt"

func main() {
    mapp := make(map[string]string)
    mapp["one"] = "1"
    mapp["two"] = "2"
    mapp["three"] = "3"

    for key, value := range mapp {
        fmt.Println(key + value)
    }
}

Output:

Program to print position and value in a slice side by side

package main

import "fmt"

func main() {
    arr := []int{23, 52, 745, 13}

    for pos, val := range arr {
        fmt.Printf("%v -> %v \n", pos, val)
    }
}

Output:

This is how we can iterate through any collection like arrays, slices and maps.

Real world scenarios where non-primitive datatypes are useful

When we want to keep track of some items as a collection and we know the upper limit of the number of these items or want to limit the items to a particular number, then arrays are useful. I know it almost feels like a definition. Let's say we are keeping track of students joining in a class. Obviously every class is limited and let's consider the limit as 60. To store names/numbers of these students, we will need an array of max size 60.
Now, consider this situation where we need to keep track of voters in a country like we did for students in above example. Number of voters is not limited and not constant. So, we can't keep a cap on the value. This is a situation where we need a slice. When there is no limit required or known, to store items as a collection, slice is the way to go.
We can use maps wherever we are connecting two entities as a whole item. But the condition is that at least one of the two entities should be unique among all items. The unique entity is called as key. An item can be uniquely identified by these keys. A real world case can be keeping track of credit card number along with user name. Here, the relation we chose is the credit card and it's owner. So, credit card number is the key and owner name is the value. We can't represent a relation of a person and his credit cards. It is because, a person name can't be unique for all items. But in first case, a credit card number will always be unique in any pair.

A complex example of non-primitive datatypes and iteration

import "fmt"

type person struct { // defining a struct
    name string
    city string
}

func main() {
    register := make(map[int]person) // map of int key and person value type
    register[5463715] = person{name: "Ram", city: "Ayodhya"}
    register[2385928] = person{name: "Sita", city: "Mithila"}
    register[1432545] = person{name: "chiranjeevi", city: "Bangalore"}

    for id, person := range register {
        fmt.Printf("%v having id %v lives in %v. \n", person.name, id, person.city)
    }
}

Output:

Conclusion

That's it for this one. In the next one, we will see what defer, panic, recover are. Let's meet there.

More on Go lang will be coming soon and do follow me to see them. Make sure you like and share if you felt this good.

Let's connect on: Twitter LinkedIn Showwcase

Go - Maps and Structs

Chiranjeevi Tirunagari — Wed, 07 Sep 2022 14:43:55 +0000

Introduction

Welcome back to the Part - 6 of the Go series. In the last one, we saw two of the non-primitive datatypes (1. Arrays, 2. Slices) in Go. Do check it out if you missed it: https://dev.to/vchiranjeeviak/go-arrays-and-slices-52pi. In this one, let's see about 3. Maps and 4. Structs.

3. Maps

We saw how arrays and slices are a collection of other primitive datatype items. Maps are also a collection of items, but here the items are not just of primitive types, they are (key, value) pairs. And a key can be any primitive datatype item and same with value. But, the types should be consistent for all (key, value) pairs in the map.

Note: A key should be unique for each pair. In other words, no two pairs should have same key. By this assumption, we can uniquely identify a pair using its key.

Declare and Initialising a map

We use make function to create a map. map[primitive]primitive is a datatype. We are basically trying to say is that "make a map of this type".

Program to declare and initialise a map

package main

import "fmt"

func main() {
        // Declaring a map
    var map1 map[int]string // A map in which key is of int type, value is of string type
        // Initialising an empty map
    var map2 = make(map[string]int) // An empty map in which key is of string type, value is of int type
        // Initialising a non-empty map
    map3 := map[float64]int{ // A map in which key is of float type, value is of int type
        0.5: 0,
        1.5: 1,
        2.5: 2,
    }
    fmt.Println(map1)
    fmt.Println(map2)
    fmt.Println(map3)
}

Output:

Check the type of the map on your own using %T in Printf and you will realise why we are using that particular notation to create a map.

Adding and deleting items in a map

Adding a (key, value) pair into a map is straight forward. Using index operator, we give the new key into index and assign new value to it. It automatically create a new pair.

For deleting a pair, we use delete function which takes the map and key as input and deletes the pair with that particular key.

Program to add and delete a pair in map

package main

import "fmt"

func main() {
    // Initialising a map
    map1 := map[int]string{ 
        1: "string1",
        2: "string2",
    }
    fmt.Println("Map initially = ", map1)
    // Adding a new pair
    map1[3] = "string3" 
    fmt.Println("Map after adding (3, string3) = ", map1)
    // Deleting a pair with key 1
    delete(map1, 1)
    fmt.Println("Map after deleting pair with key 1 = ", map1)
}

Output:

4. Structs

Struct is a bit different from other non-primitive datatypes. It is not a collection of something like arrays, slices or maps. A struct is a complex datatype which is a fusion of other datatypes. It is a user-defined datatype which is a combination of other datatypes.

Defining a struct type

As I said earlier, it is a user-defined datatype. So, we need to define this type using the syntax type <name> struct { }. Inside this, we give other datatypes with their names using syntax <name> <datatype>. This is how we create the fusion.

Program to declare and initialise a struct type and create a variable of that type and print it

package main

import "fmt"

// Creating a struct1 type struct
type struct1 struct {
    nestedVar1 string
    nestedVar2 int
}

func main() {
    // Declaring a variable of type struct1
    var structVar1 struct1
    // Initialising a variable of type struct2
    structVar2 := struct1{"string1", 10}
    // Assigning value to structVar1
    structVar1 = struct1{"string2", 20}
    // Printing both
    fmt.Println(structVar1)
    fmt.Println(structVar2)
}

Output:

Accessing nested variable in a struct

In the above case, how can we access the string part of the struct1? We can do that using . . structname.nestedVar gives that particular value.

Program to create a struct variable and accessing a nested variable

package main

import "fmt"

// Creating a struct1 type struct
type struct1 struct {
    nestedVar1 string
    nestedVar2 int
}

func main() {
    //Initialising a struct1 type variable
    structVar1 := struct1{"string2", 20}
    // Printing nested variable
    fmt.Println(structVar1.nestedVar1)
}

Output:

Conclusion

That's it for this one. In the next part, lets see the use-cases of each of these non-primitive datatypes. Also, lets cover iterating through each of these datatypes which is very important.

More on Go lang will be coming soon and do follow me to see them. Make sure you like and share if you felt this good.

Let's connect on: Twitter LinkedIn Showwcase

Go - Arrays and Slices

Chiranjeevi Tirunagari — Sat, 03 Sep 2022 09:47:37 +0000

Introduction

Welcome back to the Part 5 of Go lang series. In Part 2: https://dev.to/vchiranjeeviak/go-variables-constants-and-datatypes-502j, we saw what datatypes are and how many types are there in Go. Those are primitive datatypes meaning that they are basic. In this one, let's see about arrays and slices which are non-primitive datatypes in Go.

Non-Primitive datatypes

A datatype which is a group of variables of any primitive or non-primitive datatypes is called non-primitive datatype. Revisit this line after reading below non-primitive datatypes. You will get a clear picture of this line then.

There are 4 non-primitive datatypes in Go. They are:

Arrays.
Slices.
Maps.
Structs.

Let's see maps and structs in the next article.

1. Arrays

An array is a collection or group of values where each value belongs to the same type. In other words, all variables or items present in an array should be of same datatype.

An array in Go has a fixed size which is specified during the time of declaration or initialisation. And, its size is fixed can't be modified during program execution.

Program to illustrate declaring and initialising arrays

package main

import "fmt"

func main() {
    var arr1 [10]int // Declaring an array of size 10
    arr2 := [10]int{1, 2, 3, 4, 5} // Initialising an array of size 10 with {1, 2, 3, 4, 5} values.
    fmt.Printf("This is array 1: %v", arr1)
    fmt.Printf("This is array 2: %v", arr2)
}

Output:

Since, we haven't given any values in arr1, it is taking all values as default values, which is 0 in case of int. In arr2, the first 5 values are given by us and remaining 5 are default values.

Program to add an item at 6th position in an array of size 10

We can specify a particular position of an array using index ([]) operator. Inside these [], we give the index number. Index number = Position - 1. So, to specify 6th position of an array, we use [5] according to above expression. We use this index operator right beside the array name.

package main

import "fmt"

func main() {
    arr := [10]int{1, 2, 3, 4, 5} // Initialising array
    fmt.Println(arr) 
    arr[5] = 6 // Adding an item at position 6, a.k.a index 5
    fmt.Println(arr)
}

Output:

A negative point of an array is that its size is fixed and cannot grow or shrink automatically depending on the situation. For example, in the above array of size 10, you can't add a 11th item into it. It throws an error. So, we need to know the maximum length of the array that we require in that program.

What if it is not possible to know the maximum length of array in prior? What if we want our array to grow or shrink according to the needs? That is where slices come in handy.

2. Slices

A slice is very similar to an array. The only difference between a slice and an array is that there is no fixed size for a slice. Its size can grow or shrink depending on the situation.

Declaration or initialisation of a slice is similar to an array except that we don't specify any size like we do in the case of an array.

Program to declare and initialise a slice

package main

import "fmt"

func main() {
    var slice1 []string // Declaring a slice of type string
    slice2 := []string{"chiranjeevi", "golang"}
    fmt.Println(slice1)
    fmt.Println(slice2)
}

Output:

Program to add a new string at the end of a slice

We can't add a new item at a specific position of a slice like we did in array. We can only add a new item at the end of the slice. We do that using a function called append. This is a default function. It takes 2 arguments. One is the slice, and other one is the item we want to add. This function returns a new slice with new item added to the old slice.

package main

import "fmt"

func main() {
    slice1 := []string{"chiranjeevi", "golang"}
    fmt.Println(slice1)
    slice1 = append(slice1, "devops") // Assigning it to the old slice again
    // Bcoz the append function only return new slice
    // It doesn't change the old slice.
    fmt.Println(slice1)
}

Output:

Updating value at a position in array and slice

We can update an already present value in an array and a slice. Specify that position using index operator and assign a value to it. We did this while adding item to an array. There we assigned item to a position where there is nothing assigned already. So, it is adding an element. If we try to do the same when there is an item present there already, it is updating an item.

Program to update value at a position in array


package main

import "fmt"

func main() {
    arr := [5]int{1, 2, 3, 4, 5}
    fmt.Println(arr)
    arr[3] = 400 // Updating value of 4 (index 3) to 400
    fmt.Println(arr)
    // arr[5] = 500 //Trying to assign value to position not present
    // This throws an error if uncommented above line.
}

Output

Output if uncommented the error line

We didn't use index operator while adding an item to a slice. It is because, we can't access a position which is not part of an array or slice. In case of an array, we know the size of it while declaring, so we can add any item as far as we are adding to a position which is present in the array. But, when it comes to slice, we don't know the size that a slice currently possessing. If we try to update or access a position which is not already present in the array or slice, it throws an error. We can get size or current length of an array or a slice using len function.

Program to update a value in slice

package main

import "fmt"

func updateSlice(slc []int, pos int, val int) []int {
    if (pos >= len(slc)) {
        fmt.Println("Slice index out of bound")
    } else {
        slc[pos] = val
    }
    return slc
}

func main() {
    slc := []int{1, 2, 3, 4}
    fmt.Println(slc)
    slc = updateSlice(slc, 1, 500)
    fmt.Println(slc)
    slc = updateSlice(slc, 5, 1000)
    fmt.Println(slc)
}

Output:

Function - arguments and return type

We discussed about functions in the first article of this series, check it out if you missed it: https://dev.to/vchiranjeeviak/go-hello-world-3ino. In that one, we saw what function header, arguments and body are. Now, let's see how we actually declare arguments from the above code example.

We declare arguments inside a pair of parenthesis. For each argument, we have to give a name with which we want to call it inside the function succeeded by its datatype.

In above example, we need the slice, the position at which we are updating and the value with which we want to update as arguments. So, we need to declare 3 arguments in total. First one is of type slice with integers, so we declare it as []int preceded by the name. Second is the position which is an integer, so int preceded by its name. Third is the value which is also an integer, so int preceded by its name. Hence, it boiled down to (slc []int, pos int, val int). That is why when we are calling the function, we used updateSlice(slc, 1, 500). The number of arguments and order should be maintained as it is in the declaration.

Also, there is something after these arguments outside parenthesis. That is called the return type of the function. It means that the value which is returned by the function has that type. In our example, we are returning a int slice, so we gave []int as return type. Where does it return to? The value is returned to the place where the function is called. We are calling it inside main function, so it returns the value there. That is the reason why we are re-assigning it to the original slice there.

Conclusion

That's it for this one. In the next article, lets cover maps and structs.

More on Go lang will be coming soon and do follow me to see them. Make sure you like and share if you felt this good.

Let's connect on: Twitter LinkedIn Showwcase

Go - Conditionals and Loops

Chiranjeevi Tirunagari — Wed, 24 Aug 2022 16:43:00 +0000

Introduction

Welcome back to this part 4 of the Go lang series. In part 3, we covered pointers and user input. Check it out: https://dev.to/vchiranjeeviak/go-pointers-user-input-4mh9 if you missed it. In this one let's see conditionals and loops in go.

Conditionals

Generally, programming is all about writing some logic in the form of code so that machine can understand. One of the most vital part of writing logic is to deal with some conditions. We may want our machine to react differently in different situations. In those cases, we specify those situations as conditions and write how machine needs to work in those situations. We do this using conditionals.

We can write conditions in 2 ways. They are:

if-else.
switch-case.

1. if-else

We write the code which we want to be executed if a specific condition is met is written inside if block along with a condition.
The code which we want to get executed when that condition is not met is written inside else block.

The syntax to use if-else is:

if <condition> {
    // code which needs to be executed if above condition is met
} else {
    // code which needs to be executed when above condition is not met
}

Condition

A condition in an if-else syntax can be any combination of logical operation and relational operation.

There are many types of operators in Go lang and logical, relational operators are two of them.

Before going into it, there is something we need to know about operands. An operand is a variable or value on which the operator performs the operation.

Logical operators

An operation done using logical operators is called logical operation. There are 3 logical operators. They are AND (&&), OR (||) and NOT (!). These logical operators are applied on operands which can be evaluated to a boolean value (true or false). Both AND and OR are binary operators (refer: Part 3 for this) take two operands on either sides of the operator. AND evaluates true only when both the operands are true or false in any other case. OR evaluates true when at least one of them is true or false in any other case.

operand 1	operator	operand 2	result
True	AND	True	True
True	AND	False	False
False	AND	True	False
False	AND	False	False
True	OR	True	True
True	OR	False	True
False	OR	True	True
False	OR	False	False

NOT takes only one of the boolean values and gives back the other one.

Operator	Operand	Result
NOT	True	False
NOT	False	True

Okay.... This is fine, but where do we get these True or False from?

That's where relational operators come into picture. We usually give an expression which contains relational operators and which is evaluated to one of the boolean values.

Relational operators

Relational operators are operators which check if the given relationship between two operands is true or not. Let's say, if there is an expression which says "5 is greater than 6", it is giving relationship between two operands and it is obviously false in this case.

There are 6 relational operators. They are:

Operand 1	Operator	Operand 2	Result
5	== (equals to)	6	False
5	!= (not equals to)	6	True
5	> (greater than)	6	False
5	>= (greater than or equals to)	6	False
5	< (less than)	6	True
5	<= (less than or equals to)	6	True

Program to illustrate if-else

We are writing a program to check if the user given integer is in the range [0, 100). Depending on the input, we will print a unique message accordingly. This representation says that the number should be between 0 and 100, and can be equal to 0 but not equal to 100. One of our relational expression should be our number >= 0 and other one should be our number < 100. And, we need to combine both of them with an AND (&&) because both of them are necessary checks.

package main

import "fmt"

func main() {

    var someNumber int

    fmt.Println("Enter an integer:")

    fmt.Scan(&someNumber)

    if ((someNumber >= 0) && (someNumber < 100)) { // Condition
        fmt.Println("In our range") // Comes here only when the condition is true
    } else {
        fmt.Println("Not in our range") // Comes here only when the condition is false
    }
}

2. switch-case

I don't want to complicate switch-case because it is as simple as a real switch board. We can design a digital switch board just like how we have a unique switch for fan, light, bulb etc..

Syntax for switch-case:

switch (<variable/value>) {
    case <some value>:
        // code
    case <some other value>:
        // code
    default:
        // code
}

Program to illustrate switch-case

This example is enough to understand switch-case. We take a string input from user. If it is a "fan" given as input, we print "switched fan on". If the input is "light", we print "switched light on". If it is anything else, we print "Press the correct switch".

package main

import "fmt"

func main() {

    var userInput string

    fmt.Println("Give input:")
    fmt.Scan(&userInput)

    switch (userInput) {
        case "fan":
            fmt.Println("switched fan on")
        case "light":
            fmt.Println("switched light on")
        default:
            fmt.Println("Press the correct switch")
    }
}

Note: I am not giving outputs in this article. Please run by yourself and comment if you find any errors in code.

We can write the same code using if-else also. Try doing that yourself and comment if you faced any difficulty. I know this is basic stuff if you are coming from other programming language background, but this can be challenging for someone who started coding.

Loops

There might be some situations where we want to run some block of code multiple times. And, the number of times can be decided by a condition or an event. An example situation can be "Taking a string input from user until it is special" or "Printing numbers from 1 to 100, etc. Wherever we see repetition of task, we can apply loops there.

Unlike many famous programming languages, Go has only one type of loop, which is for loop. The syntax of for loop is:

for <condition> {
    // repetitive task
}

Until the condition is satisfied (evaluates to True), the code written inside keeps running again and again.

Whenever we think of conditions, we should remember logical and relational operators. Because, most of the times, conditions contain only them.

Program to take user input until we get `special` as input

Let's declare a variable to store input, and write a Scan statement inside for loop. But, we have to think of condition that satisfies our situation. We need to stop this loop only when we receive special. So, we need to make it run until the input is not special. And let us also print a line after loop to show that the program control came out of it.

package main

import "fmt"

func main() {
    var userInput string

    for userInput != "special" {
        fmt.Scan(&userInput)
    }
    fmt.Print("Outside loop")
}

This will keep running until you give special as input.

Program to print numbers in [1, 100) range

We can have a variable initialised to 1. When gone inside loop, print the variable, update it by increasing its value by 1 every time. We can stop when our variable value is greater than 99 or equal to 100.

package main

import "fmt"

func main(){
    number := 1
    for number <= 99 {
        fmt.Println(number)
        number++
    }
}

++ is a unary operator which increases the value of the variable by 1.

Every time we go inside a loop, we call it an iteration. This is an important terminology to know for next topics.

We are initialising a variable outside loop, writing a condition on it, and updating its value inside loop just print its value in the loop. It can become tough if the code in file is huge to keep track of this particular variable. So, it is better handle this kind of variables inside for parameters. The syntax is:

for (<initialisation>; <condition>; <updation>) {
    //code
}

Lets see how above code can be converted into this method.

package main

import "fmt"

func main() {
    for (number := 1; number <= 99; number++) {
        fmt.Println(number)
    }
}

This can be much more readable and cleaner.

Infinite loops

An infinite loop is a loop which doesn't stop running and runs forever either until the memory is full or power is disconnected. Most modern programming languages and their run time environments or compilers handle this carefully without letting your system get hanged. Yeah, that's what happens when your RAM is full of apps. How can we invoke an infinite loop? It is very simple to do. We just need to give a condition (check syntax of loop) in loop which is never going to false. One such condition can be 0 > 10. This condition will always be false no matter how the variables in the program change. Or we can just give true (boolean) as condition as anyway any condition we give at last is evaluated to either true or false.

Program to print 1 infinite times

package main

import "fmt"

func main() {
    for true {
        fmt.Println(1)
    }
}

This might give a warning that true is not required to provide as if we don't give anything, it considers as true.
So, a corrected perfect program can be:

package main

import "fmt"

func main() {
    for {
        fmt.Println(1)
    }
}

I encourage you to run this and see how an infinite loop prints if you are a beginner. If you are not a beginner, I am sure that you must have seen this a lot of times.

If we had given false instead of true, the loop doesn't even run once.

Can we run finite loops without giving a condition? The answer is partially yes. Because, we still give a condition but not at the usual place we give. We provide a condition when to stop running inside the loop but not outside loop. We do this using break and continue.

Break and Continue

break and continue are two keywords in most programming languages and so in Go. When a loop is running, if we want to stop running that loop at a particular iteration and not run further, we use break. When a loop is running, if we want to skip one particular iteration and run remaining iterations normally, we use continue.

Program to print [1, 100) using break

package main

import "fmt"

func main(){
    number := 1
    for {
        if (number == 100) {
            break
        }
        fmt.Println(number)
        number++
    }
}

This program also prints 1, 99. But the difference is in how we wrote the loop and base condition.

Program to print [1, 100) but don't print 10

package main

import "fmt"

func main(){
    number := 1
    for {
        if (number == 10) {
            continue
        }
        if (number == 100) {
            break
        }
        fmt.Println(number)
        number++
    }
}

If you think this will print 1 to 99, then you are wrong. Why? Because, when the number is 10, it goes into if block and executes continue, which will take it directly out of loop and enters back into the loop from top. It will never execute number++ line, which means the number value is not going to move from 10 and will keep rotating for loop which makes it an infinite loop.

To make it work as we intend to, we need to make a small change:

package main

import "fmt"

func main(){
    number := 1
    for {
        if (number == 10) {
            continue
            number++ // new added line
        }
        if (number == 100) {
            break
        }
        fmt.Println(number)
        number++
    }
}

This newly added line makes sure that the number value is increasing even when it hits continue.

Conclusion

That's it for this one... Like and share this if you loved it. Follow me for the future content.

Let's connect on: Twitter LinkedIn Showwcase

Go - Pointers and User input

Chiranjeevi Tirunagari — Sun, 21 Aug 2022 05:53:00 +0000

Introduction

This is the part 3 of the Go lang series. In the previous part, we saw what variables, constants and datatypes are. Check Part 2 if you missed it. In this one lets see what pointers are and how we can take input from the user who is running the program.

Before going into pointers (very important to understand pointers)

Before understanding pointers, we need to understand how the program execution works. It is different from language to language and it will be similar for some languages. Some programming languages interact with computer memory and some don't. So, "What memory are we talking about?". It is Random Access Memory (RAM).

Memory

Any high-level program or software is basically stored in hard disk to use it whenever needed. The programs written in these type of languages are loaded into RAM when we want to run and then each line of code starts running there. Any memory needed to run that like storing variables, constants etc is also taken from RAM. Sometimes, some data used by a running program can be stored in cache or in secondary memory which is hard drive depending on few factors.

Some languages like Java, Javascript, Python etc have their own runtime environments. These runtime environments act as an interface between programs and actual memory. They still use primary memory to run but not directly. They actually use something called virtual memory which maps to actual main memory of system. The addresses will be different for actual and virtual and can be mapped only by these runtime environments which is a very low level implementation. This is bit out of the way to our intention of this article. So, let's continue with RAM for now since Go doesn't use any runtime environment and directly interacts with system memory.

Memory animation

Addresses

So, now that we know that programs especially of C, C++, Go run in RAM and these use some memory to store data required to run. The unit of memory is bytes. And 1 byte = 8 bits. A bit can contain either 0 or 1. Each byte in a memory device can be uniquely identified by its address. The address will be of the form Hexadecimal. Something like 0x324XF432. And there is an order for these addresses because the memory is continuous.

Can we see the address of a variable programatically? Yes, we can do by using the & operator. On a side note, an operator is a symbol which performs a special operation on some data (operands), and the number of operands is dependent on the operator. & operator is applied on only one operand, hence, it belongs to unary operators group. There are other groups like binary operators (2 operands) and ternary operators (3 operators). So, the only operand that & (ampersand / address) operator takes is the variable name.

Program to find address of a variable

An example program to get the address of a variable:

package main

import "fmt"

func main() {
    someVariable := 10

    fmt.Println(someVariable) // This prints value of someVariable
    fmt.Println(&someVariable) // This prints address of someVariable
}

Output:

This output of address will be different for system to system. Even we get different address value every time we run.

Pointers

So, now we know how and where data (variables, constants) is being stored. This is where pointers come into picture.

Definition

Pointer is just another datatype like int, string, boolean. But, what a variable of type pointer stores is address. We saw how addresses look like in above output. A pointer stores those kind of address. Whose address they store? We can store addresses of other variables and constants.

Questions to keep in mind for future

What is the point of storing addresses? How are pointers useful? Are pointers good or bad? These are valid questions. To know the answers, we need to go deeper into learning this language. We will find out answers to each of these questions in future articles. These questions are highlighted as topics in future articles. So do wait / check if they are already published by me.

Pointer of pointer

We saw that a pointer variable stores addresses. So, it is just like any other variable, which means that it is also stored in memory, which means that a pointer variable also has an address, which means that this address value can be stored in other pointer, which is called pointer of pointer.

I hope you got an idea on pointers. You will be more confident when you get to know the answers to the above questions. So, just keep this concept in mind.

User input

Now that we are comfortable with the concept of addresses and how variables are stored, it is a perfect time to know how to take input from user while program is running (run time).

As we discussed in previous articles, even though we are not having a value while writing program and taking that value from user in run time, we need to reserve some space in our program memory to store it when program receives it. And we do that by declaring (not initialising, check Part 2) a variable for this value.

Scan

The function we use to take user input is Scan. It belongs to the same "fmt" package to which Print also belongs. If I forgot to convey that fmt is short for format, now you know.

So, we pass the address (I hope you know how to get address of a variable from above part of article) of the variable in which we want to store the input value to the Scan function. This function pauses the program execution when it reaches that line and waits for user to give the input. Once the user gives input and hits Enter, it resumes from there.

Program to illustrate user input

An example program which takes a number as input from user and prints the next number to the screen:

package main

import "fmt"

func main() {

    var number int // declaring integer variable

    fmt.Scan(&number) // we pass address using &
    // The program execution pauses here until user provides input and hits enter

    fmt.Println(number+1) // Printing next number
}

It will wait like this until you give some number to it and hit Enter. If you give other than a (int) number, it throws an error.

I gave 122 as input and hit Enter. Here is the output.

User input in Go/C/C++ vs Python/Java/Javascript

This is how we take user input in run time. We can learn this concept in the introductory class / video / article of languages like python or java. It is because that there is no concept of interacting with memory in them. So, there are no addresses in them. But, Go has this like C/C++ and so we had to learn about addresses first.

Conclusion

That's it for this one. Next article is going to be on conditionals and loops in Go.

Do follow me to see them. Make sure you like and share if you felt this good.

Let's connect on: Twitter LinkedIn Showwcase