In this, my sixth and probably final article on the Go programming language, I’m running through some smaller features which I didn’t go into detail on in earlier articles. We’ll look at extending and copying slices in more detail, type assertions, error handling, common string manipulations, basic file I/O, embedding files in binaries, and context objects.

In this, my fifth article on the Go programming language, I’m looking at the build and packaging process, and other tooling. I’ll start by looking at how code is structured into packages, and then look at the tools for building, packaging and testing.

In this, my fourth article on the Go programming language, I’m going to tackle the topic of concurrency. This concept of goroutines is one of the languages main selling points, so I’ll be interested to see how they work. We’ll also look at channels, which are used to communicate between goroutines.

In this, my third article on the Go programming language, I’m going to look at some of the additional features. Specifically we’ll look at closures and deferred actions, and also Go’s support for generics.

Having looked at the basic semantics of Go in the previous article, I’m continuing my exploration by looking at Go’s facilities for object orientation. This looks at structures and embedding in more detail, as well as methods and interfaces.

Having written a lot of articles about Python and Rust, I thought it was about time I took a look at another popular modern language, Go. In this article I’m kicking off by looking at the basic syntax and semantics as a foundation for looking at the more advanced features in future articles.

Rust is fairly new multi-paradigm system programming language that claims to offer both high performance and strong safety guarantees, particularly around concurrency and memory allocation. As I play with the language a little, I’m using this series of blog posts to discuss some of its more unique features as I come across them. This article looks at the more functional aspects of closures and iterators, as well as smart pointers.

Rust is fairly new multi-paradigm system programming language that claims to offer both high performance and strong safety guarantees, particularly around concurrency and memory allocation. As I play with the language a little, I’m using this series of blog posts to discuss some of its more unique features as I come across them. In this one I’m looking at Cargo, Rust’s build and packaging system.

Rust is fairly new multi-paradigm system programming language that claims to offer both high performance and strong safety guarantees, particularly around concurrency and memory allocation. As I play with the language a little, I’m using this series of blog posts to discuss some of its more unique features as I come across them. In this one I’m looking at how Rust’s trait system and how generics are implemented.

Rust is fairly new multi-paradigm system programming language that claims to offer both high performance and strong safety guarantees, particularly around concurrency and memory allocation. As I play with the language a little, I’m using this series of blog posts to discuss some of its more unique features as I come across them. This one discusses error handling and how to associate methods with data types.