DEV Community: Kuldeep Singh

How to Write Python Code in a Pythonic Way

Kuldeep Singh — Fri, 18 Aug 2023 06:25:27 +0000

Python is one of the most popular and powerful programming languages. It's widely used for various purposes such as web development, data analysis, machine learning, automation, etc. It is also known for its simplicity, readability, and expressiveness.

However, writing Python code is not just about following the syntax and semantics of the language. It is also about following the style and culture of the Python community. This is what we call writing Python code in a Pythonic way.

Writing Python code in a Pythonic way means following the best practices and idioms of the Python language that make your code more readable, elegant, and efficient. It also means taking advantage of the features and options that Python offers to make your code more concise and expressive.

In this blog post, I will share with you some tips and examples on how to write Python code in a Pythonic way, based on the official Style Guide for Python Code and some online resources. Let’s get started!

General Writing Style

One of the first things to consider when writing Python code is the general writing style. This includes how to format your code, how to name your variables and functions, how to use whitespace and indentation, how to write comments and docstrings, etc.

Use 4 spaces per indentation level.

# Bad practice
def foo():
  print("Hello")
    print("World")

# Good practice
def foo():
    print("Hello")
    print("World")

Limit all lines to a maximum of 79 characters.

# Bad practice
print("This is a very long line of code that exceeds the recommended limit of 79 characters")

# Good practice
print("This is a very long line of code that "
      "exceeds the recommended limit of 79 characters")

Use blank lines to separate functions and classes, and larger blocks of code inside functions.

# Bad practice
def add(x, y):
    return x + y
def subtract(x, y):
    return x - y
def multiply(x, y):
    return x * y
def divide(x, y):
    return x / y

# Good practice
def add(x, y):
    return x + y


def subtract(x, y):
    return x - y


def multiply(x, y):
    return x * y


def divide(x, y):
    return x / y

Use lowercase letters for variables and functions, and uppercase letters for constants. Use underscores to separate words in names.

# Bad practice
MyVariable = 10 # variable name should be lowercase
myFunction() # function name should be lowercase
my constant = 20 # constant name should be uppercase

# Good practice
my_variable = 10 # variable name is lowercase
my_function() # function name is lowercase
MY_CONSTANT = 20 # constant name is uppercase

Use descriptive names for variables and functions that reflect their purpose and meaning. Avoid using single letters or ambiguous names.

# Bad practice
x = 10 # what does x represent?
f() # what does f do?
n = 20 # what does n represent?

# Good practice
length = 10 # length is descriptive
area(length, width) # area is descriptive
is_prime(number) # is_prime is descriptive

Use docstrings to document your functions and classes.

def area(length, width):
    """Return the area of a rectangle.

    Parameters:
    length (float): The length of the rectangle.
    width (float): The width of the rectangle.

    Returns:
    float: The area of the rectangle.
    """
    return length * width

help(area) # displays the docstring
area.__doc__ # returns the docstring

Use comments to explain your code when necessary.

# Bad practice
x = 10 # assign 10 to x
y = x + 5 # add 5 to x and assign to y
print(y) # print y

# Good practice
x = 10 # initial value
y = x + 5 # increment by 5
print(y) # display result

By following these general writing style guidelines, you will make your code more consistent, clear, and easy to read.

Using Variable Tricks

Python offers many options that allow you to write simple and expressive commands containing variable assignment operations. Here are some of the tricks you can use to make your code more Pythonic:

Swap two variables without using a temporary variable.

# Bad practice
temp = x
x = y
y = temp

# Good practice
x, y = y, x

Assign multiple variables in one line.

# Bad practice
x = 1
y = 2
z = 3

# Good practice
x, y, z = 1, 2, 3

Unpack a sequence into multiple variables.

# Bad practice
my_list = [1, 2, 3]
x = my_list[0]
y = my_list[1]
z = my_list[2]

# Good practice
my_list = [1, 2, 3]
x, y, z = my_list

Use the asterisk (*) operator to collect or unpack variable numbers of arguments.

# Bad practice
def add(a, b):
    return a + b

def add_many(*args):
    result = 0
    for arg in args:
        result += arg
    return result

# Good practice
def add(*args):
    return sum(args)

add(1, 2) # returns 3
add(1, 2, 3) # returns 6
add(1, 2, 3, 4) # returns 10

By using these variable tricks, you will make your code more concise and expressive.

Dealing With Lists

Lists are one of the most common and versatile data structures in Python. They can store any type of objects and support various operations such as indexing, slicing, appending, extending, inserting, removing, sorting, reversing, etc. Here are some of the tips and tricks you can use to deal with lists in a Pythonic way:

Use list comprehensions to create new lists from existing iterables.

# Bad practice
squares = []
for x in range(10):
    squares.append(x**2)

# Good practice
squares = [x**2 for x in range(10)]

Use the in operator to check if an element is in a list.

# Bad practice
found = False
for x in my_list:
    if x == target:
        found = True
        break

# Good practice
found = target in my_list

Use the enumerate function to loop over a list with indexes.

# Bad practice
index = 0
for x in my_list:
    print(index, x)
    index += 1

# Good practice
for index, x in enumerate(my_list):
    print(index, x)

Use the zip function to loop over multiple lists in parallel.

# Bad practice
for i in range(len(names)):
    print(names[i], ages[i])

# Good practice
for name, age in zip(names, ages):
    print(name, age)

By using these tips and tricks, you will make your code more efficient and elegant when dealing with lists.

Having Fun With Functions

Functions are one of the most important and powerful features of Python. They allow you to group and reuse code, improve readability and modularity, and implement abstraction and encapsulation. Here are some of the ways you can have fun with functions and make your code more Pythonic:

Use default arguments to provide optional parameters to your functions.

# Bad practice
def greet(name):
    if name:
        print(f"Hello, {name}!")
    else:
        print("Hello, world!")

# Good practice
def greet(name="world"):
    print(f"Hello, {name}!")

Use keyword arguments to provide named parameters to your functions.

# Bad practice
def area(length, width):
    return length * width

area(10, 5) # returns 50

# Good practice
def area(length, width):
    return length * width

area(width=5, length=10) # returns 50

Use lambda functions to create anonymous functions.

# Bad practice
def square(x):
    return x**2

my_list = [1, 2, 3]
squares = map(square, my_list)

# Good practice
my_list = [1, 2, 3]
squares = map(lambda x: x**2, my_list)

Use decorators to modify or enhance the behavior of your functions.

# Bad practice
def hello():
    print("Hello")

def log(func):
    def wrapper():
        print(f"Calling {func.__name__}")
        func()
        print(f"Done calling {func.__name__}")
    return wrapper

hello = log(hello)
hello()

# Good practice
def log(func):
    def wrapper():
        print(f"Calling {func.__name__}")
        func()
        print(f"Done calling {func.__name__}")
    return wrapper

@log
def hello():
    print("Hello")

hello()

By using these ways, you will make your code more fun and flexible when using functions.

Follow the Zen of Python

The Zen of Python is a collection of 19 principles that guide the design of the Python language. They are written by Tim Peters, one of the core developers of Python, and can be accessed by typing import this in the Python interpreter. Here are some of the most important ones for writing Pythonic code:

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
There should be one-- and preferably only one --obvious way to do it.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.

By following these principles, you will make your code more beautiful and Pythonic.

I'll be updating this story weekly basis with the best Pythonic way to write Python code so don't forget to save it.

You can find me on Twitter, LinkedIn, and Website

PyPI Repository Under Attack: New Users and Package Uploads Temporarily Stopped

Kuldeep Singh — Mon, 22 May 2023 15:52:41 +0000

Python developers, both seasoned and newcomers, may have recently encountered an unexpected obstacle. The maintainers of the Python Package Index (PyPI), the official third-party software repository for Python, have temporarily suspended the ability for users to register and upload new packages. This decision comes in the wake of an uptick in malicious activity on the platform, threatening the security and integrity of the Python ecosystem.

The Security Incident

Over the past week, the PyPI administrators noted a surge in the creation of malicious projects and users. This increase proved overwhelming for the team, especially with several PyPI administrators on leave. In response, they made the decision to put a pause on new user registrations and project uploads.

Unfortunately, the nature of the malware and the threat actors involved in publishing these rogue packages to PyPI remains undisclosed. This lack of detail leaves room for speculation and uncertainty within the Python community. However, the incident has once again highlighted the susceptibility of software registries like PyPI to potential security threats.

Software Repositories: A Target for Attackers

Software repositories, such as PyPI, have become an attractive target for malicious actors. By poisoning the software supply chain, they can infiltrate developer environments, spreading malware and causing havoc. The recent events on PyPI serve as a reminder of this ongoing threat.

In a related incident, Israeli cybersecurity startup Phylum discovered an active malware campaign. This campaign cleverly used lures themed around OpenAI's ChatGPT to trick developers into downloading a malicious Python module. The module is capable of stealing clipboard content, potentially hijacking cryptocurrency transactions.

Simultaneously, ReversingLabs identified multiple npm packages containing a trojan called TurkoRat. The packages, named nodejs-encrypt-agent and nodejs-cookie-proxy-agent, were found in the npm repository, another popular software registry.

Conclusion

The recent security threats on PyPI demonstrate the importance of constant vigilance in the developer community. As software registries continue to be targeted, it is critical for developers to ensure the security of their code by using trusted packages and employing best practices in their programming.

For now, the Python community awaits further updates from the PyPI administrators, hoping for a swift resolution and the reinstatement of new user registrations and project uploads. In the meantime, we must continue to learn from these incidents and work together to safeguard our shared resources.

Originally published at Programming Geeks Club.

If you’re interested in learning more about programming, cyber security and related topics, we invite you to check out our website programmingeeksclub.com. We offer valuable resources and insights.

You can find us on Twitter and Facebook.

Download my first ebook about mastering markdown, from here: Download , reviews and recommendations are appreciated.

Golang Concurrency Model Explained

Kuldeep Singh — Wed, 17 May 2023 07:57:28 +0000

Understanding Concurrency

Concurrency refers to the execution of tasks independently over the same period, allowing systems to make progress on multiple tasks simultaneously. It doesn't necessarily mean tasks are executed at the same time, but they start, run, and complete within overlapping time periods.

Importance of Concurrency

Concurrency provides a way to structure a solution to solve complex tasks that can run independently. It's beneficial when different tasks do not need to share computational resources and can help increase efficiency, especially in multicore and distributed systems.

Concurrency Vs. Parallelism

Concurrency and parallelism, though often used interchangeably, are not identical. Concurrency is about dealing with multiple tasks at once (not necessarily simultaneously), while parallelism involves executing multiple tasks at the same time.


// Concurrent execution
func main() {
    go fmt.Println("Hello from another task") // starts a new goroutine
    fmt.Println("Hello from main task")
}

// Parallel execution - requires a multi-core processor
func main() {
    runtime.GOMAXPROCS(2) // set maximum number of CPUs that can be executing simultaneously
    go fmt.Println("Hello from another task")
    fmt.Println("Hello from main task")
}

Introduction to Golang

Go, or Golang, is a statically-typed, compiled language developed at Google, known for its simplicity, efficiency, and strong support for concurrent programming patterns.

Why Golang for Concurrency?

Golang makes it easy to write concurrent programs, thanks to features like goroutines and channels.

Key Features of Golang

Golang has several features that make it a good choice for concurrent programming: goroutines, channels, and the select statement.

Golang Concurrency Model

Go's concurrency model, often referred to as Communicating Sequential Processes (CSP), is centered around goroutines and channels.

Goroutines

Goroutines are functions or methods that run concurrently with other functions or methods. They're lightweight threads managed by the Go runtime.

How Goroutines Work?

Use the go keyword before a function call to start a goroutine.

package main

import (
    "fmt"
)

func printFrom(another string) {
    for i := 0; i < 5; i++ {
        fmt.Println(another, ":", i)
    }
}

func main() {
    go printFrom("goroutine") // start a new goroutine
    printFrom("main")
}

Channels in Golang

Channels are the pipes that connect concurrent goroutines. You can send values into channels from one goroutine and receive those values into another goroutine.

Unbuffered vs Buffered Channels

Unbuffered channels block senders until receivers are ready, and vice versa. Buffered channels have a queue of elements and do not block until the queue is full.

// Unbuffered Channel
ch := make(chan int) // creates an unbuffered channel

// Buffered Channel
ch := make(chan int, 2) // creates a buffered channel with capacity for 2 integers

Select Statement

The select statement is used to choose from multiple send/receive channel operations. It blocks until one of its cases can run, then it executes that case.

Use Case of Select Statement

package main

import (
    "fmt"
)

func fibonacci(c, quit chan int) {
    x, y := 0, 1
    for {
        select {
        case c <- x:
            x, y = y, x+y
        case <-quit:
            fmt.Println("quit")
            return
        }
    }
}

func main() {
    c := make(chan int)
    quit := make(chan int)
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println(<-c)
        }
        quit <- 0
    }()
    fibonacci(c, quit)
}

Real World Applications of Golang Concurrency

Golang's concurrency model is used in many real-world applications. For example, it's used in Docker for containerization and Kubernetes for container orchestration, and by companies like Uber for handling high volumes of network requests.

Case Studies

Docker: Docker uses Golang due to its strong support for concurrent process handling, which is essential for containerization.
Kubernetes: Kubernetes, an open-source system for automating deployment, scaling, and management of containerized applications, is also written in Go.

Conclusion

Golang provides powerful primitives to deal with concurrent programming. Its simple and efficient concurrency model, based on goroutines, channels, and the select statement, makes it an ideal choice for developers working with concurrent processes.

If you’re interested in learning more about programming and related topics, we invite you to check out our website programmingeeksclub.com. We offer valuable resources and insights.

You can find us on Twitter and Facebook.

Download my first ebook about mastering markdown, from here: Download , reviews and recommendations are appreciated.

Learn Golang By Building A 2D Snake Game: A Complete Guide

Kuldeep Singh — Wed, 03 May 2023 10:52:23 +0000

Learning a new programming language can be a daunting task, but working on a fun project like building a game can make the process enjoyable and effective. In this tutorial, we will learn Golang by creating a simple snake game. Golang, or Go, is an open-source programming language designed by Google that makes it easy to build simple, reliable, and efficient software.

By the end of this tutorial, you will have a basic understanding of Go and its core concepts, such as variables, functions, loops, and structs, as well as a working snake game to show off your new skills.

Setting Up Your Go Environment

Before you start building the game, You need to set up your Go environment. You can download Go from the official website at https://golang.org/dl/. Once Go installed, Make sure to set up your GOPATH and configure your environment variables correctly.

Introduction to Ebiten

For building a 2d game we are going to use Ebiten package. Ebiten is a 2D game library for Go that makes it easy to develop cross-platform games. Ebiten provides essential game features, Such as drawing images and handling user input. To get started with Ebiten, Install the library by running the following command:

go get -u github.com/hajimehoshi/ebiten/v2

Setting Up the Game Environment

Begin by creating a new Go file and importing the required packages, such as fmt , log , math/rand , time , and github.com/hajimehoshi/ebiten/v2. Next, create constants for the screen width and height, and tile size.

const (
    screenWidth  = 320
    screenHeight = 240
    tileSize     = 5
)

The main function should initialize the game state and call ebiten.RunGame() to start the game loop.

func main() {
    rand.Seed(time.Now().UnixNano())
    game := &Game{
        snake:    NewSnake(),
        food:     NewFood(),
        gameOver: false,
        ticks:    0,
        speed:    10,
    }
    ebiten.SetWindowSize(screenWidth*2, screenHeight*2)
    ebiten.SetWindowTitle("Snake Game")
    if err := ebiten.RunGame(game); err != nil {
        log.Fatal(err)
    }
}

This code sets up a basic Ebiten game window with a size of 640×480 pixels.

Creating the Snake Structure

Create a Point struct to represent x and y coordinates, and a Snake struct to represent the snake's body, direction, and growth counter.

type Point struct {
    X int
    Y int
}

type Snake struct {
    Body        []Point
    Direction   Point
    GrowCounter int
}

Now implement a NewSnake() function to create a new snake instance and a Move() method to update the snake's position based on its direction. The Move() method should also handle the snake's growth by keeping or removing the tail segment based on the GrowCounter.

func NewSnake() *Snake {
    return &Snake{
        Body: []Point{
            {X: screenWidth / tileSize / 2, Y: screenHeight / tileSize / 2},
        },
        Direction: Point{X: 1, Y: 0},
    }
}

func (s *Snake) Move() {
    newHead := Point{
        X: s.Body[0].X + s.Direction.X,
        Y: s.Body[0].Y + s.Direction.Y,
    }
    s.Body = append([]Point{newHead}, s.Body...)

    if s.GrowCounter > 0 {
        s.GrowCounter--
    } else {
        s.Body = s.Body[:len(s.Body)-1]
    }
}

NewSnake function initializes the snake with a single body part located in the center of the screen and sets the initial direction to the right.

Move function calculates the new head position based on the current head position and direction. It then adds the new head to the body and removes the tail unless the snake is growing.

Implementing the Food

Now Create a Food struct to represent the food’s position and a NewFood() function to create a new food instance with a random position on the game screen.

type Food struct {
    Position Point
}

func NewFood() *Food {
    return &Food{
        Position: Point{
            X: rand.Intn(screenWidth / tileSize),
            Y: rand.Intn(screenHeight / tileSize),
        },
    }
}

Handling User Input and Game Updates

Create a Game struct to represent the game state, including the snake, food, score, speed, and game over flag.

type Game struct {
    snake         *Snake
    food          *Food
    score         int
    gameOver      bool
    ticks         int
    updateCounter int
    speed         int
}

Implement the Update() method for the Game struct to handle user input, update the snake's position, check for collisions, and handle the snake eating the food. If the snake eats the food, increment the score and update the food position.

func (g *Game) Update() error {
    if g.gameOver {
        if inpututil.IsKeyJustPressed(ebiten.KeyR) {
            g.restart()
        }
        return nil
    }

    g.updateCounter++
    if g.updateCounter < g.speed {
        return nil
    }
    g.updateCounter = 0

    // Update the snake's position
    g.snake.Move()

    if ebiten.IsKeyPressed(ebiten.KeyLeft) && g.snake.Direction.X == 0 {
        g.snake.Direction = Point{X: -1, Y: 0}
    } else if ebiten.IsKeyPressed(ebiten.KeyRight) && g.snake.Direction.X == 0 {
        g.snake.Direction = Point{X: 1, Y: 0}
    } else if ebiten.IsKeyPressed(ebiten.KeyUp) && g.snake.Direction.Y == 0 {
        g.snake.Direction = Point{X: 0, Y: -1}
    } else if ebiten.IsKeyPressed(ebiten.KeyDown) && g.snake.Direction.Y == 0 {
        g.snake.Direction = Point{X: 0, Y: 1}
    }

    head := g.snake.Body[0]
    if head.X < 0 || head.Y < 0 || head.X >= screenWidth/tileSize || head.Y >= screenHeight/tileSize {
        g.gameOver = true
        g.speed = 10
    }

    for _, part := range g.snake.Body[1:] {
        if head.X == part.X && head.Y == part.Y {
            g.gameOver = true
            g.speed = 10
        }
    }

    if head.X == g.food.Position.X && head.Y == g.food.Position.Y {
        g.score++
        g.snake.GrowCounter += 1
        g.food = NewFood()
        g.score++
        g.food = NewFood()
        g.snake.GrowCounter = 1

        // Decrease speed (with a lower limit)
        if g.speed > 2 {
            g.speed--
        }
    }

    return nil
}

In the update function we're handling, game over logic, speed, user input, and restart game functionalities.

Drawing the Game Objects

Implement the Draw() method for the Game struct to render the game objects, such as the snake, food, and game over screen. Use Ebiten's drawing functions, like DrawRect(), to draw the snake and food as rectangles and the text.Draw() function to display the score and game over message.

func (g *Game) Draw(screen *ebiten.Image) {
    // Draw background
    screen.Fill(color.RGBA{0, 0, 0, 255})

    // Draw snake
    for _, p := range g.snake.Body {
        ebitenutil.DrawRect(screen, float64(p.X*tileSize), float64(p.Y*tileSize), tileSize, tileSize, color.RGBA{0, 255, 0, 255})
    }

    // Draw food
    ebitenutil.DrawRect(screen, float64(g.food.Position.X*tileSize), float64(g.food.Position.Y*tileSize), tileSize, tileSize, color.RGBA{255, 0, 0, 255})

    // Create a font.Face
    face := basicfont.Face7x13

    // Draw game over text
    if g.gameOver {
        text.Draw(screen, "Game Over", face, screenWidth/2-40, screenHeight/2, color.White)
        text.Draw(screen, "Press 'R' to restart", face, screenWidth/2-60, screenHeight/2+16, color.White)
    }

    // Draw score
    scoreText := fmt.Sprintf("Score: %d", g.score)
    text.Draw(screen, scoreText, face, 5, screenHeight-5, color.White)
}

Restarting the Game

At last implement a restart() method for the Game struct to reset the game state when the player presses 'R' after a game over.

func (g *Game) restart() {
    g.snake = NewSnake()
    g.score = 0
    g.gameOver = false
    g.food = NewFood()
    g.speed = 10
}

This code checks if the R key is pressed when the game is over, and if so, it restarts the game by calling the restart method. The restart method resets the game state, including the snake, score, and gameOver flag.

Running Game

Follow me on twitter and message me, I’ll send you the full working code at once.

Conclusion

Congratulations! You’ve now built a simple snake game using Golang and the Ebiten library. In the process, you’ve learned the basics of Golang, including variables, functions, loops, and structs, as well as how to handle user input and collisions in a game.

You can further enhance this game by adding more features such as different levels, obstacles, or power-ups. The possibilities are endless, and you now have a solid foundation to build upon as you continue learning Golang through game development. Happy coding!

If you’re interested in learning more about programming and related topics, we invite you to check out our website programmingeeksclub.com. We offer valuable resources and insights.

You can find us on Twitter and Facebook.

Download my first ebook about mastering markdown, from here: Download , reviews and recommendations are appreciated.

Streamline Your Content Creation with the Power of Markdown

Kuldeep Singh — Mon, 01 May 2023 08:31:05 +0000

In today's digital world, content creation is more important than ever. Whether you're a writer, programmer, or content creator, you need a tool that simplifies your writing process and streamlines your workflow. Enter Markdown—a lightweight markup language designed to make it easy to format text and web content.

In this blog post, we'll introduce you to the basics of Markdown and share some tips on getting started. Plus, we'll reveal a valuable resource for mastering Markdown and unlocking its full potential.

What is Markdown?

Markdown is a plain text formatting syntax created by John Gruber and Aaron Swartz. It allows you to create well-formatted documents using simple symbols and minimal syntax. Markdown is easy to read and write, making it an ideal choice for content creators who want to focus on their message rather than wrestle with complex formatting.

Getting Started with Markdown

Here are some basic Markdown elements to help you get started:

1. Headings

Use the hash symbol (#) followed by a space to create headings. The number of hash symbols corresponds to the level of the heading, from one (#) for the largest heading to six (######) for the smallest.

# Heading 1
## Heading 2
### Heading 3
#### Heading 4
##### Heading 5
###### Heading 6

2. Bold and italic text

To make text bold, surround it with double asterisks (**). To make it italic, use single asterisks (*) or underscores (_).

**Bold text**
*Italic text*
_Italic text_

3. Lists

For unordered lists, use asterisks (*), plus signs (+), or hyphens (-) followed by a space. For ordered lists, use numbers followed by a period and a space.

- Item 1
- Item 2
- Item 3

+ Item 1
+ Item 2
+ Item 3


* Item 1
* Item 2
* Item 3

1. Item 1
2. Item 2
3. Item 3

4. Links and images

To create a link, wrap the link text in square brackets [ ] and the URL in parentheses ( ). To add an image, start with an exclamation point (!), followed by the image description in square brackets and the image URL in parentheses.

[Link text](https://www.programmingeeksclub.com)
![Image description](https://www.example.com/image.jpg)

Mastering Markdown: A Quick Guide to Formatting Documents and Web Content

While the basics of Markdown are simple and easy to learn, there's much more to discover. If you're interested in diving deeper and truly mastering Markdown, check out "Mastering Markdown: A Quick Guide to Formatting Documents and Web Content."

This comprehensive eBook covers everything from basic formatting techniques to advanced features like tables, blockquotes, and Markdown extensions. Plus, you'll learn how to integrate Markdown into your daily workflow and collaborate more effectively on platforms like GitHub, GitLab, and Bitbucket.

Unlock the full potential of Markdown and transform your content creation process with "Mastering Markdown: A Quick Guide to Formatting Documents and Web Content."

Download your copy of "Mastering Markdown" now!

Happy writing! 🚀

If you’re interested in learning more about programming and related topics, we invite you to check out our website programmingeeksclub.com. We offer valuable resources and insights.

You can find us on Twitter and Facebook.

Go Programming Language: A Comprehensive Introduction and History of Google’s Revolutionary Language

Kuldeep Singh — Sat, 22 Apr 2023 06:13:32 +0000

Welcome to our Go programming language tutorial series! In this series, we will take a deep dive into the world of Go and explore its features, syntax, and best practices for building scalable and efficient applications. Whether you’re new to programming or an experienced developer, this series will provide you with the knowledge and tools you need to start building robust applications with Go.

Throughout the series, we will cover the basics of Go, including variables, functions, and control structures, as well as more advanced topics such as concurrency, networking, and database access. We will also provide practical examples and hands-on exercises to help you solidify your understanding of the language and its concepts.

Our goal is to make this series accessible and engaging for learners of all levels. Whether you’re just starting out in programming or looking to expand your skills with a new language, we hope this series will provide you with valuable insights and tools for success.

So, without further ado, let’s dive into the world of Go and start exploring its unique features and advantages.

Introduction

Go, also known as Golang, is a popular programming language that was created by Google in 2007. It has gained a lot of attention over the years for its simplicity, efficiency, and scalability. In this article, we will take a deep dive into what Go is, its history, and its unique features that make it a popular choice for developers worldwide.

What is Go?

Go is an open-source programming language developed by Google in 2007. It was created by Robert Griesemer, Rob Pike, and Ken Thompson, who were all experienced developers at the time. The language was designed to be simple, efficient, and scalable, making it suitable for a wide range of applications.

Features of Go

Go has several unique features that make it stand out from other programming languages. Some of these features include:

Simplicity: Go is designed to be easy to learn and use. It has a straightforward syntax that is easy to read and understand, making it an ideal language for beginners.
Concurrency: Go has built-in support for concurrency, allowing developers to write efficient and scalable code for multi-core systems.
Garbage Collection: Go has a garbage collector that automatically manages memory allocation and deallocation, making it easier for developers to write code without worrying about memory leaks.
Cross-Platform Support: Go is designed to be cross-platform, meaning it can run on various operating systems, including Windows, Linux, and macOS.
Standard Library: Go has a vast standard library that provides developers with a wide range of tools and functions for building applications.

Advantages of Go

Some of the advantages of using Go include:

Efficiency: Go is a fast language that compiles quickly, making it an ideal choice for large-scale applications.
Scalability: Go’s built-in support for concurrency makes it easy to write code that can handle a high volume of traffic.
Simplicity: Go’s simple syntax makes it easy for developers to read and understand code, reducing the likelihood of errors.
Cross-Platform Support: Go can run on various operating systems, making it a flexible language that can be used for a wide range of applications.

Disadvantages of Go

Despite its many advantages, Go has a few drawbacks, including:

Lack of Libraries: While Go has a standard library that provides developers with many tools and functions, it has a relatively small community, which means that it may be challenging to find libraries for specific tasks.
Learning Curve: Although Go is designed to be easy to learn, it still requires developers to learn a new language, which can take some time.

History of Go

Go’s creation was a response to the challenges faced by Google in building large-scale applications. Google was using a combination of languages, including C++, Python, and Java, but none of these languages provided the efficiency, simplicity, and scalability that Google needed.

In 2007, Robert Griesemer, Rob Pike, and Ken Thompson began working on a new language that would address these challenges. Their goal was to create a language that would be as fast as C++, as easy to write as Python, and as scalable as Java. The first version of Go was released in 2009, and since then, it has undergone several major releases.

Adoption and Community

Since its release, Go has gained a large and active community of developers who use the language to build a wide range of applications, from web servers and APIs to system utilities and mobile applications. Go is used by many large companies, including Google, Uber, Dropbox, and Docker.

The Go community is known for its collaborative and supportive culture, with many developers contributing to open-source projects and helping each other to solve problems. The Go community is also known for its commitment to simplicity and efficiency, with many developers focused on building applications that are fast, scalable, and easy to maintain.

Conclusion

Go is a powerful and popular programming language that offers many unique features and advantages. Its simplicity, efficiency, and scalability make it an ideal choice for building a wide range of applications, from web servers and APIs to system utilities and mobile applications. While it has a few drawbacks, such as a lack of libraries and a learning curve for new developers, its active community and commitment to simplicity and efficiency make it a language worth considering for your next project.

If you’re interested in learning more about programming and related topics, we invite you to check out our website programmingeeksclub.com. We offer valuable resources and insights.

You can find us on Twitter and Facebook.

In next part of this series we are going to setting up a Go Development Environment so if you don’t want to miss it, then do follow us and stay tuned with our latest content.

Earn $200+ an Article By Writing For These Websites

Kuldeep Singh — Tue, 18 Apr 2023 07:58:35 +0000

As a freelance writer, it can be challenging to find well-paying clients who value your work. But the good news is, several websites are willing to pay substantial rates for quality content. In this article, we’ll explore three websites that pay $200 or more for an article. With some research, creativity, and perseverance, you can turn your passion for writing into a profitable venture.

1. Cracked

Cracked is an immensely popular humor website that focuses on list-style and informative articles, with a touch of comedy. This site has a massive readership, and they’re constantly on the lookout for talented writers who can make their audience laugh while providing valuable insights.

Pay: Up to $250 per article

Submission Guidelines: Cracked welcomes unsolicited article pitches and provides a helpful guide to assist writers in crafting engaging content. They’re primarily interested in list-style articles, and they appreciate writers who can provide fresh, unique perspectives. Visit their Writer’s Workshop page for more details and pitch submission.

Tips for Success: Cracked values originality, so avoid clichés and make sure your idea hasn’t been covered before. Engaging visuals and humor are key ingredients to a successful pitch. The more unique and entertaining your content, the better your chances of acceptance.

2. A List Apart

A List Apart is a prestigious online magazine that focuses on web design, development, and content strategy. This platform is an excellent opportunity for writers with expertise in these areas to showcase their knowledge and get paid for it.

Pay: $200 per article

Submission Guidelines: A List Apart accepts submissions on a variety of topics, including user experience, coding, content strategy, and web design. They prefer articles between 1,500 and 2,000 words, and you can submit your pitch via their online form. For more details on their submission process, visit their Write for Us page.

Tips for Success: The A List Apart team is looking for well-researched and in-depth articles that provide actionable advice to readers. Demonstrate your expertise in the subject matter, and ensure your content is concise, informative, and engaging.

3. The Layout

The Layout is a web design and development blog powered by Flywheel, a managed WordPress hosting platform. They offer a wealth of resources for web professionals and are always looking for knowledgeable contributors.

Pay: $200 to $500 per article

Submission Guidelines: The Layout accepts submissions on a wide range of web-related topics, such as design trends, development techniques, and WordPress tutorials. They prefer articles between 1,000 and 2,500 words. To submit a pitch, email them with your proposed topic, a brief outline, and relevant writing samples. For more information, visit their Write for Us page.

Tips for Success: Focus on delivering practical tips, advice, and tutorials that will help web professionals improve their skills. Ensure your content is well-structured and easy to follow, and keep in mind that The Layout values originality and depth.

Final Word

Writing for well-paying websites can be both rewarding and lucrative. By targeting Cracked, A List Apart, and The Layout, you can earn $200 or more per article while gaining exposure to a broad audience. Take the time to research each website thoroughly, tailor your pitch to their specific guidelines, and showcase your unique voice and expertise. With dedication and persistence, you can unlock the door to a successful freelance writing career.

If you’re interested in learning more about freelance writing, personal finance and related topics, we invite you to check out our website smartinvestorszone.com. We offer valuable resources and insights that can help you achieve success in your writing career.

You can find us on Twitter and Facebook.

Fascinating Programming Facts You Need to Know

Kuldeep Singh — Mon, 03 Apr 2023 05:12:52 +0000

Programming is a fascinating field that has come a long way since its inception. Over the years, there have been countless developments, advancements, and innovations in programming languages, tools, and technologies. With all these changes, it’s easy to overlook the history of programming and the interesting facts that have shaped it.

If you’re a programmer or just someone interested in the field, here are some great programming facts that you should know:

The first computer virus was created in 1983 by a programmer named Fred Cohen. He was a graduate student at the University of Southern California, and his virus infected Apple II computers. The virus was called the “brain” virus because it targeted the boot sector of floppy disks and replaced it with a copy of itself.
The world’s first computer, the Atanasoff-Berry Computer (ABC), was built in the late 1930s and early 1940s by John Atanasoff and Clifford Berry. The ABC was the first computer to use binary digits (bits) to represent data and to perform operations using electronic switches.
The programming language Python was created by Guido van Rossum in the late 1980s. He named it after the Monty Python comedy group, of which he was a big fan. Python has since become one of the most popular programming languages in the world.
The term “debugging” comes from Grace Hopper, a computer scientist who worked on the Harvard Mark II computer in the 1940s. One day, her team found a moth stuck in a relay and removed it. Hopper then used the term “debugging” to describe the process of fixing errors in code.
The first computer game, Spacewar!, was created in 1962 by Steve Russell. It was played on a Digital PDP-1 computer and featured two spaceships battling each other. Spacewar! was a groundbreaking game that paved the way for the modern video game industry.
The first hard disk drive was created by IBM in 1956. It was the size of a refrigerator and could store 5 MB of data. Today, hard disk drives are much smaller and can store terabytes of data.
The programming language COBOL was designed in 1959 and is still used in some legacy systems today. COBOL stands for “Common Business-Oriented Language” and was designed to be easily readable by humans.
The first text message was sent in 1992 by Neil Papworth, a software engineer in the UK. The message read “Merry Christmas” and was sent from a computer to a mobile phone.
The first smartphone, the IBM Simon, was released in 1993. It had a touch screen, fax capability, and a calendar. The IBM Simon was a revolutionary device that paved the way for the modern smartphone.
The first computer to beat a human at chess was Deep Blue, created by IBM. In 1997, it defeated world champion Garry Kasparov in a six-game match. Deep Blue was a landmark achievement in the field of artificial intelligence.

These are just a few of the many great programming facts out there. If you want to learn more about the history and evolution of programming, be sure to check out our blog post on “What are great programming facts?”

So next time you’re writing code or tinkering with a computer, remember the fascinating history and interesting facts that have made programming what it is today. Happy programming!

Originally published at programmingeeksclub.com.

You can follow me on Twitter, Facebook, Telegram, YouTube, My Blog.

C program to display calendar for a given year

Kuldeep Singh — Tue, 14 Mar 2023 12:01:03 +0000

A calendar is an essential tool that is used by people all over the world to manage their schedules and appointments. It helps in planning events, meetings, and tasks, and keeps track of important dates and holidays. In this article, we will learn how to write a C program to display a calendar for a given year. We will use the Gregorian calendar, which is the most widely used calendar system in the world.

Code

We will begin by defining the main function, which will take the year as input and display the calendar for that year. We will use a two-dimensional array to represent the calendar, with each row representing a week and each column representing a day. The program will use a loop to fill in the array with the dates for each day of the year.

#include <stdio.h>

int main()
{
    int year, month, day;
    int daysInMonth, startingDay;

    printf("Enter the year: ");
    scanf("%d", &year);

    char *months[] = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"};

    int daysInWeek = 7;
    int calendar[6][7];

    // Calculate starting day
    startingDay = getStartingDay(year);

    // Fill in the calendar with dates
    int row = 0;
    for (month = 0; month < 12; month++)
    {
        daysInMonth = getDaysInMonth(month, year);

        // Print month and year header
        printf("\n     %s %d\n", months[month], year);
        printf("Sun Mon Tue Wed Thu Fri Sat\n");

        // Fill in the days for the month
        for (day = 1; day <= daysInMonth; day++)
        {
            calendar[row][startingDay] = day;
            startingDay++;

            // Move to the next row if necessary
            if (startingDay > 6)
            {
                startingDay = 0;
                row++;
            }
        }

        // Print the calendar for the month
        for (int i = 0; i < 6; i++)
        {
            for (int j = 0; j < 7; j++)
            {
                if (calendar[i][j] == 0)
                {
                    printf("    ");
                }
                else
                {
                    printf("%3d ", calendar[i][j]);
                }
            }
            printf("\n");
        }

        // Reset the row and starting day for the next month
        row = 0;
        startingDay = (startingDay + daysInMonth) % daysInWeek;
    }
}

We will define two helper functions to calculate the starting day of the year and the number of days in each month. The getStartingDay function will take the year as input and return the starting day of the year, which will be a number between 0 and 6 representing the day of the week. The getDaysInMonth function will take the month and year as input and return the number of days in that month.

int getStartingDay(int year)
{
    int d = (1 + (year - 1) * 365 + (year - 1) / 4 - (year - 1) / 100 + (year - 1) / 400) % 7;
    return d;
}

int getDaysInMonth(int month, int year)
{
    int daysInMonth;

    if (month == 1)
    {
        if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
        {
            daysInMonth = 29;
        }
        else
        {
            daysInMonth = 28;
        }
    }
    else if (month == 3 || month == 5 || month == 8 || month == 10)
    {
        daysInMonth = 30;
    }
    else
    {
        daysInMonth = 31;
    }

    return daysInMonth;
}

The getStartingDay function uses a formula to calculate the starting day of the year based on the year number. The formula takes into account the number of days in previous years, as well as the number of leap years that occurred in that time. The function returns the starting day as a number between 0 and 6, with 0 representing Sunday.

The getDaysInMonth function takes the month and year as input and uses a conditional statement to determine the number of days in that month. February has a different number of days in leap years than in normal years, so we check if the year is a leap year before setting the number of days in February. The function returns the number of days in the specified month.

Finally, we will create an array of month names that will be used to display the month and year header for each month. We will also define the number of days in a week, which is 7, and the calendar array, which will hold the dates for each day of the year.

The program will use a loop to iterate through each month of the year, calling the helper functions to get the starting day and number of days in each month. It will then fill in the calendar array with the dates for each day of the month, and display the calendar for that month using a nested loop.

You’ll see the following output once you run this above code:

Originally published at https://programmingeeksclub.com/c-program-to-display-calendar-for-a-given-year/

You can follow me on Twitter, Facebook, Telegram, YouTube, My Blog.

Why Go is the Future of Backend Development

Kuldeep Singh — Mon, 27 Feb 2023 12:44:24 +0000

In recent years, popularity of the Go programming language has increased rapidly. Originally developed by Google, Go has quickly become one of the most popular languages for backend development, particularly in the development of distributed systems and microservices. In this article, We will discuss the reasons why Go is the future of backend development.

Introduction of Go

Go, also known as Golang, is an open source programming language developed by Google in 2007. It has been gaining popularity in recent years as a powerful and efficient language for backend development. One of the main reasons for its popularity is its performance and speed.

1. Speed and Efficiency Of Go

One of the primary reasons why Go has emerged as a popular programming language for backend development is, It’s speed and efficiency.

Go was designed from the ground up to be a fast and efficient programming language, Making it ideal for building backend systems that can handle a high volume of requests.

Go achieves its speed and efficiency through several features, including its built-in Garbage Collector, low-level memory management, and compiler optimizations. These features allow Go to achieve excellent performance without sacrificing safety or productivity.

The Garbage Collector in Go is highly optimized and runs concurrently with the program, which means that it does not cause pauses in the application. This is critical for backend systems that need to handle a high volume of requests and must remain responsive at all the times.

Go’s low-level memory management is another factor that contributes to its speed and efficiency. Unlike many other high-level programming languages, Go allow developers to control memory allocation and deallocation directly. This level of control enables developers to optimize the use of memory in their applications and avoid the overhead associated with garbage collection in other languages.

The Go compiler is also highly optimized and includes features like escape analysis and inlining, which can significantly improve the performance of the resulting code. These optimizations enable Go to achieve faster startup times and overall performance compared to other high-level programming languages like Python or Ruby.

In addition to these features, Go also has a lightweight syntax that makes it easy to write clean and concise code. This simplicity enables developers to write code faster and reduces the likelihood of errors, resulting in more efficient and reliable backend systems.

Overall, Go’s speed and efficiency make it an excellent choice for building high-performance backend systems that can handle a high volume of requests. Its optimized garbage collector, low-level memory management, and compiler optimizations, along with its lightweight syntax, provide developers with the tools they need to build fast and reliable systems.

2. Concurrency and Scalability

Concurrency and scalability are two of the most critical features of any modern backend system. A scalable backend should be able to handle increasing number of requests without impacting performance, while a concurrent backend can execute multiple tasks simultaneously, Improving overall efficiency.

We will explore how Go’s unique approach to concurrency and scalability makes it an excellent choice for building modern backend systems.

First let’s understand the concurrency first:

Concurrency in Go

Go was designed from the ground up to support concurrency, Making it one of the most popular programming languages for building concurrent applications and servers. Go’s approach to concurrency is based on the concept of goroutines, which are lightweight threads that allow multiple tasks to be executed simultaneously.

Here is an example of how goroutines work in Go:

package main

import "fmt"

func main() {
   go func() {
      fmt.Println("Goroutine 1")
   }()

   go func() {
      fmt.Println("Goroutine 2")
   }()

   time.Sleep(time.Second)
}

In this example, we defined two goroutines that prints a message to the console(terminal). The time.Sleep(time.Second) statement is added to keep the main thread alive until both goroutines have finished executing. When we run this program, we will see both messages printed to the console.

Goroutine 2
Goroutine 1

Output of the code is not fixed because of it’s concurrent behaviour.

This is just a simple example, but it demonstrates the power of goroutines. Goroutines are lightweight, so we can create thousands of them without significantly impacting performance. This makes Go an excellent choice for building concurrent applications.

Scalability in Go

Go’s approach to concurrency makes it an excellent choice for building scalable backend systems. In Go, we can use the same approach we used for goroutines to build scalable backend systems. We can create multiple goroutines to handle requests, ensuring that the backend can handle a large number of requests without impacting performance.

Here is an example of how we can build a scalable backend in Go:

package main

import "net/http"

func main() {
   http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
      go func() {
         // Handle request
      }()
   })

   http.ListenAndServe(":8080", nil)
}

In this example, we created a simple HTTP server that can handle requests. When a request is received, We create a new goroutine to handle it. This ensures that we can handle multiple requests simultaneously, making our backend system highly scalable.

Go’s unique approach to concurrency and scalability makes it an excellent choice for building modern backend systems. Its support for goroutines and lightweight threads makes it easy to build highly concurrent applications, while its scalability makes it an ideal choice for building large-scale backend systems.

Go’s simplicity and ease of use make it an excellent choice for both experienced and inexperienced developers. Its in-built garbage collection, support for concurrency and networking, and simple deployment options make it an ideal choice for building high-performance web applications and services.

Overall, Go is an excellent language for building modern backend systems, and its growing popularity is a testament to its unique approach to solving common problems in backend development. If you are looking to build a highly concurrent and scalable backend, Go is definitely worth considering.

3. Microservices and Deployment

Microservices are a popular architectural pattern for building modern backend systems. The idea behind the microservices is to break down large monolithic applications into smaller, independently deployable services that can communicate with each other through APIs. This approach provides several benefits, including improved scalability, agility, and resilience.

Go is an excellent language for building microservices due to its simplicity, performance, and support for concurrency. In this section, we will explore how Go’s unique approach to microservices and deployment makes it, an excellent choice for building modern backend systems.

Creating Microservices in Go

Creating microservices in Go is relatively straightforward. We can create individual services as separate packages or executables, and each service can communicate with other services through APIs. This approach makes it easy to test and deploy individual services independently, allowing for rapid development and deployment of new features.

Here is an example of a simple microservice in Go:

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
        response := map[string]string{"message": "Hello, World!"}
        json.NewEncoder(w).Encode(response)
    })

    http.ListenAndServe(":8080", nil)
}

In this example, we created a simple microservice that returns a JSON response containing a “message” field with the value “Hello, World!”. We then used the http package to listen for incoming requests on port 8080. This microservice can be deployed and scaled independently, allowing for rapid development and deployment of new features as per requirement.

Deployment of Microservices in Go

Deployment of microservices in Go is relatively easy due to the language’s support for cross-compilation and static linking, This means that we can compile our microservices for a particular platform and distribute them as self-contained executables, making it easy to deploy them to a variety of environments.

Here is an example of how we can compile and deploy a microservice for a Linux environment:

$ GOOS=linux GOARCH=amd64 go build -o hello-world-linux-amd64
$ scp hello-world-linux-amd64 user@server:/path/to/deployment/folder

In this example, we used the GOOS and GOARCH environment variables to specify that we want to compile our microservice for a Linux environment running on an AMD64 architecture. We then used the go build command to compile our microservice and save it as an executable. Finally, we use the scp command to copy the executable to our deployment folder on the server.

This article is originally published on programmingeeksclub.com, you can also read full article there as well.

You can follow me on Twitter, Facebook, Telegram, YouTube, My Blog.

You can also support me by donating

Use cases of log.Fatal in Golang

Kuldeep Singh — Fri, 10 Feb 2023 09:09:33 +0000

The log.Fatal() function is used when something really bad has happened and you just want to exit your program as fast as possible after reporting the error situation.

In this article we are going to learn about when to use the log.Fatal() in Golang. “The log.Fatal() function is used when something really bad has happened and you just want to exit your program as fast as possible after reporting the error situation.“

Let’s take an example, You have a microservice which uses the environment file, to use that environment file you must load all the variable in that session and for that you’re using a function called LoadEnv(path string) error, which takes the path of the environment file and and returns a error if anything goes wrong, By chance if the provided path is wrong then the function will immediately return back the error that “provided path is wrong” if you’re not going to handle that situation then you might not be able to use the environment variables anymore, so that’s why you’ll need to use the log.Fatal(err) to return back from that situation and terminates your program so you can identify what is causing the error.

Let’s see cover some use cases when to use log.Fatal() function and when not to use log.Fatal() function.

When to use log.Fatal()?

Below is the possible use cases when you should use log.Fatal() function:

Always use log.Fatal() for those errors which can crash your server.
Always use log.Fatal() in your DB connection function, if you’re using a DB then you don’t want your services to fail so it’s better to terminate service and update DB credentials or check why connection with DB is not happening.
Always use log.Fatal() for those service connection functions which are required to run your server. Example you’re using redis to store data and if the connection with redis is not established then the function that is using the connection can not store or extract information from redis so in connection function always use log.Fatal() in your error conditions.
When the program encounters an unexpected error condition, such as invalid input from the user, a call to log.Fatal() can be used to terminate the program and report the error.
When the program is unable to write to a required file, such as a log file, a call to log.Fatal() can be used to terminate the program and report the error.
When a required configuration file is not found or cannot be read, a call to log.Fatal() can be used to terminate the program and report the error. Now we have idea when to use log.Fatal() function, It’s time to cover the use cases when not to use log.Fatal() function.

When not to use log.Fatal()?

Below is the possible use cases when you shouldn’t use log.Fatal() function:

When the program can continue to execute despite the error. In these cases, it’s better to use log.Print() or log.Panic() to report the error, but allow the program to continue running.
When the error is recoverable, for example, when the program is unable to connect to a server, it can retry connecting after a certain period of time. In this case, it is not appropriate to use log.Fatal() as it will terminate the program immediately.
When the error is due to a transient issue, such as a temporary network outage, it might not be appropriate to use log.Fatal() as it can cause the program to terminate unnecessarily.
When the error is expected and handled by the program, such as invalid input from the user. In these cases, it’s better to use log.Print() or return a specific error message to the user instead of terminating the program with log.Fatal().
When the error is part of normal operation, such as a request to a non-existing endpoint in a web application, it’s better to return a 4XX or 5XX HTTP status code instead of using log.Fatal() to terminate the program.

Demonstration of log.Fatal() function

Below is a server code which demonstrates the use of log.Fatal() function in Golang:

package main

import (
    "errors"
    "log"
    "net/http"
    "os"

    "github.com/joho/godotenv"
)

var PORT string

func init() {
    args := os.Args
    if len(args) < 1 {
        log.Fatal(errors.New("no argument provided"))
    }
    err := godotenv.Load(args[1])
    if err != nil {
        log.Fatal("failed to load env file ", err)
    }
}

func main() {
    PORT = os.Getenv("PORT")
    if PORT == "" {
        PORT = "8001"
    }

    server := http.NewServeMux()
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello from Testing Server :)"))
    })

    err := http.ListenAndServe(":"+PORT, server)
    if err != nil {
        log.Fatal("failed to run server", err)
    }
}

So as you can see in the code that, I have used the log.Fatal() function alot, first I’ve used it in to check if the argument is not provided then it’ll automatically terminate the program and also tell program that you forget to provide the argument which is required to run this program.

In Second we’re using log.Fatal() to terminate the server if anything goes wrong with godotenv.Load(args[1]) and we’re also passing a message to programmers to understand on which line the code is failing, The root of the problem.

This time we’re using log.Fatal() to terminate our server if anything wrong goes with the http.ListenAndServe() function.

It’s important to note that log.Fatal() is a function that will terminate the program, so use it only when you want your program to not continue to execute.

Originally article is published

You can follow me on these platforms as well:

My Personal Blogging Website : Programming Geeks Club
My Facebook Page : Programming Geeks Club
My Telegram Channel : Programming Geeks Club
My Twitter Account : Kuldeep Singh
My Youtube Channel: ProgramminGeeksClub

JavaScript Splice Method Explained in Detail

Kuldeep Singh — Mon, 02 Jan 2023 13:39:51 +0000

JavaScript has multiple methods for string and array data type, most of them are useful, So today, We are going to learn about one of them, which is splice.

The given definition for splice method is that it updates(modifies) the existing array and returns a part of the array which is cut from the original array as per given values to splice method.

Most of us just use the splice method to cut only the required part from the array, but you can do a lot more than just cutting a part of an array. That’s what we are going to explore in this article.

We are going to start from the beginning of the splice, what splice method is, what are the possible ways to use a splice method over an array.

What is Splice?

Splice is a method, which can be used to update or modify an array, also the part which is being cut or updated will be returned as array from splice method, and splice method only works for arrays the splice method is not made for string data type so never try to use a splice method on string you’ll get only errors, nothing else :).

Let’s cover all the possible ways to use the splice method on an array.

1. Passing single argument

Splice method takes multiple arguments but starting two are important and the first one is the most important the first argument of the splice() method tells splice to cut down the array from that index to the last index, the starting index is included which means if we have an array [1,2,3,4,5] and we pass splice(1) index 1 then from index 1 to the last index all values will be deleted from our original array and splice() method will return those values as new array, below is the code for the following scenario, one more thing you can cut the array from right to left as well by providing negative index value in the first argument of splice method.

1. Passing Positive Index

below is the example for this:

arr = [1, 2, 3, 4, 5];
arg = arr.splice(1);
console.log(`original array ${arr}`);
// [1]
console.log(`array returned by splice ${arg}`);
// [2,3,4,5]

2. Passing Negative Index

Below is the example for this:

arr = [1, 2, 3, 4, 5];
arg = arr.splice(-3);
console.log(`original array ${arr}`);
// [1,2]
console.log(`array returned by splice ${arg}`);
// [3,4,5]

The splice method always cuts or updates the array from left to right even if the given arguments are negative, this is the important thing always need to remember as a JavaScript Developer.

2. Passing two arguments

We learned in the previous block that what the first argument does in the splice method, now let’s understand the second argument, what it does and what are the possible ways to use the second argument of the splice method.

Second argument of the splice method is for the items you want to delete or cut from the array.

For example we have an array [1,2,3,4,5] and you want to cut the only two index from this array, if it’s 4,5 , not middle indexes, then it’s good you can use single argument in splice method but you want 2,3 to be cut or removed from array then you might have to use second argument which will tell splice method that our job is done return back the data, syntax: arr.splice(1,2), It’ll cut two indexes from original array and return us the [2,3] into new array.

Below is the some use cases of passing two arguments:

Passing Positive Argument

arr = [1, 2, 3, 4, 5];
arg = arr.splice(1, 2);
console.log(`original array ${arr}`);
// [1,4,5]
console.log(`array returned by splice ${arg}`);
// [2,3]

Passing First Negative argument

arr = [1, 2, 3, 4, 5];
arg = arr.splice(-3, 2);
console.log(`original array ${arr}`);
// [1,2,5]
console.log(`array returned by splice ${arg}`);
// [3,4]

If you provide second argument 0 or nil then you’ll get no changes in array and as well no return value.
If your array length is 5 and you provide -1 in the first argument, in second you provide something 3, then you’ll only cut the last index from the array, it’ll not give any error regarding second argument passing length or something etc.

Below is the example for this case:

Second argument zero

arr = [1, 2, 3, 4, 5];
arg = arr.splice(1, 0);
console.log(`original array ${arr}`);
// [1,2,3,4,5]
console.log(`array returned by splice ${arg}`);
// []

exceeding array length arguments

rr = [1, 2, 3, 4, 5];
arg = arr.splice(-1, 3);
console.log(`original array ${arr}`);
// [1,2,3,4]
console.log(`array returned by splice ${arg}`);
// [5]

3. Passing three or more arguments

Now we have idea of two arguments what each one of them do, let’s learn about three or more, the possible things you can do with three or more arguments are like you can add new indexes in array, update the index values, delete the index values, how we can do these all of things let’s see below is the example code for all of these mentioned ways:

Syntax of three arguments of splice():

arr.splice(startIndex, elementsToDelete, replacewith…)

Add Values In Array

So for adding the values into array without updating any value using splice method is very easy, what we have to do is that, first we need to add our index from where we want to start adding values then for second argument we need to provide 0, which means we don’t want to update any value, just add them from the given index and move others, already in same position to right side which makes array length to increase automatically.

Below is the code example of this:

arr = [1, 4, 5, 6, 7];
arg = arr.splice(1, 0, 2, 3);
console.log(`original array ${arr}`);
// [1,2,3,4,5,6,7]
console.log(`array returned by splice ${arg}`);
// []

Update Values In Array

We have seen how we can add new values in an array using splice, the only difference is that if you need to update your array values then you’ll need to provide the second value as a valid number, zero will not work :). Below is the example code for updating array using splice method:

arr = [1, 4, 5, 4, 5];
arg = arr.splice(1, 2, 2, 3);
console.log(`original array ${arr}`);
// [1,2,3,4,5]
console.log(`array returned by splice ${arg}`);
// [4,5]

Updating and Deleting at the same time

Yes you can update and delete values at the same time as well using splice, let’s see how for example you have an array [1,4,5,4,5] and you want update index 1,2 values and wants to remove index 3 value then you’ll need to pass your second argument higher than your updating values like: arr.splice(1, 3, 2, 3) this will first add those values in same index and once the values are updated will remove index 3 value, below is the example for this scenario:

arr = [1, 4, 5, 4, 5];
arg = arr.splice(1, 3, 2, 3);
console.log(`original array ${arr}`);
// [1,2,3,5]
console.log(`array returned by splice ${arg}`);
// [4,5,4]

There are multiple ways you can use the splice method. Try some on your own as well if you find this article helpful then hesitate to share this with your friends. It's origianally published on my website, If you found this helpful check more articles like that on my website

You can follow me on these platforms as well: