Top 10 Golang Libraries And Packages

Top 10 Golang Libraries And Packages

Golang is a multi-purpose programming language and focused on simplicity so developers can build fast, reliable and easy to build apps with golang. Since its release, golang has become more stable and an easily adopted language with strong community support which is increasing day by day. It has a well detailed documentation that helps developers to easily adapt the language. Golang is used for huge projects that can incorporate into massive large scale distributed systems. It’s vibrant community creates and shares a large number of third-party libraries. Here we’ll see the top 10 golang libraries and packages that makes working with Go even easier.

You can also know- Why Golang Is Better Than Other Languages?

Top 10 Golang Libraries and Packages-

1. Gorm-

GORM is a developer-friendly tool to convert data between incompatible type systems. It is full-featured ORM, with associations, hooks and laundry list of features. All ORMS are designed to reduce code that should be re-written when switching between type systems. This tool delivers on this goal with its RAW SQL and SQL Builders, auto migration tools and extensible plugins for customization. Each feature comes with its own tests and this makes it easy for developers to try something out without completely borking the whole system. Gorm brings the world of object-relational mapping to Go with features as follows-

  • Callbacks (Before/After Create/Save/Update/Delete/Find)
  • Preloading (eager loading)
  • Associations (Has One, Has Many, Belongs To, Many To Many, Polymorphism)
  • SQL Builder
  • Transactions
  • Composite Primary Key
  • Auto Migrations
  • Logger
  • Extendable, write Plugins based on GORM callbacks

2. Goose-

When working with relational databases, managing the schema is one of the most important tasks. Modification in DB schema is considered a scary change in many organizations. This goose package lets you perform schema changes and even data migrations if required. You can goose up and goose down to go back and forth. Goose functions by versioning your schema and using migration files corresponding to each schema. The migration files can be SQL commands or Go commands. Let us see an example of SQL migration file which adds a new table-

-- +goose Up
CREATE TABLE person (
    id int NOT NULL,
    name text,
    age int,
    PRIMARY KEY(id)
);
-- +goose Down
DROP TABLE person;

The — +goose up and — +goose down comments describes goose what to do to upgrade or downgrade the schema.

3. Cli-

It is a simple and fast package to build command line apps for Go language. With this package, developers can quickly build their own expressive command line apps. As command line applications are so small, why shouldn’t developers be expressive? The team behind cli thinks that code for an API should totally be fun and playful. Specifically, cli makes it simple to create flags, bash completion routines, and even generated help text. Cli is fast, fun and playful when you code for an API. 

4. Kubernetes-

It is an open-source container for cloud-native applications. It is a distributed system implemented in Go. Kubernetes is flexible and comes with extendable and customizable plugins for use. From the developer’s point of view, Kubernetes is very flexible and you can extend and customize it via plugins.

Know the Kubernetes security practices at- Kubernetes Security Best Practices That You Must Know

5. Docker-

Docker is used for OS-level virtualization to deliver software in packages called containers. As it comes from DevOps family, many developers don’t know that Docker is implemented in Go. Generally you don’t use Docker in your code, but it is used in significant projects and becoming popular for Go projects.

6. NSQ-

It is a robust distributed queue and is primarily used for building a block for large scale distributed systems. NSQ is a simple TCP protocol which supports client libraries in any language. It is a combination of load-balanced and multicast style message routing. There are some dependencies which are easy to deploy with default configuration. There is no need for the client library to publish the HTTP interface for stats.

Features Of NSQ-

  • Low latency push based message delivery.
  • Support for distributed topologies with no SPOF.
  • Horizontally scalable( no brokers, seamlessly add more nodes to the cluster)
  • Combination of load-balanced and multicast style message routing.
  • Primarily in memory
  • Runtime discovery service for consumers to find producers
  • Excel at both streaming and job oriented workloads.
  • Data format agnostic
  • Transport layer security(TLS)
  • Simple TCP protocol supporting client libraries in any language.
  • Integrates with statsd for real-time instrumentation
  • HTTP interface for stats, admin actions, and producers (no client library needed to publish).
  • Robust cluster administration interface

7. Etcd-

It is a reliable distributed Key-Value store. The server is implemented in Go and Go client interacts with it though gRPC. Etcd focuses on-

  • Secure 
  • Fast 
  • Simple
  • Reliable

8. Ginkgo-

It is a Behaviour Driven Development (BDD)testing framework and lets you to write your tests in a syntax that lets you to write your tests in a syntax that looks like English language. This makes it simple for individuals with less or no technical knowledge to review the tests or outputs that match the requirements of business. It integrates with Go’s inbuilt testing package and is combined with Gomega. Example of Ginkgo + Gomega test-

Actual, err := foo()
Ω(err).Should(BeNil())
Ω(actual).ShouldNot(BeNil())
Ω(actual.result).Should(Equal(100))

9. Now-

This simple package provides a convenience wrapper for standard time packages and it eases the work with various date and time  constructs around the current time. For instance, you can get the beginning of the current minute or the end of the Sunday closest to the current time. Let us see how to use “now”:

package main
import (  
  "github.com/jinzhu/now"    
"fmt"
)
func main() 
{   
fmt.Println("All the beginnings...")   
 fmt.Println(now.BeginningOfMinute())   
 fmt.Println(now.BeginningOfHour())   
 fmt.Println(now.BeginningOfDay())    
fmt.Println(now.BeginningOfWeek())    
fmt.Println(now.BeginningOfMonth())   
fmt.Println(now.BeginningOfQuarter())    
fmt.Println(now.BeginningOfYear())
}
Output:
All the beginnings...
2017-06-04 16:59:00 -0700 PDT
2017-06-04 16:00:00 -0700 PDT
2017-06-04 00:00:00 -0700 PDT
2017-06-04 00:00:00 -0700 PDT
2017-06-01 00:00:00 -0700 PDT
2017-04-01 00:00:00 -0700 PDT
2016-12-31 23:00:00 -0800 PST

Also, you can parse times and add your own formats. The Now type embeds time.Time, so you can use all of time.Time methods directly on Now objects.

10. Vegeta-

This tool is used for HTTP load testing and is specially designed for testing HTTP services with a constant request rate. It works on analyzing the weak parts of program. Vegeta library work throughout to impress the overall performance. 

Final Words-

Golang is a great, simple and approachable language. It’s standard library is more comprehensive than any other languages. The above mentioned libraries and packages are there to help developers in app development. If you are thinking of using golang for your next project, consult with the Solace team. We are here to help you through our experts. You can hire golang developers of solace team for effective development. Connect with solace and get a free quote for go development. We will be happy to help you.

Related Post