Writer for The Startup, Level Up Coding & Data Driven Investor. BS in Computer Science & Applied Math. Writing about software and what I find interesting!

Because Medium’s bio is only 160 characters.

Image for post
Image for post

Hello, my name is Israel Miles — but I also go by Izzy! I started writing during college as an editor for The Colorado Engineer. I am currently a back-end software engineer, although I have a broad background in music, martial arts and math.

I’ve played classical piano since the age of six years old, and began training Brazilian Jiu-Jitsu over four years ago. …


Surprise — you already know how to implement a simple factory!

Image for post
Image for post

The Factory design pattern is a flexible and commonly used technique throughout software engineering. Take building a car for example. The basic definitions of a car are that it needs a frame, wheels, an engine etc. Cars can vary greatly from a sudan to a truck to having electric engines vs gasoline powered engines. The Factory pattern gives a contract to the general behavior of an object that can then have various concrete implementations.

In this article, we will study the Factory pattern in real world use cases, its UML diagram as well as its implementation in Go. …


Plus a few tips and tricks!

Image for post
Image for post

Go is well known for being a comprehensive and yet concise language. Its client interface maintains this paradigm by keeping possible commands simple yet powerful. This article can serve as a reference for common commands with the Go client in order to be a productive Go developer.

Commands in order to be covered:

  • The run, build, and install commands
  • Including build flags
  • How to build shared libraries
  • Detecting race conditions

Note: You can always use go help to gain further knowledge, although the output can be a bit too verbose at times. …


Add functionality to your program on the fly!

Image for post
Image for post
Image from Reddit

The Strategy pattern is easily one of my favorite design patterns. It allows you to add functionality to an object on the fly during program run time. A great example use case for this design pattern is video games such as one of my all time favorites — Old School Runescape. In this game you could add range to your attack by equipping a bow, change your damage type to magic with a staff and runes, or gain a special attack with a weapon such as the granite maul!

In this article, we will be examining real world examples, UML+Sequence diagram and implementation in Go for the Strategy pattern. The code will be based around being able to equip different weapons to a character in order to change their attack capabilities. …


The final product is oddly satisfying.

Image for post
Image for post

The Decorator pattern is an incredibly useful and flexible technique to create forward-thinking code. It allows you to add functionality to an object dynamically at run time instead of compile time. What this means is that you don’t have to manually write new code to extend an object’s feature set, you can simply use the decorator pattern to add behavior as you need it!

It also solves the issue of becoming restricted by an extensive sub-class architecture. Instead of getting lost in inheritance, the Decorator pattern uses lots of smaller classes (in Go’s case structs) in order to wrap functionality around other objects. …


A fundamental design pattern every software engineer needs to know.

Image for post
Image for post

The Observer design pattern is a fundamental tool for any capable software engineer. In one sentence, it consists of observers that pay close attention to subjects that change their state. In this tutorial, we will explore the use cases, UML diagram and implementation in my current favorite programming language — Go.

Note: The terminology can vary as an observer/subscriber or as a subject/topic/publisher. They are all the same, but I will be using observer and subjects in this article.

Use Cases

The real world examples of the observer design pattern are endless. …


Gain working knowledge on conditionals, loops and cases.

Image for post
Image for post

Go has a unique take on controlling the flow of your program. In fact, there are no combinations of do loops or while loops. That’s because Go exclusively uses for loops! However, this does not stop a developer from being able to create flexible conditionals to execute. If anything, it is a powerful simplification of the developer’s control flow toolbox.

The Powerful For Loop Experience

Let’s start with some examples of the variety of for loop controls in Go. The classic example of printing out some numbers looks like this:

package mainimport "fmt"func main() {
var i int
for i < 10 {
fmt.Println(i) …

Hit the ground running with examples and code!

Image for post
Image for post
From Pixabay

Go maintains its unique spin on flexibility with implicit and explicit definitions for functions, methods and interfaces. The main(){} function in the main package is where our code must always start.

While Go normally enforces the use of every package and variable, you can actually include empty functions that aren’t called and your code will still compile. Calling a function is also straightforward.

package mainimport "fmt"func main() {
fmt.Println("Hello World!")
helloFromFunc()
}
func emptyFunc() {}func helloFromFunc() {
fmt.Println("Hello from a function!")
}
/* Program Output:
Hello World!
Hello from a function! …

Examples on Arrays, slices, maps and structs!

Image for post
Image for post
From Wikipedia

Go has become known for its rich standard library and being described as “batteries included”. The language was actually developed by Google engineers who grew tired of C++. In fact, Go blends the desirable traits of multiple languages in order to bring a flexible and efficient choice for web services in particular. Some of its advantages include:

  • Readability — it can be compared to a typed version of Python
  • Concurrency — via the use of goroutines
  • Speed — compilation is fast and efficient
  • Libraries — easy to use and widely applicable
  • Memory — garbage collection is built in (no more dangling pointers!) …

Go’s unique spin on pointers, constants, and variables.

Image for post
Image for post

Go makes interesting tradeoffs between verbosity and convenience, and it’s useful to know the distinctions. You can often choose whether you want to be implicit or explicit in primitive typing, giving flexibility to the developer.

Variable declaration in Go is pretty straightforward. You can either explicitly define the variable using var or implicitly declare one with the “walrus” operator := as seen below.

// explicit declaration of an int
var i int
i = 10
// explicit declaration of a float
var f float32 = 3.14
// implicit declaration of a string
firstName :=…

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store