AUTHOR

Karol Woźniak

Using first class citizen functions as a way to more testable and better abstracted code.

Technique: hiding behind wrapped functions

Go error handling and how to define your own errors.

Technique: complex errors with error interface

What material, that might theoretically be related, won't be covered here.

What won't be in here?

Define a high level plan of what we are going to do and how. Check where the necessary parts are.

The plan

Similarly to reading, here are ways of writing to files instead. This time showcasing `io.Writer` interface, which is just as prevalent and useful as its sibling.

Writing to file

After reading contents of a file we are always left with byte arrays. Find out how to convert them into more usable types.

Converting strings to other primitives

How to check if a file exists in the filesystem. And why this check should not be used in majority of cases.

Finding a file

Learn how to iterate over directories in the filesystem and manipulate Go structures representing files.

Listing a directory

See different ways of reading files in Go. Learn about one of the most used interface of the Go standard library that, among other things, allows reading all sorts of input the same way as files.

Reading a file

High level summary of what will be covered, and how.

What are we going to do?

See how to define platform specific code and how to compile it for different target platforms.

Technique: build tags and cross-compilation

First project, a battery monitor, that will showcase a library similar (in concept) to what will be implemented later in the course. Also introduces more Go concepts, like dependency handling.

Goal showcase: battery usage

See what are prerequisites for successfully going through the course.

What will be needed?

Learn how Go projects are structured in general, as well as specific conventions for CLI tools.

Project structure

Introduction

Goal showcase and abstract parts of the project

Internals: Linux (file handling)

We will create a cross-platform command line utility for adjusting CPU frequencies and seeing how it affects battery usage.

It will be written in Go, which gives us good base with its' easily cross-compilation and stdlib APIs for different systems.

Still, details about all specific instructions are very scattered around and often hard to find, we'll try to uncover and consolidate them in here.

We will cover the entire creation process, from empty directory, to a finished tool.

We will go through the abstract parts that help designing cross-platform utils and make writing them easier, as well as all the platform specific necessities.
We'll look into different problems for every platform, including discovering proper interfaces, ways of interacting with them, error handling, etc.

The newline Guide to Building a Cross-Platform Utility in Go

We will create a cross-platform command line utility for adjusting CPU frequencies and seeing how it affects battery usage.

How to interface routines native to (almost) all Operating Systems supported by Go

How to handle and pass errors in a robust manner

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Masterclasses

Tutorials

Fullstack React with TypeScript