Just like any programming language Go also provides flow controls to control the program execution. In this post, I will be discussing if-else, for loop and switch statements.

If-else

If-else statement is used to execute only some specific code when a certain condition is true. You can also provide an else block that gets executed if the condition results in false.

If-else statements can also be chained together by putting an if statement in the else block of another if statement. Similarly, you can put one if statement in another if statement and this is called a nested if statement.

In Go syntax for writing an if statement is as follows:

if <condition> {

//Your code will come here

}

You can also add an initialization statement just before the condition.

if <initialization>; <condition> {

//Your code will come here

}

Observe that the condition is not enclosed in the parentheses. Also, the else keyword should come at the same line as the closing braces of if block.

Note: Variables declared in the if statement are only available inside the if statement.

Code example

package main

import "fmt"

func main() {
// if-else statement
    var a int = 6
    if a<20{
        fmt.Println("A is less than 20")
    }else{
        fmt.Println("A is greater than 19")
    }


    // if statement with initialization statement
    if x:=10;x > 30 {
        fmt.Println("x is greater than 5")
    } else if x > 5 {
        fmt.Println("x is greater than 5 but not greater than 30")
    } else {
        fmt.Println("x is 5 or less")
    }

    // nested if-else
    y := 10

    if y > 5 {
        fmt.Println("x is greater than 5")
        if y > 2 {
            fmt.Println("x is greater than 2 but not greater than 5")
        } else {
            fmt.Println("x is 2 or less")
        }

    }
}

Loop

If you want to repeat something again and again, a loop is all that you need. All programming languages provide loops. Let's start with the for loop.

For loops have three components namely, initialization, condition and lastly update statement.

The syntax for writing for loop in Go is as follows

for <initialization>;<condition>;<updation> {

//Your code comes here

}

Initialization and updation components of the loop are optional.

There is also another kind of loop called the while loop. While loop goes on running as long as the loop condition results in true.

Syntax of while loop in Go

for <condition>{

// Your code comes here

}

Note here also the condition is not enclosed in parentheses

Code example

package main

import "fmt"

func main() {
    // Basic for loop
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }
    // for loop with only condition
    count := 5
    for ;count>0;{
        fmt.Println(count)
        count--
    }
    // while loop
    i := 0
    for i < 5 {
        fmt.Println(i)
        i++
    }
}

Switch-case

The switch-case statement is a convenient way to write chained if-else statements. To write a switch statement you have to write switch keyword and provide a variable to it after that you write each case. Depending on which case matches with the variable, the code block gets executed. If none of the cases matches then control moves to the next statement. You can optionally provide a default case that gets executed when none of the cases matches.

For the case value, you can provide a constant, a variable or even an expression. Here is the syntax for writing the switch-case statement:

switch <variable>{

case <value>:

//case code comes here

case <value>:

// case code comes here

...........// more cases can be written here

case default:

// default case code

}

Keep in mind that like other languages(C/C++, java, etc) you do not put a break at the end of each case. And if one case gets executed, rest of the cases are ignored, if you want to execute the rest of the cases use fallthrough keyword.

Code example

package main

import "fmt"

func main() {
    day := "Tuesday"

    switch day {
    case "Monday":
        fmt.Println("It's Monday.")
    case "Tuesday":
        fmt.Println("It's Tuesday.")
    case "Wednesday":
        fmt.Println("It's Wednesday.")
    case "Thursday":
        fmt.Println("It's Thursday.")
    case "Friday":
        fmt.Println("It's Friday.")
    case "Saturday":
        fmt.Println("It's Saturday.")
    case "Sunday":
        fmt.Println("It's Sunday.")
    default:
        fmt.Println("Invalid day.")
    }
}

Conclusion

So in this blog, I wrote about the control flow statements like if-else, loops and switch-case statements. You can combine these statements with different operators to write complex logic. So this was it for the control flow statement.

For related posts here is the link

For more updates subscribe to my newsletter.

Like, share and comment on this post, it encourages me to keep writing blog

Give your feedback, it helps me to improve.

Link to the previous post

Last year, I signed up for a tutoring platform, and this year, by some chance I got a student from the United Kingdom. And this is where my journey as a tutor started.

I had been learning programming and other tech-related stuff like how technologies work under the hood. Though I was working as a freelance web developer, I still felt like I was missing something, I was learning but not progressing much.

Learning and building skills

I used to spend hours every day focussing on web development. My knowledge was increasing. I was trying different things and also, every couple of months I used to go back to the basics, like programming language, frameworks, etc. I was building projects and all.

Got a message for a tutoring session

3rd March 2023, I got a message from a software engineering student for learning Python. I scheduled a demo session so that I could talk to him and understand the problems he faced. It was a good session. I showed him how I would be teaching him programming. He knew what was going on but struggled with practical coding. So, we started to work on it. Slowly building the foundations and writing codes.

The result of our efforts

He passed the subject successfully. Though it was focused on data structures and algorithms. But, since he understood Python properly he was able to come up with the solutions for the problems.

After this, he and some of his friends started learning Java from me. I started my programming journey with Java when I was in school. But by teaching it I learned something amazing, that I hadn't paid attention to earlier.

Teaching others taught me

As I was teaching Object Oriented Programming, I observed and realized how the frameworks work, and how inheritance and abstraction are used and this was an eye-opener for me. Learning something and understanding what, how, why and when of something are very different. This teaching experience helped me to become better.

Feeling good for helping others

I taught two students Object Oriented Programming with Java. One of them scored above 80 out of 100 and the other one scored above 90 out of 100. By watching them grow and improve, it made me excited to share more of my knowledge with them. They benefitted from my learning and it was a big win for me. More importantly, it made me happy.

Got more students

Through that same platform I got another student but this time it was a 14-year-old child. I wasn't sure, whether I would be able to teach a young child or not. So, I just accepted it and we had a demo session. It wasn't how I expected it to be, it was kind of good. Since he was a school student and not a college undergraduate, I had to be more cautious and understanding.

My main objective was to teach him Python in the simplest way possible. After a few lessons I observed that, to make him comfortable with coding I had to give him challenging coding tasks. So, we spent a couple of sessions just coding programs one after another.

So I would just explain to him what he has to do and he would try it on his own. I explained to him how to think about writing programs and how to visualize them and we covered some basic algorithms.

Later on, I got suggested to more students through word of mouth(recommendations from the people I taught).

Conclusion

So I will conclude by saying whatever you learn, find people who are interested in learning it and if possible teach them. It gives you a new perspective and sometimes it also challenges you to explain a complex concept simply. Well, sometimes I do struggle to explain some concepts because in my mind I can visualize them, so I try different ways to explain and observe what explanation is easiest to understand.

I would recommend everyone if possible to give it a try, not to create a livelihood out of it but to gain some experience of teaching.

If you liked reading this article, give it a like and share it with someone who may find it useful.

For more updates subscribe to my newsletter.

Let's have a quick look at these operators and their uses.

Arithmetic Operators

These operators are used for performing mathematical operations like addition, subtraction, multiplication, division and modulus.

For those who are new to programming, modulus operators return the remainder of a division operation.

The code snippet below shows how to use arithmetic operators.

package main
import "fmt"

func main() {
    var a int = 20
    var b int = 30
    // Addition
    fmt.Println(a + b)
    // prints 50

    // Subtraction
    fmt.Println(b - a)
    // prints 10

    // Multiplication
    fmt.Println(a * b)
    //prints 600

    // Division
    fmt.Println(b / a)
    // prints 1, (logically it should be 1.5) reason is given below

    // Modulus
    fmt.Println(b % a)
    // prints 10
}

All the results were as per expectation but the division returned the value 1.

The reason for this behavior is that, for the result to be a floating point number both the operands must be of a float type.

Comparison Operators

Comparison operators are also called as the relational operators. These operators are used to compare two values. Comparison operators include equality, inequality, less than, less than equal to, greater than and greater than equal to. These operations result in a boolean value i.e. either true or false.

The usage of these operators is demonstrated below.

package main
import fmt

func main(){
 // Equality check
    fmt.Println(a==b);
    // results in false

    // inequality check
    fmt.Println(a!=b)
    //results in true

    // less than 
    fmt.Println(a<b)
    // results in true

    // less than or equal to 
    fmt.Println(a<=b)
    //results in true

    // greater than
    fmt.Println(a>b)
    // results in false

    // greater than or equal to
    fmt.Println(a>=b)
    // results in false
}

Assignment operators

The assignment operator is used to assign value to a variable. Assignment operators can also be combined with operators for some common combination of operations like add and assign value( += ), subtract and assign value( -= ) and so on.

All of the assignment operators are listed below.

package main
import "fmt"

func main(){
    var a float32 = 10
        fmt.Println("Initial Value of a:",a)
        // Add and assign
        a += 5
        // is equivalent to a = a + b
        fmt.Println("Value of a after adding 5:",a)

        // subtract and assign
        a -= 5
        // is equivalent to a = a - b
        fmt.Println("Value of a after subtracting 5:",a)

        // Multiply and assign
        a *= 5
        // is equivalent to a = a * 5
        fmt.Println("Value of a after multiplying by 5:",a)

        // Divide and assign
        a /= 5
        // is equivalent to a = a / 5
        fmt.Println("Value of a after dividing by 5:",a)
}

Logical Operators

Logical operators are used to combine conditional expressions. AND, OR and NOT are logical operations with the following properties.

AND

Logical AND results in true only when both conditions are true, otherwise it results in a false.

<condition 1> && <condition 2>

OR

Logical OR results in false only if both conditions are false, otherwise it results in true.

<condition 1> || <condition 2>

NOT

Logical NOT negates the value from true to false and vice versa

!<condition>

Using logical AND (&&)

package main

import "fmt"

func main(){
    var a int = 10
    var b int = 15
    // combining two conditions together
    if a<20 && a>5{
        fmt.Println("A is greater than 5 and less than 20")
    }else{
        fmt.Println("A is either less than 6 or A is greater than 19")
    }
}

Using logical OR ( || )

package main

import "fmt"

func main(){
    var a int = 10
    var b int = 15
    // combining two conditions together with ||
    if a>20 || a<5{
        fmt.Println("A is less than 5 or greater than 20")
    }else{
        fmt.Println("A is greater than 4 and A is less than 21")
    }
}

Using logical NOT ( ! )

package main
import "fmt"

func main(){
    var isActive bool = false
    if !isActive{
        fmt.Println(isActive)
        isActive = !isActive
    }
    fmt.Println(!isActive)
}

Bitwise Operators

Bitwise operators perform operations at the bit level. Bitwise operations are faster than normal operations since they directly manipulate the bits. Bitwise operators include bitwise AND ( & ), bitwise OR ( | ), bitwise XOR ( ^ ), bitwise clear ( &^ ), left shift( << ) and right shift ( >> ).

Bitwise AND truth table

Bitwise OR truth table

Bitwise XOR truth table

Bitwise AND NOT (Bit clear &^) Operator

This operator is used to unset the specific bits. Observe the following example.

result = number1 &^ number2

Therefore, result = 1 0 0

In short, this operator takes the number2 and inverts its bits, then it performs the bitwise & on the number1 and the inverted number2.

The effect of this operation is that for every set bit of number2, the corresponding bit of number1 will be unset.

Shift Operators

Left shift ( << )

This operator shifts the bits of the operand by a specified number to the left and adds that many zeroes at the end of the number.

Example: shifting bits of 101110 to the left by 2

result = 101110<<2

result = 111000

n<<k is equivalent to n*2^k

Shifting bits of a number n to the left by k is equivalent to multiplying the number by 2^k

Right shift ( >> )

This operator shifts the bits of the operand by a specified number to the right and adds that many zeroes at the beginning of the number.

Example: shifting bits of 101110 to right by 2

result = 101110>>2

result = 001011

n>>k is equivalent to the floor of n/(2^k)

Shifting the bits of a number to the right by k is equivalent to the floor of the division of the number by 2^k.

Miscellaneous Operators

Address operator ( & )

if you put & in front of an addressable operand of type T, it will give you a pointer of type T to its address location. You can store or pass the address of a struct instance to a function.

Receiver operator ( <- )

This operator is used for passing values between concurrently running goroutines. In the upcoming Go concurrency-related posts I will discuss this operator.

References

To read more about Golang operators you can use the following.

Go specifications - Operators

Conclusion

This post was a quick overview of the operators in Go. Being aware of all the operators provided by a programming language is crucial to utilize all the features of the language. I hope this post will help you in your Go learning journey. Comment and share your learnings.

Subscribe to my newsletter for more updates

Like, share and follow my blog for Web development-related content.

The link to my previous blog is here

This blog is in continuation with the previous blog, where I discussed variables and functions in Golang. In this blog, I will be discussing the various data types in Go and the constants. For the previous post, the link is here.

Data types

Data types define what kind of data is stored inside a variable and what operations can be performed on it. For example, if I want to store a number without any fractional part, I will use an integer data type, for real numbers(numbers with fractional part), I will use float/double data type and so on.

List of Data types in Go

Numbers

1. Integer

   • int, int8, int16, int32, int64

   • uint, uint8, uint16, uint32, uint64, uintptr

2. Float

   • float32, float64

3. Complex

   • complex64, complex128

4. Byte

   • byte (alias for uint8)

5. Rune

   • rune (alias for int32) for storing unicode character

Text

String

1. • string is a sequence of bytes.

Boolean

bool can store either a true or false.

Types to be discussed in later posts

Array

Array denotes a numbered sequence of elements of a single type. Arrays have fixed size. Once created you cannot change the maximum size of the array. Arrays are 0 indexed.

Slice

Slices are just a section of an array. In Go, slices are used for creating dynamic arrays. Slice has size and capacity.

Custom Data type

You can create custom data types by combining different data types using struct, I will discuss the struct in the upcoming blog posts.

Using data types

In Go, while creating the variable, after writing the variable name we write the data type that can be any of the above-mentioned as well as user-defined structs.

import "fmt"
func main(){
    var age uint = 16
//  age is a value that can hold a uint value
    var name string = "Rishabhdev"
//  name is a variable that holds sequence of characters(string)
    var pi float64 = 3.14
//  pi is a variable of float64 type
    var isStudent bool = true
    fmt.Println("Age:",age)
    fmt.Println("Name:",name)
    fmt.Println("is Student:",isStudent)
    fmt.Println("Value of Pi:",pi)
}

Similarly, you can create a variable with any data type.

Constants

Constants are the named values that cannot be changed. The rules for naming constants are the same as variables, usually, constants' names are capitalized to differentiate them from the variables. If you provide the data type to a constant then it is called a Typed constant and if you do not provide the data type to the constant then it is an Untyped constant. Constants are declared using the const keyword then followed by the constant name and type.

Typed constant syntax

const <name> <type> = <value>

Untyped constant syntax

const <name> = <value>

Using constants

The following code shows how to create constants in Go.

Typed constants example

const TEAM_SIZE uint = 12

func main(){
    fmt.Println("Maximum number of players in the Team:",TEAM_SIZE)
}

Untyped constant example

func main(){
    const PI = 3.14159265359
    fmt.Println(PI)
}

Conclusion

Having knowledge of data types is very important. Using constants is also important to stop certain values from changing. In the upcoming blog, I will be discussing Operators in Go. I will be showing you different kinds of operators in Go namely arithmetic, comparison, logical, assignment and bitwise operators.

Keep supporting me by reacting and commenting on my blog posts. This encourages me to keep on writing more blogs.

Link to previous blog is here

Follow, like, share and subscribe to the newsletter for upcoming blog posts.

Introduction

Go a.ka. golang is a statically-typed compiled high-level programming language as you can find on google yourself. Now let's look at some other aspects of go. Go is a procedural language which means that we define a series of instructions called procedures to create programs. It supports concurrency in the form of go routine which are light-weight threads. It is a modern programming language developed by Ken Thompson, Robe Pike, and Robert Griesemer in 2007 and released in 2009 as an open-source programming language.

Use Cases

Go is a very fast language and it has built-in support for network programming and concurrency. Some of the major use cases of go are the following.

• DevOps and Cloud computing: Many of the DevOps tools like docker, Kubernetes, Graphana, Prometheus, etc. are written in Go.

• Web Development: Golang is being used to write high-performance backends. Frameworks like fiber and gin can be used to build backends in Go. Go is also widely used to build microservices.

Other than these two, you can do almost anything with Go.

Basics: Variables

Variables are named locations in the computer memory where you can store data. You can access the value using the name of the variable. To create variables in go look at the following code snippet.

// This the main function where the program execution begins
func main(){
    // Now I am creating a variable named 'name' of type string
    // with value Rishabh
    var name string = "Rishabh"
}

So the basic syntax is as follows

// creating a variable without any initial value
var <variable-name> <data-type>
// or
// creating a variable with given value
var <variable-name> <data-type> = <value>
// If value is provided data-type can be omitted
var <variable-name> = <value>

Now there is another way to create variables in Go, check this out

func main(){
// this is another way to create variable
    name := "Rishabh"
}

Pay attention that I am not providing any data type information while creating the variable. Go compiler is smart enough to infer the type of variable depending on the value to the right of := .

Note you cannot use the second syntax in the global scope, i.e. it is valid only inside functions.

// Invalid statement, since it is outside the function
country := "Wakanda"
// Valid statement, You can use var syntax to create variable 
// outside the functions. 
var leader string = "Black panther"

func main(){
//  valid statement
    var number int = 99
//  valid statement, allowed inside functions
    number2 := 50 
}

Note: You cannot use short-hand assignments outside the functions.

Multiple assignments on the same line

You can assign values to multiple variables on the same line, by separating variables by ,(comma) and providing values in the same order as variables like in the following code.

import "fmt"
func main(){
    var a,b,c int = 45,66,99
// a = 45, b = 66, c = 99
    fmt.Println(a,b,c)
    x,y,z := 10,20,30
// x = 10, y = 20, z = 30
    fmt.Println(x,y,z)
}

Functions

The function is a named group of statements that performs some specific task. For writing functions, there are three important parts,

1. Name of the function

2. Input of the function

3. Output of the function.

Function syntax

func <name of function>(<list of arguments(input)>) <return-type> {
    <body of the function>
}

// Example of a function
// this function takes two integers, adds them and
// returns an integer i.e. sum
func sum(num1 int, num2 int) int{
    return num1+num2
}

If the arguments of a function are of the same type you can omit data types for all but the last argument. Observe the following code

func sum(num1, num2 int) int {
    return num1+num2
}

Multiple return values

Any number of values can be returned by a function. You just need to provide the list of return types in the function signature

func twoValues(x, y int)(int,int){
    return y,x
}

Notice how I have provided a list of return types after the argument list.

Named return types

You can also name the return types and in this way, there is no need to write the name of the returned value Go will automatically return the named return values.

For now, observe the following code.

func myFunction(a int, b int)(z int){
    z = a + b
    return
}

In the above code, you can see I haven't returned anything but since I have named the returned variable, Go will automatically return the z.

As per Go documentation, you should use named return values only for short functions.

Conclusion

This is it for this blog I will be discussing data types, type casting and constants in the next one. I am going to share all my learnings, in a way that would help others. Feel free to suggest or discuss programming.

I will be posting more Go content, So stay tuned. More blog posts are coming where I will dive deep into this modern language.

Link to next blog is here.

Like, Comment, Share and Follow for more.

Keep supporting, It motivates me to keep creating content.

Introduction

Formset is a way of working with multiple forms at the same time. Using Formset you can use multiple forms on a single page. In this article, we will be creating formset using a model and see all the options that are available to customize formset.

Creating Formset

To create a formset we use the modelformset_factory function. You pass the Model and fields for which you want to make the Formset. modelformset_factory returns the Formset for the given model with the provided fields. Therefore it will be something like this:

from django.forms import modelformset_factory,ModelForm
from django.db import models

# Note Model Definition
class Note(models.Model):
    title = models.CharField(max_length=80)
    description = models.TextField()


# Here we create a formset of Note
NoteFormset = formset_factory(Note, fields=['title','description'])

While creating a formset you can pass an additional parameter extra with a number then the Formset will contain that many empty forms.

If you have created a ModelForm with custom fields you can pass it to modelformset_factory

#Example 
#Creating formset from NoteForm For Note with 5 empty forms
NoteFormset = formset_factory(Note,NoteForm, extra=5)
# This will create 5 empty forms in the formset

Formset with initial data

You can provide initial data for forms by passing a list of dictionaries with data. This will create forms equal to the length of initial data provided(Total number of dictionaries in the initial data list) + the value of the extra parameter passed during the creation of Formset. If you want to fill data from the database you can pass queryset as keyword argument and the forms will be filled with the data from the passed queryset.

Look at this code for better clarity.

NoteFormset = formset_factory(NoteForm,extra=5)
# This formet contains 5 empty forms
# This list contain 3 dictionaries
data = [
        {'title':"note no-1","description":"description-1"},
        {'title':"note no-2","description":"description-2"},
        {'title':"note no-3","description":"description-3"}
        ]
# We passed the initial data to the NoteFormset
# Now forms contain 3 forms with data and 5 empty forms
# So total 8 
# filling the form with initial data
forms = NoteFormset(initial=data)

# Passing data from database
# for filling formset with queryset
forms = NoteFormset(queryset=Note.objects.all())
# for keeping the formset empty
forms = NoteFormset(queryset=Note.objects.none())

In this way, you can provide data to be filled in the forms of the formset.

Controlling the number of forms in a Formset

You can also control the number of forms to be displayed. For this, you need to pass another parameter called max_num to the Formset. Have a look at the following snippet.

# This list contain 3 dictionaries
data = [
        {'title':"note no-1","description":"description-1"},
        {'title':"note no-2","description":"description-2"},
        {'title':"note no-3","description":"description-3"}
        ]

formset = NoteFormset(initial=data, extra=4, max_num=5)
# This form will display 3 forms filled with data and 2 empty forms
# Keep this in mind if the number of forms with data exceeds the max_num
# then also all the forms with the data will be created but 0 empty forms

Even if you provide the max_num less than forms with data then all forms with data + empty forms till max_num will be created.

Another parameter absolute_max can be passed to formset_factory to set the limit for the number of forms to create from POST data or initial data. In this way even if the initial data exceeds the absolute_max still only absolute_max number of forms will be instantiated.

NoteFormset = formset_factory(Note, NoteForm, absolute_max=30)
# Now NoteFormset cannot contain forms more than absolute_max value

Note: Absolute_max should be greater than max_num else ValueError will be raised

Passing the POST data to a formset

To pass POST data you simply do this

If your form also deals with files/images don't forget to pass request.FILES to the formset while processing formset

formset = NoteFormset(request.POST, request.FILES)
if formset.is_valid():
    formset.save()

Formset validation

To validate a formset call is_valid(). This will validate if the data entered in the forms was valid or not. is_valid() method returns a boolean denoting whether formset is valid or not.

Rendering Formset in templates

Now, we will be looking at how to render formset in a template

# View function
def process_form(request):
    if request.method=='POST':
        # processing formset
        return redirect('next view')
    data = Note.objects.all()
    # If we do not provide any argument to the formset then
    # also it will be filled with queryset of the model
    formset = NoteFormset()
    return render(request,'template/form.html',context={'formset',formset})

Let's look at form.html

Note: If you are dealing with files/images in the form don't miss enctype="multipart/form-data"

<form method="post" enctype="multipart/form-data">
    {% csrf_token %}
    {{ formset.management_form }}
    {% for form in formset %}
        {{ form.as_p }}
    {% endfor %}
    <input type="submit" value="Save">
</form>

It is important to include a management form inside the HTML form. So you will add {{formset.management_form}}

And this is all that you need to know to start using model formsets. For learning more about formset read the official docs here Formset and ModelFormset.

So are still reading why don't you like this post and share it will your fellow pythonistas and learners?

Share your views and story of learning tech.

In this blog post, we will be creating templates for our authentication system. We will be creating a base template that will contain the common elements of all the templates and then we will create other templates which inherit from the base template. We will be creating templates for logging users in and registration forms for different user types.

Getting started

• Update settings, to let Django know where to find templates & static files(CSS, Js, etc.)

• Create a base template

• Create other templates

• Adding CSS

• Django Templating Language Basics

• Preview of Templates

Updating the core/settings.py

Firstly we will add the path of our templates to core/settings.py. We will create a folder named 'templates' in the project root where we will store the templates. We will also create separate subfolders for different apps.

• Open the core/settings.py

• Go to TEMPLATES settings

• Add 'templates/' to the DIRS key

• Add STATIC_ROOT settings

• Add STATICFILES_DIRS settings to list directories to search for static files

    # core/settings.py
    TEMPLATES = [
        {
            'BACKEND': 'django.template.backends.django.DjangoTemplates',
            # List of directories
            'DIRS': ['templates/'],
            # Whether to search inside each app for templates
            'APP_DIRS': True,
            'OPTIONS': {
                'context_processors': [
                    'django.template.context_processors.debug',
                    'django.template.context_processors.request',
                    'django.contrib.auth.context_processors.auth',
                    'django.contrib.messages.context_processors.messages',
                ],
            },
        },
    ]
  
    STATIC_ROOT = 'collected_static/'
    # url used to refer files in STATIC_ROOT
    STATIC_URL = 'static/'
  
    # List of paths to look for static files
    STATICFILES_DIRS = [
       'static/'
    ]
  

  Note: DIRS is a list of paths for Django to look for templates. APP_DIRS tells Django to also look inside each app

• Now Django will look for templates in the 'templates' folder in the project root and the templates folder inside each application.

• It will also look for static files from directories in STATICFILES_DIRS

Creating a base template

Create a simple HTML document and save it as base.html inside templates/authentication.

We have included some template tags for including static files and adding named placeholders which will be replaced when the actual web page will be rendered.

<!DOCTYPE html>
{%load static%}
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>{%block title%}{%endblock%}</title>
    <link href="{%static 'main.css'%}" rel="stylesheet">
  </head>
  <body>
    <div class="">
      {% if messages %}
        <div>
            <hr>
            {% for message in messages %}
            <center>{{ message }}</center>
            <hr>
            {% endfor %}
        </div>
      {% endif %}
        {%block content%}{%endblock%}
    </div>
  </body>
</html>

Creating the remaining templates

• Login Template

{%extends 'authentication/base.html'%}
{%block title%}Login{%endblock%}

{%block content%}
<center>
<div class="title black">Login with Your Credentials</div>
    <form class="form" method="post">
        {%csrf_token%}
        <input name="email" type="email" placeholder="Email" required>
        <input name="password" type="password" placeholder="Password" required>
        <input class="submit-button" type="submit" value="Login">
    </form>
</center>
{%endblock%}

• Registration Template

  In this template, we will be passing our CustomUserCreationForm which will be rendered automatically. Also, this template will be used to create two web pages. We will pass the creation form depending on user type to this template.

{%extends 'authentication/base.html'%}
{%block title%}Registration{%endblock%}

{%block content%}
    <center>
      <div class='title {%if title == "Teacher Registration" %} purple {% else %} blue {%endif%}'>{{title}}</div>
      <form class="form" method="post">
        {%csrf_token%}
        {%for field in form%}
        <div class="label">{{field.label}}</div>
        <div class="field">
        {{field}}
        </div>
        {%endfor%}
        <hr>
        <label for="confirmation">Check this box for confirmation</label>
        <input type="checkbox" name="confirmation" id="confirmation" required>
        <input class="submit-button" type="submit" value="Register" />
      </form>
    </center>
{%endblock%}

Adding CSS

Create a main.css in static folder in the project directory

/* static/main.css */
body {
  box-sizing: border-box;
  background-color: white;
  font-family: "Segoe UI", Tahoma, Geneva, Verdana, sans-serif;
  margin: 0;
}
input {
  padding: 1rem;
  margin: 0.5rem;
  border: none;
  outline: 1px solid grey;
  border-radius: 0.5rem;
}
input:focus {
  outline: 2px solid blue;
}
.title {
  font-size: 2rem;
  font-weight: lighter;
  font-family: "Segoe UI", Tahoma, Geneva, Verdana, sans-serif;
  padding: 4rem 0rem;
  color: white;
  box-shadow: 5px 3px 4px black;
}
.form {
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  height: 60vh;
}
.label {
  padding: 0.5rem;
}

.submit-button {
  margin: 1rem;
  padding: 1rem 1.5rem;
  background-color: #2b7cff;
  color: white;
  outline: none;
  transition: all 0.3s ease-in-out;
}
.submit-button:hover {
  transform: scale(1.04);
}
.purple {
  background-color: #7323b5;
}
.blue {
  background-color: #0047ba;
}
.black {
  background-color: #000;
}

@media screen and (min-width: 480px) {
  .form {
    height: 55vh;
  }
}
hr{
    width:10rem;
}

Project Structure

Django Templating Language Basics

• {% %} notation is used for statement

• {{ }} notation is used for expressions

• {%block name %}{%endblock%}: Placeholder that will be replaced when the template will be rendered on user request. We will change the title of the template using the title block and the body of the template using the content block. The rest of the template will remain the same.

• {{variable}}: you can access variables passed to the templates through a context dictionary.

For in-depth reading Official Django Templating Language Docs

Templates Preview

Now, these form templates are fully functional and you can add Students and Teachers using them.

Try starting the project by activating the virtual environment if not yet activated.

# for linux / macOS
source env/bin/activate
python3 manage.py runserver



# for windows
./env/Scripts/activate
python manage.py runserver

After starting the project try the following URLs

• 127.0.0.1:8000/auth/register-teacher/

• 127.0.0.1:8000/auth/register-student/

• 127.0.0.1:8000/auth/login/

Conclusion

Now we have almost completed the authentication and registration part. We learned about templates and how we can define a template once to create any number of web pages with different data, as we have created a single template to render different forms. We also saw how to use static files like CSS in Django.

In the next blog, we will be creating a new app that will handle profile creation. From now on we will be quickly moving forward since we know how to define views, URLs and templates.

Like, Comment and Share

Your feedback will be really helpful for improvement. Feel free to connect and discuss technologies.

Happy Learning

References

Django Template Language

Templates Settings in Django

Static Files Settings in Django

Previous part

For the authentication system, we will start by defining our user model and then creating proxy models to differentiate between different types of users. We will also define custom managers for the models to override the create_user and get_queryset methods.

After defining our models we will be creating our custom user creation form and user change form to create and update our users. Then defining URL paths and writing view functions to process the form data and register different types of users.

For a better, understanding give the following blogs a read.

Learn about the Structure of Django Applications Here

Learn About Django Models Here

Defining Custom User model

We will be extending the AbstractBaseUser from django.contrib.auth.models and setting email as the username field for logging in users.

# authentication/models.py
from django.utils import timezone
from django.db import models
from django.contrib.auth.models import AbstractBaseUser, BaseUserManager, PermissionsMixin

# This the user manager with function to create_user and create_superuser methods. Manager is used to perform query operations
class UserManager(BaseUserManager):
    def create_user(self, email, password=None):
        if not email or len(email) <= 0:
            raise ValueError("Email Field is required!!!!")
        if not password:
            raise ValueError("Password is required")

        user = self.model(
            email=self.normalize_email(email)
        )
        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_superuser(self, email, password):
        user = self.create_user(
            email=self.normalize_email(email),
            password=password
        )
        user.is_admin = True
        user.is_staff = True
        user.is_teacher = True
        user.is_superuser = True
        user.save(using=self._db)
        return user

# This is the custom user model with type attribute for differentiating user types. Default type is student
class User(AbstractBaseUser,PermissionsMixin):
    class Types(models.TextChoices):
        STUDENT = "STUDENT", "student"
        TEACHER = "TEACHER", "teacher"
    type = models.CharField(
        max_length=8, choices=Types.choices, default=Types.STUDENT)
    email = models.EmailField(unique=True, max_length=100)
    date_joined = models.DateTimeField(default=timezone.now)
    is_active = models.BooleanField(default=True)
    is_admin = models.BooleanField(default=False)
    is_staff = models.BooleanField(default=False)
    is_superuser = models.BooleanField(default=False)
    is_teacher = models.BooleanField(default=False)
    is_student = models.BooleanField(default=False)
    USERNAME_FIELD = 'email'
    objects = UserManager()

    def __str__(self) -> str:
        return str(self.email)

    def has_perm(self, perm, obj=None) -> bool:
        return self.is_admin

    def has_module_perms(self, app_label) -> bool:
        return True

    def save(self, *args, **kwargs):
        if not self.type or self.type == None:
            self.type = User.Types.STUDENT
        return super().save(*args, **kwargs)

Defining Proxy model for different user types

Proxy models operate on the same database table of concrete class in our case it is User but proxy models can have different behavior, permissions and meta options. We have used proxy models since both students and teachers should be able to login into the system.

# authentication/models.py
# Manager for student
class StudentManager(models.Manager):
    def create_user(self, email, password=None):
        if not email or len(email) <= 0:
            raise ValueError("Email is Required!!")
        if not password:
            raise ValueError("Password is Required!!")
        email = email.lower()
        user = self.model(
            email=self.normalize_email(email)
        )
        user.set_password(password)
        user.save(using=self._db)
        return user

    def get_queryset(self, *args, **kwargs):
        queryset = super().get_queryset(*args, **kwargs)
        queryset = queryset.filter(type=User.Types.STUDENT)
        return queryset

# Student proxy model
class Student(User):
    class Meta:
        proxy = True

    objects = StudentManager()

    def save(self, *args, **kwargs):
        self.type = User.Types.STUDENT
        self.is_student = True
        super().save(*args, **kwargs)

# Manager for Teacher model
class TeacherManager(models.Manager):
    def create_user(self, email, password=None):
        if not email or len(email) <= 0:
            raise ValueError("Email Required!!")
        if not password:
            raise ValueError("Password is Required!!")
        email = email.lower()
        user = self.model(
            email=self.normalize_email(email)
        )
        user.set_password(password)
        user.save(using=self._db)
        return user

    def get_queryset(self, *args, **kwargs):
        queryset = super().get_queryset(*args, **kwargs)
        queryset = queryset.filter(type=User.Types.TEACHER)
        return queryset

# Teacher proxy model
class Teacher(User):

    class Meta:
        proxy = True

    objects = TeacherManager()

    def save(self, *args, **kwargs):
        self.type = User.Types.TEACHER
        self.is_teacher = True
        self.is_staff = True
        return super().save(*args, **kwargs)

For each proxy model, we have overridden the save method to change the attributes as per the proxy model and save the model

Creating UserCreationForm and UserChangeForm

Now we will extend the UserCreationForm and UserChangeForm and modify them as per our Proxy model. While defining a Form in Django we define the model in the inner class Meta along with fields to be exposed through the form.

# authentication/forms.py
from django.contrib.auth.forms import UserCreationForm, UserChangeForm
from authentication.models import Student, Teacher, User

# Creation form for our Concrete Model
class CustomUserCreationForm(UserCreationForm):
    class Meta:
        model = User
        fields = ('email',)

# Change form for updating User
class CustomUserChangeForm(UserChangeForm):
    class Meta:
        model = User
        fields = ('email',)

# Creation form for Teacher proxy model
class TeacherCreationForm(UserCreationForm):
    class Meta:
        model = Teacher
        fields = ('email',)

# Change form for updating Teacher
class TeacherChangeForm(UserChangeForm):
    class Meta:
        model = Teacher
        fields = ('email',)

# Creation form for Student proxy model
class StudentCreationForm(UserCreationForm):
    class Meta:
        model = Student
        fields = ('email',)

# Change form for updating Student
class StudentChangeForm(UserChangeForm):
    class Meta:
        model = Student
        fields = ('email',)

Updating core/settings.py and core/urls.py

The next step is to add our authentication app to the installed_apps list

# core/settings.py
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
# I have added authentication app here
    'authentication',
]
# Settings to use our custom user for authentication
AUTH_USER_MODEL = 'authentication.User'

# core/urls.py
from django.contrib import admin
from django.urls import path, include
# Here we have included authentication urls to the main django project
# All path starting with 'auth/' will be looked up in authentication app urls file
urlpatterns = [
    path('admin/', admin.site.urls),
    path('auth/',include('authentication.urls'))
]

Defining URL paths and View Functions

Create a urls.py file in the authentication folder and add the following lines to it

# authentication/urls.py
from django.urls import path
from django.contrib.auth.views import LoginView
from . import views
# path( "path string/", views.function, name="optional name of path"
urlpatterns = [
path('',
    views.homepage,
    name="homepage"
    ),
path(
    'login/',
    views.loginUser,
    name="login"
    ),
path(
    'logout/',
    views.logoutUser,
    name="logout"
    ),
path(
    'register-student/'
    ,views.registerStudent,
    name="register-student"
    ),
path(
    'register-teacher/',
    views.registerTeacher,
    name="register-teacher"
     ),
]

Now we will create view functions that are triggered as per the URL path that the client accesses in our web application.

# authentication/views.py
from django.shortcuts import redirect, render
from django.contrib import messages
from authentication.forms import StudentCreationForm, TeacherCreationForm


def homepage(request):
    return render(request, "homepage.html")


def registerStudent(request):
    if request.method=='POST':
        form = StudentCreationForm(request.POST)
        if form.is_valid():
            form.save()
            messages.success(request,'Registered Successfully')
        else:
            messages.error(request,'Please recheck the form data')
        return redirect('register-student')
    form = StudentCreationForm()
    title = "Student Registration"
    return render(request, 'authentication/register.html', {'form': form,'title':title})


def registerTeacher(request):
    if request.method=='POST':
        form = TeacherCreationForm(request.POST)
        if form.is_valid():
            form.save()
            messages.success(request,'Registered Successfully')
        else:
            messages.error(request,'Please recheck the form data')
        return redirect('register-teacher')
    form = TeacherCreationForm()
    title = "Teacher Registration"
    return render(request, 'authentication/register.html', {'form': form,'title':title})


def loginUser(request):
    if request.method=='POST':
        email = request.POST['email']
        password = request.POST['password']
        user = authenticate(request,email=email,password=password)
        if user is not None:
            login(request,user)
            messages.success(request,"Logged in Successfully")
            return redirect('homepage')
        else:
            messages.error(request,"Invalid credentials!")
    return render(request,'authentication/login.html')


def logoutUser(request):
    logout(request)
    return redirect('login')

For using the creation form we create an instance of the form and pass it to the template for rendering. We have created different functions for each user type and are passing different creation forms as per type to the template.

Registering model for Admin panel

Now finally we will be registering our models to the admin panel

# authentication/admin.py
from django.contrib import admin
from .models import *

admin.site.register(User)
admin.site.register(Teacher)
admin.site.register(Student)

Conclusion

We have almost completed the backend of the authentication system. We created our User models, proxy models for different user types, URL routes, and views functions for registering users, logging users in and logging them out.

In the next part, we will create templates i.e. the front end of our authentication system.

Previous Part

Next Part

Follow, like, share, comment and support

We will be building a full-fledged school management system and deploying it to the web. We will be starting from scratch and gradually building up on the foundation of our Django knowledge. There will be a proper explanation for every code block that we write. Let us first list all functionalities that we will be having in our school management system. Managing

• Student records

• Teacher records

• Attendance records

• Subjects

• academic reports/performance

Prerequisites

• Text editor/ IDE (Pycharm or VS code or any other you like)

• Installed Python 3 interpreter

• Familiarity with Python 3

For creating templates

• HTML

• CSS

• Javascript

Setting up a virtual environment

Before starting with the project we need to create a virtual environment where all the modules and packages we need will be saved. The virtual environment is very useful for development it helps to avoid problems with package version compatibility.

Create a new folder and open it in your text editor

Open integrated terminal in it. For VS code you can press

CTRL + Shift + `

To create a virtual environment on Linux / Mac system enter the following command

# python3 -m venv <name of virtual environment>
python3 -m venv env

# Activating your newly created virtual environment
source env/bin/activate

After activating the virtual environment the terminal prompt will look something like this

Now we need to add some packages that we need to start our Django project. In the terminal type either of the following command.

# Adding Django to the virtual environment
pip3 install django
# or
pip install django

Starting a new Django project

To start a new Django project we will use django-admin CLI tool. Enter the following command to start a new Django project.

django-admin startproject core .

Pay attention to the trailing (.). This trailing " . " will start a new Django project in the current directory. If you omit the period in the end. It will create a new folder named core and then inside it will start a new project.

What do these files do?

• core/__init__.py

  This file makes the Python interpreter treat the directory as a python module.

• core/asgi.py and core/wsgi.py

  These files are used by the application server to communicate with the Django application.

• core/settings.py

  This file contains very important configurations of our Django application including secret key, static files settings, database configurations, and much more.

• core/urls.py

  This file contains the root URLs of your Django project. Here we define the path for various Django apps.

Try running the project

Start the development server using the following command

python manage.py runserver
# or
python3 manage.py runserver

Now open up the link in your browser

To stop the development server press CTRL + C

In the next part, we will be creating a new application that will handle the authentication and authorization of our Django project.

Next Part

Follow to get notified of upcoming parts of this project. Happy Learning!

In the process of learning Django, you surely will come across Django models. It is an important component of any Django application. Having good knowledge is essential to create an efficient web application using Django.

Django models define the fields and behavior of the data to be stored. Generally, a single model class defines a single table in the database. Models have fields that represent the columns of the table. We can also provide additional constraints to control what is stored.

How to define models

Django models are simply just classes that subclass django.db.models.Model. Each attribute of a model class is an instance of the appropriate Field class. The Field class determines the type of data stored, the minimum validation required and the widget which will be used while rendering the form field.

from django.db import models

class Manufacturer(models.Model):
  name = models.CharField(max_length=20)

  def __str__(self):
    return self.name


class Car(models.Model):
  model = models.CharField(max_length=20)
  year = models.PositiveIntegerField()
  manufacturer = models.ForeignKey(Manufacturer, on_delete=models.CASCADE)

In this code snippet, two models are declared namely Manufacturer and Car. The Manufacturer model has only one field which is name which can contain text of size at most 20 characters whereas the Car model has three fields, namely model that can contain text of size at most 20 characters, year field which can contain only positive integers and manufacturer field that references a Manufacturer in the Manufacturer table.

Various Fields for models

There are many different Field classes to store different types of data like integers, text, date, time and so on.

Here are some of the Field Classes

• CharField - stores string data

• IntegerField - stores integer

• PositiveIntegerField - stores only positive integer

• DataTimeField - stores date and time

• DateField - stores only date

• BooleanField - stores true/false value

• DecimalField - stores numbers with a decimal point

• EmailField - stores email

• FileField - for storing file

• TextField - for storing large text

• ImageField - for storing images, and many more...

All Field classes have some common optional arguments. Here are some of them:

• null - whether you want to allow storing null as a value, the default value is False

• blank - when set to True it allows the field to be blank

• choices - it allows you to have a value from a set of values. For using this option pass a list of 2-tuples to it with the first value of every tuple as the value you want to store and the second value as the display value that the user sees.

• default - use it to give a default value to the field

• primary_key - to use the field as a primary key for the model

• unique - to apply the unique constraint to the field

Defining Relationships

Relating different tables to each other is a powerful feature of RDBMS. Django provides ways to implement different relations like one-to-one, many-to-one and many-to-many.

One-to-One relationship

To form an OneToOne relationship we use models.OneToOneField

from django.db import models

class User(models.Model):
    name = models.CharField(max_length=30)
    age = models.PositiveIntegerField()

class Profile(models.Model):
    user = models.OneToOneField(User,on_delete=models.CASCADE)
    location = models.CharField(max_length=100)

Here we have defined a one-to-one relation between the user model and the profile model. Now in the database, we can store only a single Profile relating to a single user or vice versa.

Many-to-One relationship

To define a many-to-one relationship between two tables, we use models.ForeignKey(). It needs two parameters, first is the Model with which you want to create the relationship and the second is the on_delete positional argument to define the behavior of the model when the related record is deleted from the related table.

from django.db import models
class Author(models.Model):
    name = models.CharField(max_length=30)
    country = models.CharField(max_length=40)


class Book(models.Model):
    title = models.CharField(max_length=60)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)

Here in the above snippet, we have defined two Models viz. Author and Book. Many-to-One relation defined in Book will allow an Author to have multiple 'Books' but no 'Book' can have more than one Author.

Many-to-Many relationship

For creating Many-to-many relationship, we use models.ManyToManyField(). It takes in another model as an argument to form a relationship. While defining a many-to-many relationship, you don't need to define the relation in both models just define it in one model.

from django.db import models

class Student(models.Model):
    name = models.CharField(max_length=50)
    age = models.PositiveIntegerField()


class Course(models.Model):
    title = models.CharField(max_length=50)
    students = models.ManyToManyField(Student)

Now a student can have multiple courses and a course can have multiple students. For more in-depth information regarding ManyToManyField follow this link to the Django documentation

Conclusion

For developing a decent application using RDBMS, it is really important to have good knowledge of different types of relationships. Being good with RDBMS concepts will help you manage data efficiently. It is not much important what you are using but how you are using it. Keep learning keep building stuff.

In the next blog, we are going to see how to perform queries using the automatically-generated database-access API.

#Follow for more Django content

Django is one of the most popular backend frameworks out there in the market. It is written in python. It is known for its development speed. A project in Django can be up and running in a minimal amount of time. It has a very supportive community and many big websites use Django, here are some of them Mozilla, Instagram, Disqus, National Geographics, Pinterest and many more.

MVT Model

Django applications follow MVT architecture which stands for Model View Template. There are other architectures like MVC(Model View Controller) followed by other frameworks like Spring in Java. Below is the explanation of Each component of MVT architecture.

Models

Model refers to the database layer that stores, manipulate and retrieve data from the database. In Django, we define models by creating a class that subclasses django.db.models.Model and define fields we want to include in the database as class attributes with built-in Field classes.

# Example of Django model
from django.db import models

class Person(models.Model):
    name = models.CharField(max_length=50)
    age = models.PositiveIntegerField(default=0)
    occupation = models.CharField(max_length=50)

Views

View refers to the layer that contains all the business logic and this layer interacts with the Model for data and returns an HTML document. There are two types of views in Django functional views and class-based views though, both do the same task.

# Example Django View function
from django.shortcuts import render
def home(request):
    name = "fuzzydevs"
    context = {'name':name}
    return render(request, "home.html", context=context)

Templates

Templates are HTML files with placeholders for data. Django has its own templating language that resembles Jinja templating language. Django Template Language has many constructs like loops, conditional statements, inheritance, and so on. Templates are the presentation layer of the Django Applications.

URL paths

URL paths in Django are defined as a list of path functions that contains a URL string, a view function that handles the request, and an optional name for the path as arguments.

# Example of url path
from django.urls import path
urlpatterns = [
path('',views.home, name="home"),
path('form/',views.form_handler, name="form handler"),
]

Generally, paths of different Django apps in the project are defined in a file called urls.py in each app and are included in the main project urls.py file.

Flow of Application

The request is handled by the Django application and passed on to the appropriate View function as defined in the urlConf(where URLs are defined). The View function performs the business logic and interacts with Models as needed and passes the data and template to the Template engine which combines the data and template, spits out the HTML document with data in it. The final HTML document is returned from the view function as a response to the viewer.

Conclusion

This is a simplified explanation of how the Django applications work, and how it handles the request and returns a response for the corresponding request. I have also shown how we define models, views and URLs in a Django project. In the next blog, we will learn about Django models in-depth.

#Follow for more upcoming Django Content

When I was just exploring different domains of tech, I decided to get started with web development. Web development is one of the most in-demand skills in the Industry. So, I started a course on Udemy.

Foundation

From the course that I was doing, I learned HTML, CSS and javascript. I learned about different HTML tags like image, heading, paragraph, semantic tags and a lot more. In CSS I learned about different properties, pseudo-classes, units, flexbox, grid and mediaquery. I wasn't using Javascript much whenever I was creating webpages.

Improving the basics

To improve my HTML and CSS skills I started implementing designs that I found on the internet. It was challenging in beginning but as I kept pushing forward it started to feel easy. I would say to improve a skill you need to gradually increase the intensity, in this case, the complexity of design to implement.

A short break

I started to get bored with it and I started to learn some other stuff(ML and AI), it sounds cool, right? So for the next 6 months, I learned nothing about web development. Just tried different technologies like TensorFlow, flutter and so on. Then I realized that I should stick to one thing and try to absorb it completely.

Getting started with the backend

I felt like I should stick to web development and learn the backend. So I chose Spring framework in Java. As I started learning spring, I started to enjoy the learning process. For me working on the backend was exciting, but soon I realized that for building an MVP or for just building a simple website spring was not a good choice. In java, a ton of code has to be written. In the end, I switched from Spring to Django. I don't know if Django was too easy to learn or if I am a good learner but I finished the basics of Django in a week whereas for Spring it took me almost a month to reach the authentication part. Whatever the case may be, I created a Blog in it from scratch though I later learned that there are various projects which make it too easy to build blog applications in Django.

Similarly, I built some other projects to reinforce my learning and also extend it. Since then I have been sticking to Django. The deeper I am going into Django, the more I am loving it.

If you are interested in learning Django you can check out my Django-project Series

Conclusion

I started from the basics and improved by practicing and applying the knowledge I had gained. If I hadn't taken the 'short break', I might have gained more knowledge and experience. Building projects helped me a lot, trying different approaches is a great way to improve development skills. So try building different stuff to keep challenging yourself.

What do you think are different ways to test your newly acquired skill?

After my 12th Standard board exams, I decided that I would start coding, though few years earlier I learnt some basic Java, but that was all that I knew. The thing was, I was fascinated by the concept of programming computer. So I made up my mind to learn python which is one of the most popular language. Just at that time lockdown was declared. So, I had nothing else to do I went all in Python and finished the basics and OOPs in two weeks.

First mistake

I didn't make any project with whatever I had learnt. But soon I started project based learning and started applying my learnings. Thank god I realized it sooner.

Second Mistake

I didn't stick to a single technology and kept jumping from one tech to another. After the Python I started learning web development. I started learning HTML, CSS and Javascript. Learnt to build some basic webpages. Then I got bored and went into data science and machine learning stuff. Though most of the stuff went right above my head.

Third Mistake

I was learning all alone. When we learn alone we are not able to know the level of knowledge we have gathered. Since we have no competition/rival we tend to get lazy. I kept on learning alone but soon met some like minded people. It helped me a lot mentally. I started feeling motivated and confident.

Fourth Mistake

Getting into cool stuff without learning the basics. Whenever I started something new I jumped directly into the stuff which seemed cool and skipping basics slows down the learning process a lot.

Fifth Mistake

Not trying to learn a technology in-depth. We all tend to learn only the basics of a technology and when we feel it is getting complex and hard we chicken out. And this separates an expert from a normal person. Just get your hands dirty and try complex things.

Conclusion

Finally these were some of the mistakes which I made in the beginning. I had no one to guide me and help me out with this. So, the summary is

• Build Projects
• Stick to a single technology and learn it perfectly, partially learning is of no use.
• Find a group with same interest as you or having same goal
• Learn the basics before jumping into cool stuff
• Learn the technology in-depth, get comfortable with advance stuff

What do think are some other mistakes to avoid? Comment down.