DEV Community: Jordan Taylor

Exploring Interfaces in Go: A Versatile Tool for Polymorphism

Jordan Taylor — Wed, 11 Oct 2023 21:10:32 +0000

Photo by Barn Images on Unsplash

Interfaces in Go are a versatile tool that can greatly enhance the way we design and build programs. In this blog post, we’ll explore how Go interfaces can be leveraged to create a flexible and extensible system for making various types of toys.

The World of Toy Creation

Imagine you are developing a toy factory application in Go. Your factory can produce a wide range of toys, from teddy bears to action figures and remote-controlled cars. Each toy has its unique features and functionalities, making it challenging to design a robust and maintainable system.

Enter Go Interfaces

Go interfaces provide an elegant solution to handle the diversity of toy types and their respective functionalities. Let’s dive into a practical example:

package main

import (
 "fmt"
)

// Toy represents the basic structure of a toy.
type Toy interface {
 Assemble() string
 Play() string
}

// TeddyBear is a type of toy that implements the Toy interface.
type TeddyBear struct {
 Name string
}

// Assemble method for a teddy bear.
func (tb TeddyBear) Assemble() string {
 return fmt.Sprintf("Assembling a %s teddy bear…", tb.Name)
}

// Play method for a teddy bear.
func (tb TeddyBear) Play() string {
 return fmt.Sprintf("Playing with the %s teddy bear!", tb.Name)
}

// ActionFigure is another type of toy that implements the Toy interface.
type ActionFigure struct {
 Name string
}

// Assemble method for an action figure.
func (af ActionFigure) Assemble() string {
 return fmt.Sprintf("Assembling an %s action figure…", af.Name)
}

// Play method for an action figure.
func (af ActionFigure) Play() string {
 return fmt.Sprintf("Playing with the %s action figure!", af.Name)
}

func main() {
 // Create a teddy bear.
 teddy := TeddyBear{Name: "Cuddly"}
// Create an action figure.
 actionFigure := ActionFigure{Name: "Superhero"}
// Create a slice of toys.
 toys := []Toy{teddy, actionFigure}
// Assemble and play with each toy.
 for _, toy := range toys {
 fmt.Println(toy.Assemble())
 fmt.Println(toy.Play())
 fmt.Println() // Add a newline for separation.
 }
}

In this example, we define a Toyinterface with two methods: Assemble() and Play(). We then create two toy types, TeddyBearand ActionFigure, each of which implements the Toyinterface by providing their implementations of Assemble()and Play(). If this wasn’t clear just to repeat myself; we use the names of the func’s as a contract to agree with; with the Interfacethat we are implementing. Moving forward any methods that use the same names are now in agreement with this Interface as to what they should now be implementing as a default. ie ActionFigure implements the Play() / Assemble() methods.

Benefits of Using Interfaces

Using interfaces in your toy creation program offers several advantages:

Flexibility : You can create new types of toys by simply implementing the Toy interface. This allows you to add new toys to your factory without modifying existing code.
Polymorphism : You can treat different types of toys uniformly, enabling you to assemble and play with them generically, as demonstrated in the loop in the main() function.
Maintainability : Interfaces promote clean code by enforcing a consistent structure for toys. This makes it easier to understand, extend, and maintain your toy factory application.
Testing : Interfaces make it straightforward to create mock toy implementations for testing purposes, ensuring the reliability of your code.

Conclusion

In the world of toy creation, Go interfaces are a valuable tool for building a flexible and extensible system. By defining a common interface for different types of toys, you can streamline the assembly and play processes, making your toy factory code more elegant and maintainable. As you continue to develop your toy factory, interfaces will empower you to add new and exciting toys to your lineup with ease. Happy toy crafting in Go!

Mastering Go For Loops: A Comprehensive Guide

Jordan Taylor — Wed, 11 Oct 2023 21:09:52 +0000

Introduction

For loops are commonly used to iterate over arrays and slices in Go using the range keyword. They can also be used to traverse the elements of a map.

An infinite loop can be created by omitting the initialization, condition, and post statements, but these must be used carefully.

The post typically updates the loop counter variable. Loops allow programming repeating logic and process collections of data.

The Basic Syntax

The basic syntax of a for loop in Go is straightforward:

for initialization; condition; post {
 // Code to be executed
}

Initialization : This part is executed before the loop begins and typically initializes a variable that will be used in the loop.
Condition : The loop continues executing as long as the condition is true.
Post : This part is executed after each iteration of the loop and is often used to update the loop control variable.

Let’s break down each component with examples:

Initialization

In this section, you can declare and initialize variables that will be used within the loop. For instance:

for i := 0; i < 5; i++ {
 fmt.Println(i)
}

In this example, i is initialized to 0, and the loop will continue as long as i is less than 5. After each iteration, i is incremented by 1.

Condition

The loop will continue executing as long as the condition is true. If the condition is false from the beginning, the loop won’t run at all. For example:

go
for j := 10; j > 0; j — {
 fmt.Println(j)
}

This loop counts down from 10 to 1. Once j becomes 0, the condition is false, and the loop terminates.

Post

The post statement is executed after each iteration of the loop and is often used to update the loop control variable. Here’s an example:

go
for x := 0; x < 10; x += 2 {
 fmt.Println(x)
}

In this case, x starts at 0 and is incremented by 2 after each iteration, producing the numbers 0, 2, 4, 6, and 8.

Using For Loops

Looping Over Arrays and Slices

For loops are commonly used to iterate over arrays and slices in Go:


numbers := []int{1, 2, 3, 4, 5}

for index, value := range numbers {
 fmt.Printf("Index: %d, Value: %d\n", index, value)
}

The range keyword is used to iterate over the elements of a slice or an array, providing both the index and the value of each element in each iteration.

Infinite Loops

In the world of go, we don’t have a while loop; but we can create an infinite loop by omitting the initialization, condition, and post statements. Use caution when creating infinite loops, as they can lead to program hangs if not controlled properly. For example:

for {
 // This is an infinite loop
}

Using For Loops with Maps

In addition to iterating over arrays and slices, Go for loops are also useful for traversing the elements of a map. Here’s an example of how you can loop over a map and perform actions on its key-value pairs:

// Create a map with some key-value pairs
studentGrades := map[string]int{
 “Alice”: 90,
 “Bob”: 85,
 “Charlie”: 78,
 “David”: 92,
}

// Loop over the map using the "range" keyword
for student, grade := range studentGrades {
 fmt.Printf("Student: %s, Grade: %d\n", student, grade)
}

In this example, we have a map called studentGrades that associates student names with their grades. We use a for loop with the range keyword to iterate over the map. During each iteration, the student variable holds the key (student name), and the grade variable holds the corresponding value (student’s grade).

The output of this code will be:

Student: Alice, Grade: 90
Student: Bob, Grade: 85
Student: Charlie, Grade: 80
Student: David, Grade: 92

This example demonstrates how to effectively loop over a map in Go, allowing you to access and process key-value pairs within your programs. Whether you need to analyze data stored in maps or perform specific operations on map elements, the for loop combined with range provides a powerful and flexible way to work with maps in Go.

Conclusion

In this blog post, we’ve covered the basics of for loops in Go, including their syntax and usage in various scenarios. Understanding how to use loops effectively is crucial for writing clean and efficient Go code. With this knowledge, you can iterate over collections, implement looping logic, and create more advanced control flow structures in your Go programs. Experiment with different loop variations to become proficient in harnessing the power of loops in Go, Happy coding friends!

Building Go Structs: An Illustrated Guide to Toy Creation

Jordan Taylor — Wed, 13 Sep 2023 20:05:43 +0000

Introduction

Structs in the Go programming language serve as fundamental building blocks for creating custom data structures. They enable us to encapsulate and organize data effectively. In this blog post, we'll explore Go structs by using the analogy of creating a toy to better understand their syntax, usage, and best practices.

What is a Struct?

In Go, a struct is like a blueprint for creating custom data types. Think of it as a recipe for building something unique. For our analogy, let's imagine we're creating a toy car:

type ToyCar struct {
    Model  string
    Color  string
    Wheels int
}

Here, we've defined a ToyCar struct with three key attributes: Model, Color, and Wheels, each representing an essential feature of our toy car.

Creating Toy Instances

Just as you would assemble a real toy car, you can create instances (or instances of your toy) from the ToyCar struct. Here's how you can create a toy car:

myToyCar := ToyCar{
    Model:  "Sports",
    Color:  "Red",
    Wheels: 4,
}

In this code, myToyCar is an instance of our ToyCar struct, and we've given it specific values for its attributes.

Playing with Toy Fields

To enjoy our toy car, we need to know how to interact with it. In Go, we access a struct's attributes using dot notation. For instance, if we want to know the model of myToyCar, we can do this:

fmt.Println(myToyCar.Model) // Output: Sports

Toy Composition: Adding Extra Features

Just like you might want to add a turbocharger or racing stripes to your toy car, Go allows you to embed one struct within another. This feature is called "struct embedding" and allows you to compose more complex data structures. Let's say we want to add a radio to our toy car:

type ToyWithRadio struct {
    ToyCar
    Radio bool
}

Now, a ToyWithRadio includes all the attributes of a ToyCar as well as an extra Radio feature.

Toy Methods: Making It Move

To make our toy car zoom around, we need to define methods. In Go, methods are functions that operate on a struct's instances. For example, let's add a method to start our toy car:

func (t ToyCar) Start() {
    fmt.Println("Starting the", t.Color, t.Model, "toy car!")
}

With this method, we can start our toy car like this:

myToyCar.Start() // Output: Starting the Red Sports toy car!

Certainly! Let's improve the example in the "Decorating Our Toy: Using Struct Tags" section by using JSON tags, and I'll explain why they are essential.

Decorating Our Toy: Using JSON Tags

In the world of Go structs, JSON tags are commonly used to provide metadata about struct fields. These tags are particularly important when you need to serialize a struct into JSON format or deserialize JSON data into a struct. Here's a revised example:

type ToyCar struct {
    Model  string `json:"model"`
    Color  string `json:"color"`
    Wheels int    `json:"wheels"`
}

In this updated ToyCar struct, we've added JSON tags to each field. The JSON tags are specified within backticks and follow the field name. The tags provide information to Go's JSON encoding and decoding functions.

Conclusion

Creating Go structs is akin to crafting your own toys, with each field and method defining a unique feature or behavior. By understanding how to define, build, and play with structs, you'll be well-equipped to design and develop complex applications in Go. So, unleash your creativity and start building incredible Go "toys" today!

Getting started with C# -String Formatting

Jordan Taylor — Sun, 11 Jul 2021 14:00:13 +0000

C# - String Formatting

Hey friends, today I will show you how string formatting works in C#; let's dive in.

You can follow long with your own code or clone the git repo as well. gettingStartedWIthCsharp - stringFormatting

Learn By Doing

All right, so let's learn a little .NET CLI as well; we start by making a new .NET project. Now let's create our .NET project.

//The following will create our console app in the directory, in the stringFormate.
dotnet new console -o stringFormate

This basic console app for now, and we will be adding upon this. Here our Main method will be asking for your first and last name, and then it will give you your initials.

using System;

namespace string format
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Enter you first name: ").IsUpper;
            string firstName = Console.ReadLine();

            Console.WriteLine("Enter you last name: ");
            string lastName = Console.ReadLine();

            Console.WriteLine($"Your initials are: '{firstName[0]}.{lastName[0]}'");
        }
    }
}

string interpolation

If we look at the existing code block that we just ran, we can see that the final line seems a little different from a standard print string. This is called string interpolation; this is a way of formatting our output; we can add the $"" to our write lines to call variables from directly in the Console.WriteLine() method.

Console.WriteLine($"Your initials are: '{firstName[0]}.{lastName[0]}'");

String Indexes

You can access the characters in a string by referring to its index number inside square brackets []. If we take a look at our example, we can see that we already used this to get the first character from our first and the last name gets it our initials.

Console.WriteLine($"Your initials are: '{firstName[0]}.{lastName[0]}'");

Okay, now let's look at a few other methods that can help us format our stings.

ToUpper()

This is a method that you can add to your strings to make sure that you always get upper case lettering no matter what the user puts in. If we take a tool at the following code block, we can see that we need to add some extra variables to our method. If we look at our new variables, we can see that we call the ToUpper() method when it's attached to an existing variable. ie fistName.ToUpper()

Side Note
C# is a strongly typed language which means, you must declare a variable type before you can use it. We see that with both the variables, we are calling the types we want to use. The "var" keyword is used to declare a var type variable. The var type variable can be used to store a simple .NET data type, a complex type, an anonymous type, or a user-defined type.
From a programming standpoint, you can think of var == string, double, int, char, bool, long, object.

Console.WriteLine("Enter you first name: ");
            string firstName = Console.ReadLine();
            var upperFirstName = firstName.ToUpper();

            Console.WriteLine("Enter you lastname: ");
            string lastName = Console.ReadLine();
            var upperLastName = lastName.ToUpper();

            Console.WriteLine($"Your initials are: '{upperFirstName[0]}.{upperLastName[0]}'");

Summary

We can see that in this session, we were able to complete the following.

Being able to create variables.
Taking input from the console.
Apply indexing to our outputs to get only certain characters.
Using different types.
Formatting methods.
Using string interpolation to format our output.

Conclusion

Formatting strings can be instrumental in real-world scenarios; this could range from formatting numbers for security reasons or validating that the data that is being used is only received in a specific format itself.
Here is some homework for you. Are you able to find any other method that we can use to format our data? I will give you one more to look into to, .ToLower the name gives it away if you have made it this far; with this, we can turn all our data into a lower casing format. Explore and see what other methods you can find as well.

Resources

Like, share and follow me 🔥 for more content:

📽YouTube
☕Buy me a coffee
💖Patreon
🌐JustJordanT.com
🐱‍💻GitHub
🤠Twitter
🏢LinkedIn

Get out there and build and happy coding.

Getting started with C# - Storing and retrieving data

Jordan Taylor — Mon, 07 Jun 2021 20:44:15 +0000

C# Variables

Variables are containers for storing data values.

In C#, there are different types of variables (defined with different keywords), for example:

int:

stores integers (whole numbers) without decimals, such as 123 or 123.

double:

stores floating-point numbers, with decimals, such as 19.99 or -19.99.

char:

stores single characters, such as 'a' or 'B'. Single quotes surround char values

string:

stores text, such as "Hello World." Double quotes surround string values

bool:

stores values with two states: true or false

Declaring Variables

By declaring variables we are creating a variable, you must specify the type and assign it a value:

Examples

int num = 5;
Console.Writeline(num);

//double
double num = 3.92
Console.Writeline(num);

string name = "Jordan";
Console.WriteLine(name);

Modifying variables

A good thing to note is if you assign a new value to an existing variable, it will overwrite the previous value:

int myNum = 115;
myNum = 220; // myNum is now 220
Console.WriteLine(myNum);

Constants

You can also add the const keyword to prevent others from altering the existing values; this could be helpful in certain situations.

const int numPi = 3.14
numPi = 20; // error

The const keyword is used to tell a variable always to keep the same value.

Note: You cannot declare a constant variable without assigning the value. If you do, an error will occur: A const field requires a value to be provided.

Using the keyword var.

The var keyword has been around for a long time, and it's commonly used in code examples.

The use of the var keyword is significant in C#. There are some situations where the data type may be different than the code intended to use it.

var message = "Hello world!";

var message = 19.0m;

Sneak Peak for the next lesson we will continue to put this all together for what we have learned so far.

int age = 25; 
int name = "Jordan";

Console.Writeline($"Hey Friends!, my name is {name}, and I am {age}!");

If you want to dive in deep with variables take a look at the links below.

sources

Like, share and follow me 🔥 for more content:

📽YouTube
☕Buy me a coffee
💖Patreon
🌐JustJordanT.com
🐱‍💻GitHub
🤠Twitter
🏢LinkedIn

Getting started with C# - Hello World!

Jordan Taylor — Mon, 07 Jun 2021 20:43:19 +0000

Hey friends!

If you are like and you realized that C# and the whole .NET ecosystem is fun to work with or you are just getting your feet wet this is fast little series of articles for you to go through to get up and running with C#.

What is C#?

C# is pronounced "C-Sharp".

It is an object-oriented programming language created by Microsoft that runs on the .NET Framework.

C# has roots from the C family, and the language is close to other popular languages like C++ and Java.

The first version was released in year 2000. The latest version, C# 9 that was released in 2020.

C# is used for:

Mobile applications.
Desktop applications.
Web applications.
Web services.
Web sites.
Games.
VR.
Database applications.

And a whole lot more!

So by now you may be thinking... Why Use C#?

It is one of the most popular programming language in the world.
It is easy to learn and simple to use.
It has a huge community support.
C# is an object oriented language which gives a clear structure -to programs and allows code to be reused, lowering development costs.
As C# is close to C, C++ and Java, it makes it easy for .
programmers to switch to C# or vice versa.

Let's get building!

Microsoft has built this handy tool to try .NET and C# that is vary user friendly or beginner or even if you don't want to mess with IDEs it get straight to coding.

Click me - Try.dot.net

Taking out first steps.

Now that we have our web IDE, let's start coding something simple. We can remove all the default test on Try.dot.net and copy this in there and click run.

using System;

namespace HelloWorld
{
  class Program
  {
    static void Main(string[] args)
    {
      Console.WriteLine("Hello World!");    
    }
  }
}

We can view our results.

And there we are running our first lines of code in C#.

In part 2 we will take a look at Storing and retrieving data in C#.

Resources

Like, share and follow me 🔥 for more content:

📽YouTube
☕Buy me a coffee
💖Patreon
🌐JustJordanT.com
🐱‍💻GitHub
🤠Twitter
🏢LinkedIn

#100DaysOfCode Thoughts?

Jordan Taylor — Sun, 04 Oct 2020 15:19:31 +0000

I have always been interested in computers and programming from a young age, but never supported my direction.

Python courses always try to give you the basics and nothing more; most courses nowadays do a lot better when it comes to the content.

I wanted to learn programming on a deeper level, so I decided to buckle down and learn Python from the top. I've made some small python projects in the past, but nothing too significant, just enough to connect the dots.

Then cam the Python for Everybody and Data Science applied with Python from the University of Michigan; this was a big game-changer.

These courses brought you through everything you would need to get started as a python programmer, from understanding the workflow and how to think about problems from an engineering standpoint.

I will say that after completing this challenge, I do think that you could probably learn a lot more, focusing on a project-based capacity.

Even if you do not know 100 percent of what you are doing, this will allow you to research and find out what you need for a specific problem; I think this correlates well to real-world experiences / Projects.

100 Days Of Coding can be an excellent resource and or habit for coding, but I think that moving on to something like 100DaysOfCoingProjects would be a good idea as well.

Project ideas

https://github.com/karan/Projects

https://www.codementor.io/@npostolovski/40-side-project-ideas-for-software-engineers-g8xckyxef

https://www.reddit.com/r/learnprogramming/comments/2a9ygh/1000_beginner_programming_projects_xpost/

https://www.freecodecamp.org/news/more-project-ideas-to-improve-your-coding-skills-99f48d09bb4b/