DEV Community: Pritish Samal

Introduction to Go: A Powerful and Efficient Programming Language

Pritish Samal — Sun, 23 Jul 2023 09:35:46 +0000

Introduction

In the ever-evolving landscape of software development, programming languages play a vital role in shaping the way we build and deploy applications. Among the myriad of programming languages available, Go, also known as Golang, has gained significant popularity due to its simplicity, performance, and robustness. Created by Google engineers Robert Griesemer, Rob Pike, and Ken Thompson, Go was first released in 2009 and has since become a go-to choice for developers across various domains. In this blog, we will explore the fundamental features, strengths, and use cases of Go, highlighting why it has captured the hearts of programmers around the world.

A Brief Overview of Go

Go is an open-source, statically-typed, and compiled programming language designed to be simple and efficient. It draws inspiration from several existing languages, such as C, Pascal, and Oberon, but incorporates modern language features to address the challenges faced in contemporary software development.

Key Features

Simplicity: Go's syntax is clean and concise, making it easy for developers to read and understand the code. It eliminates unnecessary complexity, favoring a straightforward and intuitive design.
Concurrency Support: Go has built-in support for concurrency through goroutines and channels. Goroutines are lightweight threads that enable concurrent execution, while channels facilitate communication and synchronization between goroutines.
Garbage Collection: Go comes with automatic garbage collection, which helps manage memory effectively, relieving developers from manual memory management burdens.
Fast Compilation: The Go compiler, known as "gc," is highly optimized and provides quick compilation times, allowing developers to iterate and deploy their applications faster.
Static Typing: Being a statically-typed language, Go performs type-checking at compile-time, catching potential errors early in the development process.
Standard Library: Go ships with a robust standard library, providing a wide range of packages for various tasks like networking, file I/O, encoding/decoding, and much more, reducing the need for third-party dependencies.
Cross-platform Support: Go supports compilation to multiple platforms, enabling developers to write code once and deploy it on various operating systems with minimal modifications.
Open Source: Go is licensed under the BSD-style license, making it freely available to the community. This fosters an active and enthusiastic developer base, leading to continuous improvements and enhancements.

Getting Started with Go

Before diving into Go programming, you need to set up the development environment. Go's official website (https://golang.org) provides installation binaries for all major operating systems. Once installed, you can confirm the installation by running a simple "Hello, World!" program.

package main

import "fmt"

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

Save the code in a file with a ".go" extension (e.g., hello.go) and run it using the following command:

$ go run hello.go

If everything is set up correctly, you should see "Hello, World!" printed on the console.

Language Syntax

Go's syntax is straightforward and easy to grasp, making it an excellent choice for developers coming from different programming backgrounds. Let's take a closer look at some essential elements of Go's syntax.

Variables and Constants

In Go, variables are declared using the var keyword, followed by the variable name and its type.

package main

import "fmt"

func main() {
    var age int
    age = 30

    fmt.Println("Age:", age)
}

Constants are defined using the const keyword, and their values cannot be changed during runtime.

package main

import "fmt"

func main() {
    const pi = 3.14
    fmt.Println("Value of Pi:", pi)
}

Control Structures

Go supports familiar control structures like if, for, and switch.

package main

import "fmt"

func main() {
    // if-else
    num := 10
    if num%2 == 0 {
        fmt.Println("Even")
    } else {
        fmt.Println("Odd")
    }

    // for loop
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
    }

    // switch
    fruit := "apple"
    switch fruit {
    case "apple":
        fmt.Println("It's an apple.")
    case "banana":
        fmt.Println("It's a banana.")
    default:
        fmt.Println("Unknown fruit.")
    }
}

Functions

Functions in Go are defined using the func keyword, followed by the function name, parameters, return type (if any), and the function body.

package main

import "fmt"

func add(a, b int) int {
    return a + b
}

func main() {
    result := add(3, 7)
    fmt.Println("Result:", result)
}

Structs

Go allows developers to define custom data types using structs, which can encapsulate different fields.

package main

import "fmt"

type Person struct {
    Name   string
    Age    int
    Email  string
}

func main() {
    person := Person{
        Name:   "John Doe",
        Age:    30,
        Email:  "john.doe@example.com",
    }

    fmt.Println("Name:", person.Name)
    fmt.Println("Age:", person.Age)
    fmt.Println("Email:", person.Email)
}

Concurrency in Go

One of the standout features of Go is its built-in support for concurrency. Concurrency allows programs to execute multiple tasks independently, resulting in improved performance and resource utilization. In Go, concurrency is achieved using goroutines and channels.

Goroutines

A goroutine is a lightweight thread managed by the Go runtime. Unlike traditional threads, which are relatively heavy and may consume substantial memory, goroutines are highly efficient and have minimal overhead. They enable concurrent execution of functions, making it easy to perform tasks concurrently.

To create a goroutine, you need to use the go keyword before the function call.

package main

import (
    "fmt"
    "time"
)

func task() {
    for i := 1; i <= 5; i++ {
        fmt.Println("Task", i)
        time.Sleep(time.Second)
    }
}

func main() {
    fmt.Println("Main started.")
    go task()
    time.Sleep(5 * time.Second)
    fmt.Println("Main completed.")
}

In this example, the task function is executed as a goroutine concurrently with the main function. Without using go, the output would be sequential; however, with goroutines, the tasks are interleaved, demonstrating concurrent behavior.

Channels

Channels are communication primitives in Go, used for passing data between goroutines. They provide a safe and synchronized way to exchange information, allowing goroutines to communicate without race conditions.

Channels can be created using the make function with the chan keyword, specifying the type of data they will transmit.

package main

import "fmt"

func sum(values []int, ch chan int) {
    result := 0
    for _, num := range values {
        result += num
    }
    ch <- result // Send result through the channel
}

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    resultChannel := make(chan int)

    go sum(numbers, resultChannel)

    result := <-resultChannel // Receive result from the channel
    fmt.Println("Sum:", result)
}

In this example, the sum function calculates the sum of numbers and sends the result back through the ch channel. The main function creates a channel, calls sum as a goroutine, and then receives the result from the channel.

Go's Standard Library

Go's standard library is rich with functionality, covering a wide range of tasks. Let's take a brief look at some of the packages provided by the standard library.

net/http Package

The net/http package allows you to build web servers and web clients effortlessly. It provides functions to handle HTTP requests, responses, and routing.

package main

import (
    "fmt"
    "net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, Go!")
}

func main() {
    http.HandleFunc("/", helloHandler)
    http.ListenAndServe(":8080", nil)
}

In this example, a simple HTTP server is created using the net/http package. When a request is made to the root ("/") of the server, the helloHandler function responds with "Hello, Go!".

encoding/json Package

The encoding/json package provides functions to encode and decode JSON data. It is extensively used for working with JSON data in web applications and APIs.

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name  string `json:"name"`
    Age   int    `json:"age"`
    Email string `json:"email"`
}

func main() {
    jsonString := `{"name": "John Doe", "age": 30, "email": "john.doe@example.com"}`
    var person Person

    err := json.Unmarshal([]byte(jsonString), &person)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println("Name:", person.Name)
    fmt.Println("Age:", person.Age)
    fmt.Println("Email:", person.Email)

    // Encoding to JSON
    newPerson := Person{
        Name:  "Jane Smith",
        Age:   25,
        Email: "jane.smith@example.com",
    }

    newJSON, err := json.Marshal(newPerson)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println("New JSON:", string(newJSON))
}

In this example, the Person struct is used to unmarshal the JSON data into a Go struct and marshal a new struct back to JSON.

Conclusion

Go has proven itself to be a powerful and efficient programming language for building a variety of applications. Its simplicity, concurrency support, and performance make it an attractive choice for developers aiming to achieve scalability and maintainability in their projects.

In this blog, we've only scratched the surface of what Go has to offer. As you delve deeper into the language, you'll discover its vast ecosystem of libraries, frameworks, and tools that further simplify and enhance the development experience.

If you're looking for a language that strikes a balance between simplicity and power, Go is undoubtedly a language worth exploring. Whether you're a seasoned developer or just starting your programming journey, Go's approachable syntax and performance capabilities make it an excellent addition to your programming toolkit.

Resources to learn Go

How to develop Kyverno CLI locally?

Pritish Samal — Wed, 22 Jun 2022 21:17:58 +0000

"The Kyverno Command Line Interface (CLI) is designed to validate and test policy behaviour to resources prior to adding them to a cluster. The CLI can be used in CI/CD pipelines to assist with the resource authoring process to ensure they conform to standards prior to them being deployed."

You can install and use the kyverno cli using krew, yay or by directly building it from source. But here, we will see how to use kyverno CLI in development mode. Basically the usage remains the same except that here, you've to execute the Go package i.e. cmd/cli/kubectl-kyverno/main.go which essentially calls the kyverno CLI.

Prerequisite

The only pre-requisite is that you need to have Go installed and set-up correctly in your local development workspace. Also, your Go version must be greater than 1.16 thus it is recommended to install the latest release. Here's a great set of resources that can help you set-up Go development in your local environment.

You can download the latest binary release of Go from here
https://learn.gopherguides.com/courses/preparing-your-environment-for-go-development
If you're on a Windows machine, follow this
If you're on a Mac or Linux machine, follow this

Example

Let's say you've to run the test command to validate the Disallow Latest Tag policy.
To do this using the kyverno CLI, you run:

kyverno test ../policies/best-practices/disallow_latest_tag

But to use the kyverno CLI in the development mode, follow these steps:

Make sure you've cloned the fork of kyverno/kyverno and kyverno/policies in the same directory. Your workspace should be looking something like this:

/kyverno
    api
    charts
    cmd
    definitions
    docs...

/policies
    best-practices
    cert-manager
    other
    pod-security...

cd into kyverno directory (which is your local fork of kyverno/kyverno)
Run the below mentioned command:

go run ./cmd/cli/kubectl-kyverno/main.go test ../policies/best-practices/disallow_latest_tag

On executing the above command, you'll get an output as follows:

Executing disallow_latest_tag...
applying 1 policy to 1 resource... 
│───│─────────────────────│────────────────────│───────────│────────│
│ # │ POLICY              │ RULE               │ RESOURCE  │ RESULT │
│───│─────────────────────│────────────────────│───────────│────────│
│ 1 │ disallow-latest-tag │ require-image-tag  │ myapp-pod │ Pass   │
│ 2 │ disallow-latest-tag │ validate-image-tag │ myapp-pod │ Pass   │
│───│─────────────────────│────────────────────│───────────│────────│

useReducer Hook to the rescue!

Pritish Samal — Sun, 06 Feb 2022 10:51:28 +0000

Hello folks 👋
Have you ever felt the need of an easier way to manage complex state in your React application without having to install heavy dependencies? You've arrived at the right place. Let us talk about the useReducer() hook provided by React. You must be familiar with the useState() hook in React. It's basically a hook that lets you add state to a functional value. The useReducer hook, an alternative to the useState hook, also lets you manage the state when you've a complex state logic.

There are various state management libraries like Redux, Recoil, Easy Peasy, etc. Personally, I have used Redux to manage state and can say that the usage of useReducer hook is pretty much similar to that of Redux. However, there are some differences between Redux and the useReducer hook. The useReducer hook comes in-built with React but Redux is a 3rd party dependency which was built as a state management tool for JavaScript applications and not specifically for React. Also, it takes a lot of boilerplate code to set-up Redux but setting up useReducer is pretty minimal and straight forward. Today, we'll learn about managing state with useReducer hook by building a Notes Application.

So, I'll be demonstrating two basic functionalities of creating and deleting a note using useReducer(). You can find the code of the application here. First, let us create a basic controlled form which will store the title and body of the note.

<form>
  <input
    type="text"
    placeholder="Note Title"
    value={title}
    onChange={(e) => setTitle(e.target.value)}
  />
  <input
    type="text"
    placeholder="Note Body"
    value={body}
    onChange={(e) => setBody(e.target.value)}
  />
  <input type="submit" value="Add Note" />
</form>

So, we'll be using two states (one to store the note title and the other to store note body).

const [title, setTitle] = useState("");
const [body, setBody] = useState("");

In order to use the useReducer hook, we need to have our actions and reducers defined. The concept of actions and reducers in this case has the same use-case as that of redux. Reducer is nothing but a pure function that takes an action and the previous state of the application and returns a new state. Actions on the other hand describes what happened and it is the reducer's job to return the new state based on that action.

In this case we need two actions i.e. create and delete note which can be written as:

const ACTIONS = {
  ADD_NOTE: "add-note",
  DELETE_NOTE: "delete-note"
};

We have our Let's initialise a useReducer() hook below 👇

const [notes, dispatch] = useReducer(reducer, []);

Here, notes is the state which will store all the notes and the dispatch is the function of the global store using which we can dispatch an action. The empty array ([]) is the initial state of the notes array.

Now, let us define the onSubmit handler of our form:

<form onSubmit={handleSubmit}>

const handleSubmit = (e) => {
 e.preventDefault();
 dispatch({ type: ACTIONS.ADD_NOTE, payload: { title: title, body: body } });
 setTitle("");
 setBody("");
}

The dispatch function will take in an object with a field named type which will contain the type of action we want to perform when our form is submitted. Here, we'll be passing ACTIONS.ADD_NOTE action. Also, we can pass an optional field named payload(name can be anything, not necessarily payload) and can be any type of value.

It represents the payload of the action. Any information about the action that is not the type or status of the action should be part of the payload field.

When it comes to reducer, let's make one for ADD_NOTE action:

const reducer = (notes, action) => {
  switch (action.type) {
    case ACTIONS.ADD_NOTE:
      return [...notes, newNote(action.payload.title, action.payload.body)];
    default:
      return notes;
  }
};

The newNote() function that you can see above will only return a new note object with all the properties in it. It will look like👇

const newNote = (title, body) => {
  return { id: Date.now(), title: title, body: body };
};

On the dispatch of the ADD_NOTE action, it will execute its corresponding reducer and then the notes state will be updated with the new note.

In-order to display all the Notes, we can map through the notes array and we can display each note like below👇

{notes.map((note) => (
        <Note key={note.id} note={note} />
))}

Where, the Note component is the structure of a note and is imported in App.js.

export default function Note({ note }) {
  return (
    <Wrapper>
      <NoteTitle>{note.title}</NoteTitle>
      <NoteBody>{note.body}</NoteBody>
      <DeleteIcon>
        <Trash2 />
      </DeleteIcon>
    </Wrapper>
  );
}

Now, you can see when you submit the form a new note gets added in the screen.

PS: I've used Styled Components to style the jsx elements(personal preference) and feather icons using react-feather.

The first part of our application is done i.e. adding a note. Now moving on to deleting a note, we have its corresponding action as DELETE_NOTE. So, in order to delete a note, we require its id and this action needs to be dispatched when the delete button gets clicked which by the way is present in the Note.jsx component. Thus in-order to do the same, we can pass the dispatch function as a prop and then dispatch the action inside the note component.

Passing dispatch function as prop👇

<Note key={note.id} note={note} dispatch={dispatch} />

And then, destructure it in Note.jsx and use it when the delete button is clicked. We can do that like such below👇

export default function Note({ note, dispatch }) {
  return (
    <Wrapper>
      <NoteTitle>{note.title}</NoteTitle>
      <NoteBody>{note.body}</NoteBody>
      <DeleteIcon
        onClick={() =>
          dispatch({ type: ACTIONS.DELETE_NOTE, payload: { id: note.id } })
        }
      >
        <Trash2 />
      </DeleteIcon>
    </Wrapper>
  );
}

Since we require the note id inside the reducer, thus we passed it inside the payload object. Now, the final task remaining is to write a reducer function for DELETE_NOTE action👇

case ACTIONS.DELETE_NOTE:
      return notes.filter((note) => note.id !== action.payload.id);

The above snippet basically traverses through the notes array and it makes another array with all the notes whose id doesn't matches with the note.payload.id.

That was basically it. Your Note Application is up and running with create and delete functionalities. I know my CSS sucks but I'm trying to become better at it. Please bear with me😂

You can find the full codebase here. Before concluding, let me quickly walk you through the directory structure:

├── public
│   ├── index.html
├── src
│   ├── components
│   │   ├── Note.jsx // Note component
│   │   ├── Navbar.jsx // Navbar component
│   ├── store
│   │   ├── actions.js // Contains all the actions
│   │   ├── reducers.js // contains all the reducer functions
│   ├── App.js
│   ├── index.js
│   ├── styles.css
├── package.json

This type of structure can come handy when you've a complex state logic. Here we keep the actions and reducers separately inside a store directory and you just import them and use wherever required.

That was all about the useReducer() hook. Hope you liked it. Do like, share and comment your suggestions below. I'm trying to be consistent in publishing articles now xD. There are a few other blogs lined up too. They'll be on the Context API in React, beginner's guide to Kubernetes, Golang Minutes, my MLH Prep Fellowship experience, all about LFX Mentorship Program, GitHub Campus Experts program and many more. If you're interested in such content, do follow me dev.to/ciphertron. You can find more about me at pritishsamal.tech.

Relevant Links:

Beauty of Poetry ✨

Pritish Samal — Wed, 30 Jun 2021 11:15:19 +0000

Disclaimer: Here, in this article, the word "Poetry" is not referred to as something related to English Literature, history, religion, or stuff. :)

First things first, I'm on a Ubuntu 20.04 LTS operating system. Few things might be different for you according to your operating system. So, without any further ado, lets get started🚀

List Of Contents:

PS: If you directly want to get into what's Poetry and its functions, feel free to skip the Introduction part.

Introduction
Why Poetry?
What's Poetry?
Download & Install
Configure Poetry
Basic Usage of Poetry
Conclusion

# Introduction

I'm primarily a JavaScript, React developer where the dependency management(adding, removing, upgrading) is taken care of by npm or yarn. I always wanted to try out a Python web framework & that is when I came across Flask which is a lightweight framework to develop web applications, RESTful APIs and much more. In this article, I'll be using some analogies in JavaScript to describe how things work in Python.

Normally, npm install <dependency> will install a dependency in that project itself by generating a node_modules folder and if we add a -g or --global flag, it will install the dependency globally. But things are a little different in Python. In Python, we have to create something called a virtual environment which is essentially a Python environment such that the Python interpreter, libraries and scripts installed into it are isolated from other virtual environments or those libraries installed in a System Python i.e., one which is installed as part of your operating system.

Lets take an instance for example: Suppose you're working on a project with five other developers and lets say you have flask version 1.1.2 version installed globally whereas the project requires flask version 1.1.3. That is where conflicts might or might not arise due to different flask versions. To be on the safer side, we use virtual environments.

# Why Poetry?

Before coming on to what Poetry actually is, let me explain its use cases and how it makes our life easier. The two major issues that we face using python are:

1. Manually creating and managing virtual environments

In python, we can use many ways to make virtual environments with venv being its standard library. Few other libraries include virtualenv, and conda. For beginners, it is recommended to use the pip & virtualenv combo.
To create a virtual environment:

With venv:

$ python3 -m venv .venv

With virtualenv:

$ virtualenv venv

To activate a virtual environment:

$ .venv/Scripts/Activate.ps1

Voila! our virtual environment is activated. Now, we can install any dependency using pip install. But if you see the process, it is very much time consuming.

2. `requirements.txt` file is too primitive to deal with!

Generally, we can export requirements.txt which defines all the dependencies we've installed using pip. We can export it by:

$ pip freeze > requirements.txt

What we get from it is a plain text file with all the dependencies as well as their versions listed.

bcrypt==3.2.0
dnspython==2.1.0
email-validator==1.1.2
Flask==1.1.2
Flask-Bcrypt==0.7.1
Flask-Login==0.5.0
Flask-SQLAlchemy==2.5.1
Flask-WTF==0.14.3
gunicorn==20.1.0
itsdangerous==1.1.0
Jinja2==2.11.3
MarkupSafe==1.1.1
Pillow==8.2.0
pycparser==2.20
SQLAlchemy==1.4.7
Werkzeug==1.0.1
WTForms==2.3.3
yapf==0.31.0

But again, here we have to lock requirements.txt everytime we add or remove a dependency. Also, it becomes difficult to audit all dependencies & bring them up-to date when needed.

Thus, we need something which can isolate the project as well as it can manage our dependencies & their versions as well as lock everything that gets installed just like we have a package.json in Javascript which is like a manifest for your project, a place where npm or yarn stores all the dependencies with their version & package-lock.json or yarn.lock if you're using npm or yarn respectively which keeps track of the exact version of every package that is installed so that a product is 100% reproducible in the same way even if packages are updated by the maintainers.

This is where Poetry comes to rescue and saves us from the above mentioned problems. Let us learn more about what is Poetry in the next section.

# What's Poetry?

So, Poetry is a tool for dependency management and packaging in Python. According to their official documentation, it allows us to declare the libraries our project depends on and it will manage (add/remove/update) them for us. IMO, Poetry is by far best dependency as well as virtual environment management tool I've come across in python programming. Initialising a Poetry project produces two main files, namely pyproject.toml which works like a package.json & poetry.lock that works like package-lock.json or yarn.lock. In other words, we can say that Poetry resembles npm/yarn. Bear with me, I won't give much analogies from now onwards XD. Now, let's see how we can download & use Poetry,

# Download & Install

Poetry has a well documented set of instructions on how to install it and the best thing is that almost every operating systems (eg: Windows, Linux, MacOS) supports Poetry. Poetry is also available on PyPi but it is not recommended to install using pip because it will also install Poetry’s dependencies which might cause conflicts with other packages.

Prerequisite: If you don't have curl installed, you can do so by:

$ sudo apt update
$ sudo apt install curl

The installation guidelines as stated in the official documentation are listed below!

# osx / linux / bashonwindows install instructions
$ curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python -

# windows powershell install instructions
$ (Invoke-WebRequest -Uri https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py -UseBasicParsing).Content | python -

# Installing with pip
$ pip install --user poetry

Voila! Poetry will be now installed in your system. To confirm it, you can:

$ poetry --version
Poetry version 1.1.6

# Configure Poetry

Before we get started with Poetry, we have to make sure of some configurations. You can always type poetry --help and it'll display the set of commands & arguments and how to use them else refer to their configuration documentation. I've listed below the required configurations. Make sure you do the same.

# To list all the configurations
$ poetry config --list
cache-dir = "/home/john/.cache/pypoetry"
experimental.new-installer = true
installer.parallel = true
virtualenvs.create = true
virtualenvs.in-project = true
virtualenvs.path = "{cache-dir}/virtualenvs"  # /home/john/.cache/pypoetry/virtualenvs

To change or modify any configuration for instance, virtualenvs.create, you can:

$ poetry config virtualenvs.create false

Else, if you want to modify the configuration only for a specific project, Poetry provides a --local option to the config command to do the same.

$ poetry config virtualenvs.create false --local

If you want to remove a configuration, you can:

$ poetry config virtualenvs.path --unset

# Basic Usage of Poetry

Now we are all set to get started with Poetry. Yayy!!
So, we will be initialising a Poetry project in the Desktop directory. To initialise an empty project, we can type:

~/Desktop$ poetry new poetry-kickstart
Created package poetry_kickstart in poetry-kickstart

A new package named poetry-kickstart will now be created in your Desktop. We are going to modify the structure a little bit.

We will be having the following contents inside the poetry-kickstart package.

poetry-kickstart
├── pyproject.toml
├── README.rst
├── poetry-kickstart.py
└── tests
    ├── __init__.py
    └── test_poetry_demo.py

Then, we will spawn a shell using poetry shell command and install flask.

~/Desktop/poetry-kickstart$ poetry shell
Spawning shell within Desktop/poetry-kickstart/.venv
. Desktop/poetry-kickstart/.venv/bin/activate

(.venv) ~/Desktop/poetry-kickstart$ poetry add flask
Using version ^2.0.1 for Flask

Updating dependencies
Resolving dependencies... (0.8s)

Writing lock file

Package operations: 6 installs, 0 updates, 0 removals

  • Installing markupsafe (2.0.1)
  • Installing click (8.0.1)
  • Installing itsdangerous (2.0.1)
  • Installing jinja2 (3.0.1)
  • Installing werkzeug (2.0.1)
  • Installing flask (2.0.1)

Spawning a shell will make a virtual environment and automatically activate it. Thus, the contents inside the poetry-kickstart package will be:

poetry-kickstart
├── .venv
├── poetry.lock
├── pyproject.toml
├── README.rst
├── poetry-kickstart.py
└── tests
    ├── __init__.py
    └── test_poetry_demo.py

Now, we are inside a virtual environment with flask installed. Let us make a simple route returning "Hello World!" in poetry-kickstart.py.

from flask import Flask

app = Flask(__name__)


@app.route('/')
def index():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run(debug=True)

We have a simple route. Now, let's check if it's working or not. But before that, do ensure if your python interpreter is pointing towards the one in the virtual environment.

To check the sample API,

(.venv) $ poetry run python -m poetry-kickstart
 * Serving Flask app 'poetry-kickstart' (lazy loading)
 * Environment: production
   WARNING: This is a development server. Do not use it in a production deployment.
   Use a production WSGI server instead.
 * Debug mode: on
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 117-620-034

Hurray!! We now have our flask app up and running. Cheers!

Again, you can click ctrl+c to kill the process & then type exit to exit from the virtual environment.

# Conclusion

This article demonstrates only the basic usage of Poetry. However, there are ton other things that you can do using Poetry. I would prefer their official documentation anytime since it is well structured. But, this is not the end. In my next article, I'll be demonstrating how you can run tests using Poetry, & how to deploy a poetry project to Heroku. Heroku is the go-to service for many developers because it requires less configuration and has quick deployment. But Heroku doesn't have a standard buildpack for Poetry. Thus, we will be using another open-source buildpack for Poetry and trust me, it works just fine. Last but not the least, I would like to thank The Open Bio-informatics Foundation for giving me this opportunity & also my mentors @João Paulo Tiz & @Yo Yehudi for their constant support and guidance.