Wire FAQs

Wire is a code generation tool that automates connecting components using dependency injection.

Cobra

Cobra is both a library for creating powerful modern CLI applications as well as a program to generate applications and command files.

Cobra is used in many Go projects such as [Kubernetes - https://kubernetes.io/], Hugo - https://gohugo.io/, and Github CLI - https://github.com/cli/cli to name a few. This list - https://github.com/spf13/cobra/blob/master/projects_using_cobra.md contains a more extensive list of projects using Cobra.

gofakeit

gofakeit is a Random data generator written in go.

It can fake Random data about File, Person, Generator, Auth, Address, Game, Beer, Car, Words, Foods, Misc, Colors, Internat, Date/Time, Payment, Company, Hacker, Hipster, App, Animal, Emoji, Language, Number, String, and custom Function, etc.

sync.Once

Once is an object that will perform exactly one action.

.Do calls the function f if and only if .Do is being called for the first time for this instance of Once. In other words, given var once Once if once.Do(f) is called multiple times, only the first call will invoke f,
even if f has a different value in each invocation.

A new instance of Once is required for each function to execute.

sync.WaitGroup

WaitGroup is used to wait for all the goroutines launched here to finish since the main function actually terminates before the goroutine gets a chance to execute by defatult.

WaitGroups essentially allow us to tackle this problem by blocking until any goroutines within that WaitGroup have successfully executed.

We first call .Add(n) on our WaitGroup to set the number n of goroutines we want to wait for, and subsequently, we call .Done() within any goroutine to signal the end of its’ execution.

Package sync provides basic synchronization primitives such as mutual exclusion locks. Other than the Once and WaitGroup types, most are intended for use by low-level library routines. Higher-level synchronization is better done via channels and communication.

log

Package log implements a simple logging package. It defines a type, Logger, with methods for formatting output. It also has a predefined ‘standard’ Logger accessible through helper functions Print[f|ln], Fatal[f|ln], and Panic[f|ln], which are easier to use than creating a Logger manually. That logger writes to standard error and prints the date and time of each logged message. Every log message is output on a separate line: if the message being printed does not end in a newline, the logger will add one. The Fatal functions call os.Exit(1) after writing the log message. The Panic functions call panic after writing the log message.

sync.Mutex & sync.RWMutex

Mutex and RWMutex are not associated with goroutines, but RWMutex is obviously more suitable for scenarios with more reads and less writes. For read performance only, RWMutex is higher than Mutex, because multiple reads of rwmutex can coexist.

Module

Go has included support for versioned modules as proposed here - https://golang.org/design/24301-versioned-go since 1.11. The initial prototype vgo was announced - https://research.swtch.com/vgo in February 2018. In July 2018, versioned modules landed in the main Go repository.

sync.Pool

A Pool is a set of temporary objects that may be individually saved and retrieved.

When there is an expensive object you have to create it frequently, it can be very beneficial to use sync.Pool.

Any item stored in the Pool may be removed automatically at any time without notification. If the Pool holds the only reference when this happens, the item might be deallocated.

A Pool is safe for use by multiple goroutines simultaneously.

Pool’s purpose is to cache allocated but unused items for later reuse, relieving pressure on the garbage collector. That is, it makes it easy to build efficient, thread-safe free lists. However, it is not suitable for all free lists.

premailer-rails

premailer-rails is a drop in solution for styling HTML emails with CSS without having to do the hard work yourself.

Styling emails is not just a matter of linking to a stylesheet. Most clients, especially web clients, ignore linked stylesheets or <style> tags in the HTML. The workaround is to write all the CSS rules in the style attribute of each tag inside your email. This is a rather tedious and hard to maintain approach.