DEV Community: Samarth Gupta

Ultimate Backend Roadmap 2022

Samarth Gupta — Sun, 21 Nov 2021 12:43:13 +0000

Hey There,

Are you a Java developer, or a Python developer, or maybe Golang developer?
Well, whoever you are, we all face the same set of problems in our backend, just our language of choice is different in solving those problems. But one may think how to grow, not just in particular technology but as an engineer in a whole. So I present the Backend Skillset Roadmap

This roadmap is language agnostic and could be thought of as a checklist instead of a roadmap. You don't need to learn things serially, one can progress through each parallelly.

P.S: Don't be Jack of all and Master of none.

Java Backend Roadmap

Samarth Gupta — Wed, 20 Oct 2021 04:17:15 +0000

Hi You all,

I created a perfect Java Roadmap for Backend Engineering.

Download Roadmap

Also check my Spring Learning Path to learn Spring.
Follow Me Here

Golang for Experienced Developers - Part III

Samarth Gupta — Sun, 03 Oct 2021 15:14:54 +0000

Hi, I'm back

This is the third part of Golang tutorial series, if you haven't checked out the first & second parts, do check it out here.

Control Constructs in Go

Go provides following statements for controlling the program flow:

If statement

Syntax:

// Regular if
if condition {
    ...
}

// Initialised if
if initialisation; condition {
    ...
}

// if-else
if condition {
    ...
} else {
    ...
}

if condition1 {
    ...
} else if condition2 {
    ...
} else {
    ...
}

Points to remember:

Go provides two syntaxes for if statements, one with initialisation & one without initialisation.
Braces are mandatory, even for one line.
The { (opening brace) after the if and else must be on the same line.
The else if and else must be on same line as } (closing brace).
Can use parentheses for composite expressions with &&, ||, !
The ; after initialisation is required.
Use local assignments (:=) for initialisation in initialised if statements.
Scope of initialisation variable is known only within if statement.
Can also invoke functions to initialise variable in the initialised if statements.

Example:

package main
import ("fmt"; "runtime")

func main() {
    if platform := runtime.GOOS; platform == "linux" { // fetch os info 
      fmt.Println("linux platform")
    } else if platform  == "darwin" {
      fmt.Println("darwin platform")
    } else {
      fmt.Println("windows platform")
    }
}

Switch Statement

Syntax:

// Regular switch
switch variable {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

// Initialised switch 
switch initialisation; variable {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

// Tag-less switch
switch {
    case boolexpr1:
        ...
    case boolexp2:
        ...
    default:
        ...
}

Points to remember:

Go provides three syntaxes for switch statement.
The { (opening brace) must be on the same line as the switch
variable can be any type.
val1, val2 must be of the same type.
More than one value may appear in a case.
Breaks from each case are implicit.
Use keyword fallthrough to combine case conditions.
Braces ({ and }) are allowed in case for multiple statements.
Use keyword default to handle conditions that match no case
Keyword default may be placed anywhere in switch.
In tag-less switch statements, case statements must evaluate to boolean expressions.

Example:

package main
import ("fmt"; "runtime", "os")

func main() {
    switch platform := runtime.GOOS; platform {
        case "linux", "darwin", "windows":   // multiple cases
            fmt.Println("Known OS")
        default:
            fmt.Println("Unknown OS")
     }

    arg := os.Args[1]  // fetch command line argument
    num, _ := strconv.ParseFloat(arg, 64) // string to float64
    var val float64
    switch {
         case num < 0:
             num = -num
             fallthrough   // fallthrough to second case
         case num > 0:
             val = math.Sqrt(num)
         case num == 0:
             val = 0;
    }
    fmt.Println(val)    
}

For statement

Syntax:

// Counter controlled loop
for initialisation; condition; update {
    ...
}

// Condition controlled loop
for condition {
    ...
}

// Range controlled loop
for index, value := range collection {
    ... 
}
for index := range collection {
    ...
}

Points to remember:

Go provides three syntaxes for for statement.
No while or do while statements.
Braces are mandatory, even for one line.
Opening brace { must be on the same line as for
Surrounding parenthesis after for are not allowed.
May assign more than one counter in initialise with commas
Omitting condition in a condition controlled loop results in an infinite loop.
In range controlled loops, collection is a sequence of items (string, array, map).
index is the integer index at each iteration in the loop.
value is the item in the collection at each iteration in the loop.

Example:

package "main"
import "fmt"
import "os"

func main() {
    nargs := len(os.Args)
    // counter controlled
    for i := 1; i < nargs; i++ {
        fmt.Printf("%s ", os.Args[i])
    }

    args1 := os.Args[1:]
    // condition controlled
    for len(args) > 0 {
        fmt.Printf("%s ", args1[0])
        args1 = args1[1:]  // shift left
    }

    args2 := os.Args[1:]
    // range controlled
    for i, arg := range args {
        fmt.Printf("%d %s\n", i, arg)
    }
}

Break & Continue Statement

Break:

Used inside a for, switch, or select statement.
Breaks out of innermost loop in multiple for statements.
Can be used with labels.

Continue:

Can only be used in for statement.
Continues with the next iteration of innermost loop.
Skips remaining body of loop.
Can be used with labels.

Example:

package main
import "fmt"
func main() {
    for i := 1; i < 25; i++ {
        if i % 2 != 0 { continue }
        if i > 20 { break }
        fmt.Printf("%d ", i)
    }
}

This concludes the third part of the series. In next tutorial we'll cover functions and more, till then, Aloha.

Reach out to me here

Golang for Experienced Developers - Part II

Samarth Gupta — Tue, 21 Sep 2021 16:18:23 +0000

Welcome,

This is the second part of Golang tutorial series, if you haven't checked out the first part, do check it out here.

Let's continue where we left off...

Primitive Data Types in Go

Syntax:

var variableName type = value

Following are the types of Primitive Data Types in Go:

Boolean

A bool type represents the set of Boolean truth values denoted by the predeclared constants true or false.
Supported operators are &&, || and !
Use %t to print booleans.

Example:

var flag bool = !(10 > 0 && 20 < 40)
fmt.Printf("%t\n", flag)  // false

Numeric

A numeric type represents sets of integer or floating-point values.
Architecture dependent types determine their size based on the architecture. Architecture independent types have fixed size.
There is no float type, only float32 or float64
Precision of float32 is 7 decimal places.
Precision of float64 is 15 decimal places.
There is no implicit type conversion between any data types. i.e. int16 can't be assigned to int32, to overcome this one must do explicit type conversion.

Architecture Dependent Types:

uint     either 32 or 64 bits
int      same size as uint
uintptr  an unsigned integer large enough to store the uninterpreted bits of a pointer value

Architecture Independent Types:

uint8       the set of all unsigned  8-bit integers (0 to 255)
uint16      the set of all unsigned 16-bit integers (0 to 65535)
uint32      the set of all unsigned 32-bit integers (0 to 4294967295)
uint64      the set of all unsigned 64-bit integers (0 to 18446744073709551615)

int8        the set of all signed  8-bit integers (-128 to 127)
int16       the set of all signed 16-bit integers (-32768 to 32767)
int32       the set of all signed 32-bit integers (-2147483648 to 2147483647)
int64       the set of all signed 64-bit integers (-9223372036854775808 to 9223372036854775807)

float32     the set of all IEEE-754 32-bit floating-point numbers
float64     the set of all IEEE-754 64-bit floating-point numbers

Explicit Type Conversion:

var val1 int16 = 32
var val2 int32 = int32(val1)   // explicit conversion

Complex Number

Go provides a two new data type to store complex numbers which are architecture independent.
Complex arithmetic is supported.
Use complex(real, imaginary) function to create complex numbers & real() & imag() function to extract real & imaginary part.
Use %v to print complex numbers.

complex64   the set of all complex numbers with float32 real and imaginary parts
complex128  the set of all complex numbers with float64 real and imaginary parts

Example:

var cp1 = complex(1.2, 2.1)
var cp2 = complex(3.4, 5.8)
fmt.Println(real(cp1), imag(cp2))  // 1.2  5.8
fmt.Printf("%v\n", cp1 + cp2)     // (4.6 + 7.9i)

Character

It's a special case of integer type.
Use \u(4 hex digit) or \U(8 hex digits) for unicode
User %c or %U for printing.

byte        alias for uint8, for storing ASCII characters
rune        alias for int32, for storing UTF-8 characters

Example:

var char1 byte = 65           // ASCII 'A'
var char2 byte = '\x41'       // ASCII 'A'
var char3 rune = '\u0041'     // Unicode 'A'
var char4 rune = '\U00101234' // Unicode
fmt.Printf("%c %U\n", char1, char4)   // A U+1012334

Pointer

Pointers are variables that store memory address.
This is exactly similar to C++ except pointer arithmetic isn't supported in Go.
Pointer variables are stored in heap and are garbage collected.
AddressOf(&) and dereference(*) operators act same as C++.
Use %p to print pointers.

Syntax:

var identifier *type = address

Example:

var num int = 6
var ptr *int = &num
fmt.Printf("%p\n", ptr)    // address of num

*ptr = 20                  // changes num to 20
fmt.Println(num)           // 20

ptr++                      // illegal, pointer arithmetic not supported
const val = 10
ptr = &val                 // illegal, why?

See this for why.

String

string are immutable in Go for the same reason why it's immutable in Java.
Strings are not null terminated like C/C++.
Indexing & slicing is allowed.
Use len(str) for string length.
Can't take address of string character (&str[i] illegal)
Comparison operators compare bytes.
Strings are initialised with double quotes or back-ticks.
Defaults to empty string ("")

Example:

var str string = "Let's Go"
fmt.Println(len(str))       // 8
var str2 string = "C:\newfolder\text.txt"
fmt.Println(str2)     // C:
                      // ewfolder    ext.txt, bcoz escape sequence

var str3 string = `C:\newfolder\text.txt`   // raw string
fmt.Pritln(str3)     // C:\newfolder\text.txt

Concatenation & Update:

var a = "Hello "
var b = "world"
var c = a + b      // Hello world, concatenation
a += b          // Hello world, update but create new object bcoz immutability

Indexing:

var str = "hello"
fmt.Printf("%c\n", str[0]) // h
str[0] = 'j'             // illegal

Slicing:

var str = "hello"
fmt.Println(str[1:4])   // ell, index 1-3
fmt.Println(str[:4])    // hell, index 0-3
fmt.Println(str[1:])    // ello, index 1-end
fmt.Println(str[:])     // hello, index 0-end

fmt.Println(str[-1])    // illegal, but legal in Python
fmt.Println(str[:-1])   // illegal, but legal in Python

String Conversions & Functions

There are two packages available for string conversions and string functions in Go.

For string conversion:

import "strconv"

Example:

package "main"
import "strconv"
import "fmt"

func main() {
    // string to numeric
    num, _ := strconv.Atoi("1234")
    fmt.Println(num)    // 1234 - int
    fval, _ := strconv.ParseFloat("3.46", 64)  // (str, floatSize)
    fmt.Println(fval)   // 3.46 - float64
    num2, _ := strconv.ParseInt("123", 10, 64) // (str, base, intSize)
    fmt.Println(num2)   // 123 - int64

    // numeric to string
    str1 := strconv.Itoa(789)
    fmt.Println(str1)    // 789 - string
    str2 := strconv.FormatFloat(3.45, 'f', -1, 32)
    fmt.Println(str2)    // 3.45 - string
    str3 := strconv.FormatInt(1234, 10)
    fmt.Println(str3)    // 1234 - string
}

For string functions:

import "strings"

Useful Functions:

func Contains(s, substr string) bool
func Count(s, sep string) int
func HasPrefix(s, prefix string) bool
func HasSuffix(s, suffix string) bool
func Index(s, sep string) int
func Join(a []string, sep string) string
func LastIndex(s, sep string) int
func Repeat(s string, count int) string
func Replace(s, old, new string, n int) string
func Split(s, sep string) []string
func ToLower(s string) string
func ToUpper(s string) string
func Trim(s string, cutset string) string

With this, concludes the second part of this tutorial. Next up we have control constructs in Golang. Coming soon...

Spring Learning Path

Samarth Gupta — Tue, 21 Sep 2021 02:08:57 +0000

Java is a confusing world.

As a newcomer to Java, have these questions ever popped up in your mind?

What is J2SE?
Okay, I understand J2SE but what is J2EE?
What is JSF now?
What is JNDI and what is JNI?
What is EJBs now?
What is JMS?
What is JSR?
What's JPA?
and more...

If these questions does boggle your mind sometimes(well, it certainly did to me), you're in the right place. Today I am going to oversimplify Spring learning path for you. This will clarify how Java progressed through time and how Spring came as a de-facto standard in industry. This will also clarify what should you learn in Java world, certainly you can't learn it all. JAVA IS HUGE.

I will be going through pointers to explain it easily:

J2SE

Core Java + Concurrency API + Collection API = Java Standard Edition (J2SE)

J2EE

Then comes Java Enterprise Edition (J2EE) which has a set of enterprise features used to develop full-fledged enterprise java applications.
Servlet, JSP, JSF, EJB, JMS, JNDI, JDBC, JavaMail, JTS, JTA, JCA, these all are enterprise features and comes under J2EE.
J2EE is just some abstract and standardised specifications (APIs) and their implementation is provided by the respective Application Server. Examples of Application Servers are Glassfish, JBoss, Liberty, WebSphere, etc.
These abstract specifications are defined using JSR (Java Specification Request) and are implemented by Reference Implementation, for eg. JPA is a JSR and Hibernate is a Reference implementation i.e. JPA defines all annotations and methods signatures & a reference implementation implements underlying code for it. Think interface & class.

Web Server vs Application Server vs Web Container

Web servers just serve static content, Application servers provide dynamic content with other functionality like managing EJB pool, facilitating distributed transaction, facilitating application lookup over JNDI, application security, and others. Web containers are just Servlet containers that are only responsible for generating HTML by executing JSP and Servlet on the server-side.

Spring is here

Spring is another alternative to J2EE for creating Enterprise applications in Java.
Spring is a framework doing lots of the stuff on the J2EE specifications, but in its own form. They don't follow J2EE specifications and APIs for that. But they do include a web framework, transaction management, security, and several other solutions that J2EE offers.

Spring Learning Plan

So start with Spring Core which is relevant to CDI in J2EE. This will teach you dependency injection & inversion of control.
Then move on to Spring-Web/MVC which is equivalent to Servlet/JSPs in J2EE but with more features & support.
Then move on to several Spring Modules which provides different functionality of J2EE.

Important Spring Modules:

Spring-AOP: Provides cross cutting concerns
Spring-JDBC: Provides JdbcTemplate which removes boilerplate code from JDBC
Spring-ORM: Provides HibernateTemplate which does the same in ORM world
Spring-JMS: Provides messaging.

After you're done with this and know how spring works, it's time to start learning Springboot, Springboot is opinionated framework and does most of the configuration for you.

That's it, this is the oversimplification of Spring Learning Path. If you're a curious Spring learner, I have a new tutorial series coming up to learn spring from scratch. Follow to know more. Comment in case you've any doubts.

Golang for Experienced Developers

Samarth Gupta — Mon, 20 Sep 2021 15:39:41 +0000

Hello World,

Today I am going to start a Golang tutorial series. I am an experienced Java Developer however my job required me to learn Golang so I will be documenting my learning journey in a structured format. In this series, we'll go from absolute basics to somewhat intermediate in Golang. This is the first place you should start if you have just heard of the name "Golang" but never got a chance to learn it.

Go: Pros & Cons

Suppose C++, Java & Python had a child, they named it Go and so it inherits features from each one of these languages. Here are some of them:

C-like Syntax, therefore Concise & Clean
Garbage Collection, therefore Memory Safety
Package Model, therefore Faster Builds
Statically Typed, therefore Type Safety
Free & Open Source, therefore More Support

Here is What Go Lacks?

No overloading of functions & operators
No classes & inheritance
No exception handling
No support for pointer arithmetic

After reading these counter statements you might be wondering why would someone go with Go(pun intended), check this & this out and you will know why.

Let's "Go" to First Program

package main
import "fmt"

func main() {
    fmt.Println("Hello World!");
}

Points to remember:

main is the first function that gets executed, similar to any other programming language.
fmt is a format library in-built in Go, it's used for formatted printing & more.
import statement is used to import external libraries in Go, like Java.
package is used for modularisation of Go programs, like Java.

Go Run & Go Build

Now it's time to build & run the program we just wrote, for this purpose we need to make sure we have Go installed in our system, you can refer this to install Go in your system.

Building Go Programs

$ go build main.go

This command will build your Go program into system native executable named same as your program file name (main.go), you can run the executable directly by calling the executable (main).

$ go build -ldflags "-s -w" main.go

The ldflags stand for linker flags, it passes flags to underlying Go toolchain linker. The flags -s & -w will disable creation of symbol tables for the compiler and hence reduce down the size of the executable.

Running Go Programs

$ go run main.go

This command will first build your Go program in system temp location & run it to show the output, once the run is completed, the build is discarded. In other words, this will simply run your Go program.

How Does Go Work?

Go programs doesn't require a VM to run like how Java runs on JVM, Go compiles the program into native executables that are specific to the system therefore Go doesn't support platform independence. However the load falls on the developer to build executables for Windows, Linux & Darwin systems.

Basics

Any Go program consists of:

Keywords
Identifiers
Data Types
Constants
Variables
Operators
Functions

Keywords

The following keywords are reserved and may not be used as identifiers.

break        default      func         interface    select
case         defer        go           map          struct
chan         else         goto         package      switch
const        fallthrough  if           range        type
continue     for          import       return       var

Identifiers

Identifiers name program entities such as variables and types.

An identifier is a sequence of one or more letters and digits.
The first character in an identifier must be a letter.

Some identifiers are predeclared.

Predeclared Identifiers:

Types:
       bool byte complex64 complex128 error float32 
       float64 int int8 int16 int32 int64 rune 
       string uint uint8 uint16 uint32 uint64 uintptr

Constants:
       true false iota

Zero value:
       nil _

Functions:
       append cap close complex copy delete imag len
       make new panic print println real recover

Data Types

Primitives: 
           int, complex, float, bool, string
Structured:
           struct, array, slice, map, channel

NOTE: We'll cover each data type in further tutorials.

Constants

The syntax to define a constant in Go is as follows:

const identifier type = value

Points to remember:

Constants must be evaluated at compile time.
The type is optional as compiler will guess the type based on value at compile time.
Applies only to primitive data types.
Can be enumerated with iota identifier.

Examples:

const c1 = "this is a constant string." // type is optional

const c2 float32 = 5/6. // period(.) at the end tells compiler to do float arithmetic instead of integer arithmetic.

const billion = 1e9 // possible

const funcValue = funcThatReturnValue()   // compile time error, why? 

const(one, two = 1, 2) // can combine various constant initialisation into once

const (           // using iota for enumeration
    zero = iota   // 0
    one           // 1
    two           // 3
    three         // 4
)

Variables

The syntax to define a variable in Go is as follows:

var identifier type = value

Points to remember:

If value is not supplied, type is required.
If type is not supplied, value is required.
Variables are always initialised to default values (0 or nil).
Variables declared inside functions have local scope.
Variables declared outside functions have global scope(package scope).

Examples:

var variable1 int   // syntactically ok

var variable2       // missing value & type, compile time error

var value = 3.48    // ok, defaults to float64 type

var isSet bool = false  // ok

var (                  // can combine various variable declaration into once
    radius int
    isSet bool
    name string
)

Operators:

Following is the list of operators & delimiters in Go:

-    |    +    &    *    ^    /    <<    /=    <<=    ++    =
%    >>    %=    >>=    --    !    &^    &^=    +=    &=    -= |=    *=    ^=    &&    ==    !=    (    )    ||    <    <-   
>    <=    [    ]    >=    {    }    :=    ,    ;  ...    .  :

Operator Precedence:

Precedence    Operator
    5             *  /  %  <<  >>  &  &^
    4             +  -  |  ^
    3             ==  !=  <  <=  >  >=
    2             &&
    1             ||

Local Assignment Operator( := ):

The syntax for local assignment operator is as follows:

identifier := value

Points to remember:

The local assignment operator ( := ) creates new variables and assign value.
It doesn't need type details as the compiler does guess it for you.
Local assignment operator must be used inside functions.

Example:

func main() {
    value := 50.5
    isSet := false
    x, y, z := 3, 56.5, "hello"   // x = 3, y = 56.5, z = "hello"
}

This concludes the first part of this tutorial series. Check out the second part here where I talked about all primitive data types and string handling.