Go is expressive, concise, clean, and efficient. The language is statically typed with syntax similar to the C programming language.

Go was designed to run on multiple cores, and it was built to support concurrency. You can use Go to write applications that need to be performant and can run on a modern scale, like distributed systems with hundreds of thousands of servers on a cloud platform.

In this article, you'll learn how to write a basic CLI (Command Line Interface) application in Go. First, we'll briefly go over some main Go characteristics. Then we'll talk about the basic structure of a Go file. Lastly, you'll learn how to set up Go locally to write code.

Table of Contents

• Characteristics of Go
• How to Set Up Go Locally on Windows
• How to Get Started With Writing Code in Go
• What Are Packages in Go?
• What Are Modules in Go?
• What is the Go Command?
• What are Variables in Go?
• Naming Conventions in Go
• Differences Between the var Keyword and const Keywords
• Data Types in Go
• Operators in Go
• Wrapping Up

Characteristics of Go

Go is used as server-side and backend language

Go is commonly used to build server-side applications and backend services. This includes a wide range of applications such as microservices, web applications, API servers, and database services.

Go is designed with concurrency in mind, making it well-suited for building scalable and efficient server-side applications. Its simplicity, performance, and built-in support for concurrency make it a favorable choice for backend development.

Go uses simple syntax

Go has a straightforward and minimalistic syntax. It's intentionally designed to be easy to learn, read, and write code. Go encourages a clean and concise coding style.

A simple syntax reduces the load on developers, making it easier for them to understand and maintain code.

Go has fast build time, startup, and run time

Go's compilation process is quick, allowing developers to see the results of their code changes rapidly.

Also, Go programs generally start up quickly and have efficient runtime performance.

Go is resource efficient

Go programs typically require fewer system resources like CPU and RAM to run compared to some other languages. This is partly due to Go's statically compiled nature and efficient runtime.

Lower resource requirements make Go well-suited for building applications that need to be lightweight and efficient, particularly in environments where resources are limited. It contributes to better scalability and cost-effectiveness in server deployments.

Go is a compiled language

Go is a compiled language, meaning that source code is translated into machine code or an intermediate form before execution. This is in contrast to interpreted languages where code is executed directly by an interpreter.

Compilation offers advantages such as faster execution, as the code is pre-processed into a form that the machine can directly execute. It also ensures that potential errors are caught during the compilation phase, reducing runtime errors and improving overall program reliability.

How to Set Up Go Locally on Windows

Install Go on your System

Before installing Go, open up your command prompt, type “go” and hit enter. This is to confirm whether you have Go installed on your PC or not.

When you enter “go” and hit enter, you should get a message that says “'go' is not recognized as an internal or external command, operable program or batch file”.

Command Prompt Interface

This means you need to install it.

To install Go on your Windows computer, you have to first download Golang from the official website. It supports all main operating systems. Install the one that corresponds with your operating system.

Golang Official Website Interface

Next, double-click on the downloaded installer to install Go. Follow the prompts accordingly and Go will be installed.

Go installer Interface

Golang Installer Interface

After installing Go, return to the command line and type "go" again. This time, you should see numerous commands in Go.

Command prompt to show Go installation Completion

Now you'll need to set up your Go workspace by configuring environment variables. Go to your desktop and create a folder called "go-projects" (you can call it whatever you like). This is the folder where your Go projects will be saved.

First, search for “env” on the Windows searchbar and click on “Edit the system environment variables”.

Search for Edit the system environment variables

Click on the Environment variables button, as you can see below:

Click on the Environment variables button

You will have to change the value of the GOPATH variable to the folder you created earlier.

Make sure “GOPATH” is selected, then click “Edit…”.

Select GOPATH

Click on “Browse Directory”

Click on “Browse Directory”

Select the folder you created earlier (“go-projects”, or whatever you named yours) and click "OK".

Select the folder you created earlier

Click "OK" again.

Click OK

Click "OK" again.

Click "OK" one more time.

Voilà! You are done setting the GOPATH variable.

Set Up an IDE

Install an IDE (Integrated Development Environment) of your choice if you don't have one installed already.

An IDE is an editor for writing Code, like Visual Studio Code, Sublime, and so on.
Here is the link to download Visual Studio Code.

Install the Go Extension in VS Code

Next, you'll want to install the Go extension on Visual Studio Code. It provides features like code completion, code navigation, syntax highlighting, and snippet suggestions.

Go extension

How to Get Started Writing Code in Go

Open up the “go-projects” folder (or whatever you named it) with VS Code (or your code editor of choice). Create a folder called "hello-world" (this is optional) and create a file named main.go. You can name the file whatever you want.

Example Go code

Here's the output:

Output

You might be wondering what the code snippet above is doing 🤔. I'll explain in detail below.

Let's go 🚀🚀

• Package Declaration (package main): Every Go program starts with a package declaration, indicating to which package the file belongs. The main package is a special one, as it's the entry point for executable programs.
• Import Statement (import "fmt"): In Go, you import packages to use their functions and features. Here, we import the fmt package, which stands for "format" and is used for input and output operations.
• Main Function (func main()): Every Go executable program must have a main function. When you run your program, it's the first function that gets executed.
• Print Statement (fmt.Println("Hello World")): This line uses the Println function from the fmt package to print the text "Hello World" to the console. The Println function is used for printing with a newline character at the end, so the next output appears on a new line.

What are Packages in Go?

Packages are Go's way of organizing code. A package is a collection of source files. It should be narrowly focused and perform a single thing like argument passing, handling HTTP request, and so on.

Programs start running in package main. This program uses the packages with import paths “fmt”.

In Go, import path is a unique identifier for a package. It specifies the location of a package in the Go module system. The import path is used in the import statement to bring in external packages or dependencies into your Go code.

Here's a breakdown of the import path:

Standard Library Packages: For packages that are part of the Go standard library, you can directly use their name in the import statement.

For example:

import "fmt"

Local Packages: If you are working on a project with multiple files or packages, you can use relative import paths to import local packages.

For example, if you have a package named "mypackage" in the same directory as your main file, you can import it like this:

import "./mypackage"

Remote Packages (from version control repositories): Go supports importing packages directly from version control repositories like GitHub. The import path includes the repository URL.

For example:

import "github.com/example/mypackage"

Remote Packages (from custom servers): You can also import packages from custom servers by specifying the full URL.

For instance:

import "myserver.com/mypackage"

Vendored Packages: If you have a vendored package (a copy of a package kept within your project's repository), you can import it using a path relative to your project root.

For example:

import "myproject/vendor/mypackage"

Packages from the Go Module Cache: With the introduction of Go modules, when using modules, Go automatically caches the dependencies in a module cache. Import paths can refer to packages in the cache.

For example:

import "example.com/mypackage"

package main is always written as the top of your code as shown below

Here's an example below:

package main

import "fmt"

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

What Are Modules in Go?

A module is a collection of packages. It contains information about your project like dependencies, the Go version, and package info. All Go projects have a go.mod file.

Here is the command for initializing the go.mod file from the terminal:

go mod init <module path>

module path is also the import path.

How to initialize go.mod from the terminal

The picture above shows how modules are created right from the terminal. And this is the generated go.mod file:

Screenshot of the go.mod content

What is the Go Command?

The "Go command" refers to the go command-line tool in the Go programming language. It's a versatile tool that you can use to perform various tasks related to Go development such as compiling, testing, installing packages, managing dependencies, and more.

What does the go command do?

The go command automates many aspects of the Go development workflow. It handles tasks like compiling, testing, dependency management, and more, making it easy for developers to build, test, and maintain Go projects. It also facilitates the adoption of Go modules, a dependency management system introduced to improve versioning and dependency tracking in Go projects.

You use the go command in various scenarios during the development lifecycle of a Go project:

• Running Code: go run compiles and executes a Go program.
• Building Executables: go build compiles Go source code into an executable binary.
• Testing Code: go test runs tests in the current package and go test ./... runs tests in all subdirectories.
• Package Management (with Modules): go mod init initializes a new module (Go project) and creates a go.mod file. go get downloads and installs packages and dependencies. go mod tidy removes any dependencies that are no longer necessary. And go list -m all lists all dependencies for the current module.
• Documentation: go doc shows documentation for a package or symbol.
• Dependency Analysis: go list lists information about available packages. go list -m -versions <module> lists all known versions of a module.
• Code Formatting: go fmt formats Go source code.
• Environment: go env prints Go environment information.

What are Variables in Go?

Variables provide a way to store and access data in your program.

To create a variable, you can use single creation, compound creation, block creation, or the create and assign method. Let's go through examples of each of them now.

Single Creation

Single Creation is used when you need to create and initialize a single variable.

Example of using the single creation method:

package main

import "fmt"

func main() {
    var singleVariable int
    singleVariable = 10
    fmt.Println(singleVariable)
}

In this example, singleVariable is declared and later assigned the value 10.

Compound Creation

We can also create multiple variables at the same time. This way of creating variables makes it simple to assign multiple different data types to multiple variables.

package main

import "fmt"

func main() {
    var a, b, c  = 1, 2, "Coders"
    fmt.Println(a, b, c)
}

Block Creation

Block creation is used when you want to limit the scope of the variables to a specific block. You declare and initialize multiple variables within a code block {}.

package main

import "fmt"

func main() {
    {
        var blockVariable int
        blockVariable = 5
        fmt.Println(blockVariable)
    }

    // blockVariable is not accessible here
}

In this example, blockVar1 is only accessible within the block it is declared.

Create and Assign

You declare and initialize a variable in a single line using the := shorthand, like this:

package main

import "fmt"

func main() {
    createAndAssignVar := 42
    fmt.Println(createAndAssignVar)
}

In this example, createAndAssignVar is declared and initialized in a single line using the := shorthand.

Naming Conventions in Go

Go variable naming uses camel case. For instance:

const myVariable = 20

Whenever you are coming up with a variable name, it's a good practice to give it a descriptive name, for example conferenceName := "Linux" instead of conference := "Linux".

Difference Between var Keyword and const Keyword in Go

There are two ways to declare variables in Go: var and const. For those of you who know JavaScript, this may sound familiar.

• var is used to declare variables, and their values can be changed after the declaration.
• const is used to declare constants, and their values cannot be changed after the declaration.

Here's an example of using both var and const to declare variables:

package main

import "fmt"

func main() {
    // Using var
    var variable1 int = 5
    variable1 = 10  // Valid, the value of variable1 can be changed

    // Using const
    const constant1 int = 5
    // constant1 = 10  // Invalid, constants cannot be reassigned

    fmt.Println(variable1, constant1)
}

In the example above, variable1 can be reassigned to a new value, while constant1 cannot be reassigned due to its const nature.

Data Types in Go

There are different data types in Golang, which include number, string, boolean, array, pointer, struct, map, and interface.

Let's see examples of each of these so you can learn how they work.

• Number ( int, float64) is used for representing numerical values (whole numbers or decimals). Here's an example:

package main

import "fmt"

func main() {
    // Integers
    var integerVar int = 42
    fmt.Println(integerVar)

    // Floating-point numbers
    var floatVar float64 = 3.14
    fmt.Println(floatVar)
}

In this example, integerVar is an integer variable, and floatVar is a floating-point variable.

• String is used for representing sequences of characters (text). Here's an example:

package main

import "fmt"

func main() {
    var stringVar string = "Hello, Golang!"
    fmt.Println(stringVar)
}

In this example, stringVar is a string variable holding the text "Hello, Golang!".

• Boolean is used for representing logical values (true or false). Here's an example:

package main
import "fmt"
func main() {
    var boolVar bool = true
    fmt.Println(boolVar)
}

In this example, boolVar is a boolean variable set to true.

• Array is used for storing fixed-size sequences of elements of the same type. Here's an example

package main

import "fmt"

func main() {
    var intArray [3]int = [3]int{1, 2, 3}
    fmt.Println(intArray)
}

In this example, intArray is an array of integers with a fixed size of 3.

• Pointer is used for storing the memory address of a variable. Here's an example:

package main

import "fmt"

func main() {
    var originalVar int = 42
    var pointerVar *int = &originalVar
    fmt.Println(*pointerVar) // Dereferencing the pointer
}

In this example, pointerVar is a pointer to the memory address of originalVar.

• Structure (Struct) is used for grouping together variables of different types under a single name. Here's an example:

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

func main() {
    var personVar Person = Person{Name: "Alice", Age: 30}
    fmt.Println(personVar)
}

In this example, personVar is a struct representing a person with a name and an age

• Map is used for representing key-value pairs. Here's an example:

package main

import "fmt"

func main() {
    var myMap map[string]int = map[string]int{"one": 1, "two": 2, "three": 3}
    fmt.Println(myMap)
}

In this example, myMap is a map with string keys and integer values.

• Interface is used for defining a set of method signatures without specifying the implementation. Here's an example:

package main

import "fmt"

type Shape interface {
    Area() float64
}

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return 3.14 * c.Radius * c.Radius
}

func main() {
    var myShape Shape = Circle{Radius: 5.0}
    fmt.Println(myShape.Area())
}

In this example, Shape is an interface, and Circle is a type implementing the Area method of the Shape interface.

Operators in Go

There are 3 main types of operators in Go: arithmetic operators, logical operators, and relational operators

Now let's go through each category of operators and see how they work, with examples.

Arithmetic Operators

Arithmetic operators are used when you need to perform basic mathematical operations in your code. They include the following:

• Addition (+) is used for adding numerical values together. Here's an example:

package main

import "fmt"

func main (){    
    a := 5    
    b := 3    
    result := a + b  
    // result is 8
fmt.Println(result)
}

How to use the Addition operator in Go

• Subtraction (-) is used for finding the difference between two numerical values. Here's an example:

package main

import "fmt"

func main (){
    a := 8
    b := 3
    result := a - b
    // result is 5
fmt.Println(result)

How to use the Subtraction operator

• Multiplication (*) is used for calculating the product of two numerical values. Here's an example:

package main

import "fmt"

func main (){ 
    a := 4
    b := 6
    result := a * b
// result is 24
fmt.Println(result)

How to use the Multiplication operator

• Division (/) is used for calculating the quotient of two numerical values. Here's an example:

package main

import "fmt"

func main(){
    a := 10
    b := 2
    result := a / b
// result is 5
fmt.Println(result)
}

How to use the division operator

• Modulus (%) returns the remainder of the division of the left operand by the right operand. Here's an example:

package main

import "fmt"

func main (){
    a := 15
    b := 7
    result := a % b
fmt.Println(result)
}

How to use the Modulus operator

Relational Operators

Relational operators are used for comparing values and making decisions based on the comparison results. It includes the following:

• Greater Than (>) is used for comparisons where the left operand is greater than the right operand. Here's an example

package main

import "fmt"

func main (){
    x := 8
    y := 5
    isGreater := x > y
// isGreater is true
fmt.Println(isGreater)
}

How to use the Greater than sign

• Less Than (<) is used for comparisons where the left operand is less than the right operand. Here's an example:

package main

import "fmt"

func main (){
    p := 12
    q := 18
    isLess := p < q
    // isLess is true
fmt.Println(isLess)

]

How to use the less than sign

• Greater Than or equal (>=) checks if the left operand is greater than or equal to the right operand. Here's an example:

package main

import "fmt"

func main (){
    m := 5
    n := 5
    isGreaterOrEqual := m >= n
    // isGreaterOrEqual is true
fmt.Println(isGreaterOrEqual)
}

How to use the greater than or equal sign

• Less Than or Equal to (<=) checks if the left operand is less than or equal to the right operand.

package main

import "fmt"

func main (){
    r := 10
    s := 15
    isLessOrEqual := r <= s
    // isLessOrEqual is true
fmt.Println(isLessOrEqual)
}

How to use the less than or equal sign

• Equivalence (==) checks if the left operand is equal to the right operand. You use this for equality comparisons. Here's an example:

package main

import "fmt"

func main (){
    age := 25
    checkAge := age == 25
    // checkAge is true
fmt.Println(checkAge)
}

How to use the Equivalence sign

• Not Equal (!=) checks if the two operands are not equal. Here's an example:

package main

import "fmt"

func main (){
    score1 := 80
    passingScore := score1 != 75
    // passingScore is true
fmt.Println(passingScore)
}

How to use the Not Equal

Logical Operators

You use logical operators when you need to implement boolean logic and make decisions based on multiple conditions.

• Logical AND (&&): This operator returns true only if both operands are true, otherwise, it returns false. Here's an example:

package main

import "fmt"

func main (){
    x := true
    y := false
    result := x && y
    // result is false
fmt.Println(result)
}

Example of Logical AND

• Logical OR (||): This operator returns true if at least one of the operands is true, otherwise, it returns false. Here's an example:

package main

import "fmt"

func main (){
    a := true
    b := false
    result := a || b
// result is true
fmt.Println(result)
}

Example of logical OR

• Logical NOT (!): This operator is a unary operator, meaning it operates on only one operand. It negates the value of the operand, turning true into false and false into true. Here's an example:

package main

import "fmt"

func main (){
    isSunny := true
    isRainy := !isSunny
    // isRainy is false
fmt.Println(isRainy)
}

Logical NOT example

Wrapping Up

In this article, you learned about the Go programming language and why it is useful to know. You also learned about the characteristics of Go and how to set up Go locally on Windows.

Then you learned how to actually get started writing code in Go, and you saw examples of many of Go's features in action. We also talked about what packages are, how modules work, and more.

Go is well worth your time. Now, go study some more Go.

Happy Coding!

In this article, you'll learn what accessibility means, and why it's important to make accessibility a part of your regular workflow. I'll also give you practical tips with examples to make your websites more accessible.

Let's explore the key parts of web accessibility together and help you make a website that includes everyone.

What is Web Accessibility?

Web accessibility refers to the practice of designing and developing websites, applications, and digital content in a way that ensures people with disabilities can perceive, understand, navigate, and interact with them effectively.

Principles of Web Accessibility

To effectively enhance the accessibility of your websites and apps, you'll want to follow these fundamental principles outlined by the Web Content Accessibility Guidelines (WCAG):

Is it Perceivable?

Content should be displayed in a manner that all users can understand, regardless of their sensory abilities. Here are some ways you can make your content more perceivable:

First, you can provide captions for audio and video materials. Adding captions to your website or application allows those with hearing disabilities to understand the information being shared, and make the content more accessible to everyone.

You can see an example of adding captions to a video in the image below:

Image of a video illustrating the use of captions.

Next, make sure you use proper color contrast for text and background elements.

Colors are an important part of a website, and we can describe them in terms of hue, lightness, and saturation.

There are several categories of colors which include warm colors, cool colors, and neutral colors

Warm Colors: Warm colors include red, orange, and yellow, and variations of
those three colors. These are the colors of fire, fall leaves, sunsets, and sunrises, and are generally energizing, passionate, and positive.

Cool Colors: Cool colors include green, blue, and purple, are often more
subdued than warm colors. They are the colors of night, water, of nature, and are usually calming, relaxing, and somewhat reserved.

Neutral Colors: Neutral colors often serve as the backdrop in design. They’re
commonly combined with brighter accent colors. But they can also be used on their own in designs and can create very sophisticated layouts. Neutral colors include black, white, gray, cream, and beige.

Examples of colors that will make good contrast are white and blue, purple and white, yellow and white, light purple and black, green and white, black and white, and so on – basically any colors that are different enough from each other to create that contrast.

Examples of colors that will make a bad contrast are gray and white, brown and orange, red and purple, and so on.

Here is an example that shows good color contrast that's easy to read:

Image illustrating good contrast using a dark blue background with white text

And here's an image with poor color contrast that's hard to read:

Image Illustrating bad contrast using a white background with light grey text

Also, it's a good idea to include descriptive alternative text (alt text) for images, explaining what they depict and their purpose.

So for example, when you want to add an image to your website, you can add alt text to it explaining what it depicts.

Here is a markup description of how to add alt text to an image:

    <img src="Dog.png" alt="Image of a dog">

Here is an example that shows an image of two (2) dogs:

Image of two dogs

And here's an example of an image that illustrates the use of alt text:

Image of dog with alt text displayed

You should also describe your icon buttons.

Icons can be easily understood most of the time. It's widely recognized that an x symbol, like this ❌, typically closes a window, a check mark ✅ signifies completion, a forward arrow ▶ signifies send (or play), and a plus sign ➕ represents addition.

But this is clear only for individuals with visual capabilities. For people who aren't able to see the buttons, you'll need to provide a description so they know what that button does.

Let's take a look at this HTML and CSS code that shows how to make buttons access:

<!DOCTYPE html>

Here's the result of the code implemented above:

Is it Operable?

Users should be able to navigate and interact with the interface quickly. Consider the following factors:

First, make sure you use clear and consistent headings.

This is what clear and consistent headings look like:

I am a Title

I am a Subtitle

This is heading 3

This is Heading 4

This is Heading 5

This is heading 6

As you can see, these headings go from largest to smallest in order. We have an H1 heading first, followed by H2, H3, and so on.

Here are some headings that don't follow the proper hierarchy:

This is heading 6

This is Heading 5

This is Heading 4

This is heading 3

I am a Subtitle

I am a Title

In this example, the headings go in reverse order, starting from H6 and moving up through H5, H4, and so on.

Just remember to use proper heading hierarchy – don't use an H2 and then jump straight to H4 for a subheading, for example, as this is visually jarring and doesn't convey the proper importance or hierarchy of the text.

Here's why heading hierarchy is important:

• A clear heading hierarchy helps readers easily navigate and understand the content of a document.
• Heading hierarchy is crucial for accessibility, as it helps screen readers and assistive technologies interpret the structure of the content. This is important for individuals with visual impairments who rely on such tools to access information.
• A well-organized heading hierarchy implement a logical flow of information, ensuring that topics are presented in a coherent order.

Also, refrain from using elements that might trigger physical discomfort, like bright flashing lights.

And make sure you think about keyboard accessibility so users can navigate and communicate using the keyboard, and not exclusively using a mouse.

Is it Understandable?

Content and functionality should be presented clearly and understandably. Consider the following factors:

• Organize content using headings, subheadings, and bullet points to enhance readability.
• Provide instructions and error messages that are easy to understand.
• Use simple and concise language, avoid complex terms.

Is it Robust?

Websites should be built using robust and widely supported technologies to enable compatibility across devices and assistive technologies.

You'll want to maximize compatibility with current and future user agents, including assistive technologies.

Here are some of the ways you can maximize compatibility with current and future agents, including assistive tools:

• Use HTML5 semantic elements like <header>, <nav>, <main>, and <footer> to enhance the document's structure.
• Ensure that your JavaScript code is efficient and doesn't block the rendering process.
• Utilize browser developer tools and online testing services to identify and fix compatibility issues.
• Conduct usability testing with a diverse group of users, including those who rely on assistive technologies, to gather feedback and make improvements.
• Optimize your website for fast loading times and low data usage using techniques like caching and tools like CDNs to reduce latency. This benefits both accessibility and user experience.
• Document your code and accessibility features for future maintainers.
• Test website compatibility across various browsers. Testing website compatibility involves ensuring that your website functions correctly and looks good on a variety of devices, browsers, and assistive technologies.

Here are the steps you can follow to test website compatibility effectively:

1. Device Testing: Test your website on various devices, such as desktop computers, laptops, tablets, and smartphones. This includes both iOS and Android devices.
2. Browser Testing: Check your website's performance and appearance on multiple browsers, including but not limited to Google Chrome, Mozilla Firefox, Apple Safari, and Microsoft Edge.
3. User Testing: Conduct usability testing with real users. Ask them to use your website on different devices and browsers and collect feedback on compatibility issues.
4. Performance Testing: Assess website loading times, and optimize for speed using tools like Google PageSpeed Insights, GTmetrix, or Lighthouse. Check for compatibility with slow internet connections.

Conclusion

Understanding web accessibility can enhance the user experience by creating a smooth and seamless interaction with websites and web applications.

Implementing these tips can improve the overall user-friendliness and navigability of your app. It'll help create a more enjoyable experience for all users, and will also allow people with disabilities to perceive, understand, navigate, and interact with your sites effectively.