Forem: Si

Value Receivers VS Pointer Receivers in Go

Si — Mon, 29 Nov 2021 16:55:13 +0000

What is a Method?

Before we start talking about Value Receivers and Pointer Receivers, let's make sure we have a good grasp of what a Method is.

In Go, a Method is is a function that is defined on a type using a receiver argument.

The following example is from Tour of Go:

type Vertex struct {
    X, Y float64
}

func (v *Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

What is a Value Receiver?

When using a Value Receiver, a copy is taken of the type and passed to the Method; similarly to what happens when passing-by-value to a normal function. When the method executes, the object copy sits in a different location in memory; thus any changes made to the object don't effect the original.

Take the following example; even though we change the Breed and Weight, the original object remains unchanged.

type Dog struct {
    Breed string
    Weight int16
}

func main() {
    dog := Dog{Breed: "Dalmation", Weight: 40}

    fmt.Printf("dog before ValReceiver: %+v\n", dog) // {Breed:Dalmation Weight:40}
    dog.ValReceiver()
    fmt.Printf("dog after ValReceiver: %+v\n", dog) // {Breed:Dalmation Weight:40}
}

func (d Dog) ValReceiver() {
    d.Breed = "Terrier"
    d.Weight = 10
}

There are some exceptions to this rule, for example when using slices; which contain a pointer to the underlying array and can lead to the original object being amended. The following is an example of this scenario:

type Dog struct {
    Breed string
    Weight int16
    Friends []string
}

func main() {
    dog := Dog{Breed: "Dalmation", Weight: 40, Friends: []string{"Fred", "Amy"}}

    fmt.Printf("dog before ValReceiver: %+v\n", dog) // {Breed:Dalmation Weight:40 Friends:[Fred Amy]}
    dog.ValReceiver()
    fmt.Printf("dog after ValReceiver: %+v\n", dog) // {Breed:Dalmation Weight:40 Friends:[Chris Amy]}
}

func (d Dog) ValReceiver() {
    d.Breed = "Terrier"
    d.Weight = 10
    d.Friends[0] = "Chris"
}

What is a Pointer Receiver?

When using a Value Receiver, the memory address is passed to the Method; similarly to what happens when passing-by-reference to a normal function. When the method executes, it has a reference to the original object; thus any changes made to the object do affect the original.

Take the following example; When the method changes the Breed and Weight, the original object is also changed.

type Dog struct {
    Breed string
    Weight int16
}

func main() {
    dog := Dog{Breed: "Dalmation", Weight: 40}

    fmt.Printf("dog before PtrReceiver %+v\n", dog) // {Breed:Dalmation Weight:40}
    dog.PtrReceiver()
    fmt.Printf("dog after PtrReceiver: %+v\n", dog) // {Breed:Terrier Weight:10}
}

func (d *Dog) PtrReceiver() {
    d.Breed = "Terrier"
    d.Weight = 10
}

Can I mix-and-match Value and Pointer Receivers?

It is generally recommended you don't mix-and-match. If a type uses both Value and Pointer receiver, it will be hard for your consumers to know which method uses which type without having to read the code. However, yes you can mix-and-match.

When doing so, remember the following rules (ref):

If you have a *T you can call methods that have a receiver type of *T as well as methods that have a receiver type of T.
If you have a T and it is addressable you can call methods that have a receiver type of *T as well as methods that have a receiver type of T.
If you have a T and it isn't addressable, you can only call methods that have a receiver type of T, not *T.
If you have an interface I, and some or all of the methods in I's method set are provided by methods with a receiver of *T (with the remainder being provided by methods with a receiver of T), then *T satisfies the interface I, but T doesn't. That is because *T's method set includes T's, but not the other way around (see the first bullet).

In short, you can mix and match methods with Value Receivers and Methods with Pointer Receivers, and use them with variables containing values and pointers, without worrying about which is which. Both will work, and the syntax is the same. However, if Methods with Pointer Receivers are needed to satisfy an Interface, then only a Pointer will be assignable to the Interface — a Value won't be valid.

Debugging with delve

Si — Mon, 29 Nov 2021 16:52:52 +0000

Learn how to use Delve to debug your Go applications and tests.

What is delve?

Delve is an open source debugger for the Go programming language.

When should I use delve to debug my Go programmes?

If you use one of the popular Code Editors (e.g. VSCode, Golang) they will handle this for you. If you use VIM, and Print statements aren't cutting it, then this tutorial is for you.

Pre-requisites

Install Go
Have at least a basic working knowledge of the language
Install delve

Setting up

Create a new directory in a place of your choice
Run the go mod init command (e.g go mod init github.com/simondrake/biggest-num)
Create our pkg directory - mkdir -p pkg/biggestNum
Add a biggestNum.go file in the biggestNum directory with the following contents:

package biggestNum

func BiggestEvenNum(nums []int) int {
    var biggest int

    for _, n := range nums {
        if n > biggest && isEven(n) {
            biggest = n
        }
    }

    return biggest
}

func isEven(num int) bool {
    isEven := num%2 == 0

    return isEven
}

Create another directory, separate from the one you created at the beginning of this section
Run go mod init example.com
Change your go.mod file to the following, which basically imports our biggestNum package without having to push it up to GitHub (change directory names as required):

module example.com

go 1.16

require (
    github.com/simondrake/biggestNum v1.0.0
)

replace github.com/simondrake/biggestNum => ../biggest-num

Create a main.go file with the following contents (change import for biggestNum as required):

package main

import (
    "fmt"

    "github.com/simondrake/biggestNum/pkg/biggestNum"
)

func main() {
    b := biggestNum.BiggestEvenNum([]int{1, 4, 23, 12, 41, 51})

    fmt.Println(b)
}

Run go run main.go and make sure you don't get any compilation errors.

Debugging your Application

We now have a Go application we can debug, so let's start the debugger with dlv debug and you should see the following:

$ dlv debug
Type 'help' for list of commands.
(dlv)

Add a breakpoint at line 10 of our main.go file by running breakpoint main.go:10 (or b main.go:10 for short).

(dlv) b main.go:10
Breakpoint 1 set at 0x10cb9cf for main.main() ./main.go:10

Run continue (or c) to run-to-breakpoint.

(dlv) c
> main.main() ./main.go:10 (hits goroutine(1):1 total:1)
     5:
     6:         "github.com/simondrake/biggestNum/pkg/biggestNum"
     7: )
     8:
     9: func main() {
=>  10:         b := biggestNum.BiggestEvenNum([]int{1, 4, 23, 12, 41, 51})
    11:
    12:         fmt.Println(b)
    13: }

From here we could continue (c), which would run the programme to completion because there are no more breakpoints, but instead let's step-into the BiggestEvenNum method by running step (or s).

> github.com/simondrake/biggestNum/pkg/biggestNum.BiggestEvenNum() /path/to/biggest-num/pkg/biggestNum/biggestNum.go:3
     1: package biggestNum
     2:
=>   3: func BiggestEvenNum(nums []int) int {
     4:         var biggest int
     5:
     6:         for _, n := range nums {
     7:                 if n > biggest && isEven(n) {
     8:                         biggest = n

Note how the first line gives us a handy reference to where we are (/path/to/biggest-num/pkg/biggestNum/biggestNum.go:3).

Now let's add another breakpoint in our biggestNum package, on line 7:

(dlv) b /path/to/biggest-num/pkg/biggestNum/biggestNum.go:7
Breakpoint 2 set at 0x10cb8ea for github.com/simondrake/biggestNum/pkg/biggestNum.BiggestEvenNum() /path/to/biggest-num/pkg/biggestNum/biggestNum.go:7

Run continue to get to our next breakpoint.

(dlv) c
> github.com/simondrake/biggestNum/pkg/biggestNum.BiggestEvenNum() /path/to/biggest-num/pkg/biggestNum/biggestNum.go:7 (hits goroutine(1):1 total:1)
     2:
     3: func BiggestEvenNum(nums []int) int {
     4:         var biggest int
     5:
     6:         for _, n := range nums {
=>   7:                 if n > biggest && isEven(n) {
     8:                         biggest = n
     9:                 }
    10:         }
    11:
    12:         return biggest

You can evaluate expressions by running print (or p)

(dlv) p n
1

You can evaluate a function call by running call

(dlv) call isEven(n)
> github.com/simondrake/biggestNum/pkg/biggestNum.BiggestEvenNum() /path/to/biggest-num/pkg/biggestNum/biggestNum.go:7 (hits goroutine(1):2 total:2)
Values returned:
        ~r1: false

You can continue to run the programme to the next iteration of the loop, or run next (or n) to go to the next line, but we're going to skip that by removing this breakpoint. First, get the name of the breakpoint with breakpoints (or bp) and then delete it

(dlv) clear 2
Breakpoint 2 cleared at 0x10cb8ea for github.com/simondrake/biggestNum/pkg/biggestNum.BiggestEvenNum() /path/to/biggest-num/pkg/biggestNum/biggestNum.go:7

Then we'll stepout (or so) of this package

(dlv) so
> main.main() ./main.go:10
Values returned:
        ~r1: 12

     5:
     6:         "github.com/simondrake/biggestNum/pkg/biggestNum"
     7: )
     8:
     9: func main() {
=>  10:         b := biggestNum.BiggestEvenNum([]int{1, 4, 23, 12, 41, 51})
    11:
    12:         fmt.Println(b)
    13: }

From here you can restart if you want to run the same debugger again, or continue until completion of the application.

Debugging tests

So far, we've seen how to debug a Go application. But what if we wanted to debug our biggestNum standalone? If you try running dlv debug you'll get an error.

$ dlv debug pkg/biggestNum/biggestNum.go
could not launch process: not an executable file

But, delve does have a test subcommand we can use to run our tests in debug mode. So, first, let's add the following test under biggestNum_test.go:

package biggestNum

import (
    "testing"
)

func TestBiggestEvenNum(t *testing.T) {
    expected := 290

    out := BiggestEvenNum([]int{23, 51, 4, 32, 45, 290})

    if out != expected {
        t.Fatalf("'%d' did not match expected '%d'", out, expected)
    }
}

To run the tests in debug mode, use dlv test

$ dlv test pkg/biggestNum/*.go -test.v
Type 'help' for list of commands.

Then set a breakpoint as we did in the previous step

(dlv) b biggestNum.go:6
Breakpoint 1 set at 0x11607d3 for command-line-arguments.BiggestEvenNum() ./pkg/biggestNum/biggestNum.go:6``

Run continue as we did before

(dlv) continue
> command-line-arguments.BiggestEvenNum() ./pkg/biggestNum/biggestNum.go:6 (hits goroutine(4):1 total:1)
     1: package biggestNum
     2:
     3: func BiggestEvenNum(nums []int) int {
     4:         var biggest int
     5:
=>   6:         for _, n := range nums {
     7:                 if n > biggest && isEven(n) {
     8:                         biggest = n
     9:                 }
    10:         }
    11:

And then debug your package, as we did our application, in the previous section.

Closing thoughts

You've learnt the basics of debugging with delve, but you should refer to the help command output to learn about what else delve can do.

Best programming audiobooks

Si — Tue, 16 Jun 2020 15:56:04 +0000

I struggle to read books, the words dance around on the page which results in me skipping over whole sentences/paragraphs.

Sometimes I can go ten minutes and have no idea what I've just read.

However, audiobooks are right up my street!

What books convert well in the audiobook format?

Binary to decimal converter

Si — Tue, 19 May 2020 13:00:00 +0000

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

Have you ever seen Binary, those ones and zeros that computers somehow understand, and wondered what it all means? Well,
today we're going to demistify some of if by creating a small application that converts from binary to decimal.

What is decimal?

Decimal is the numbering system that most of us use everyday. We're taught it from a young age, so it may seem like the
only logical way of counting. Let's take a quick look at what it looks like to count in decimal:

1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ..... 1001

Decimal can also be referred to as Base 10. It includes the numbers 0-9 (ten possibilities) and each column in a number
is a power of ten.

Let's look at an example by breaking down the number 5,743, which we know is Five Thousand, Seven Hundred, and Fourty Three.

So, what did I mean when I said each column in a number is a power of ten? If we look at the above image, starting from the right-most box, we can say:

Ten to the power of Zero (10^0) is 1. We have Three in this column, so our calculation is 3x1 (3).
Ten to the power of One (10^1) is 10. We have Four in this column, so our calculation is 4x10 (40).
Ten to the power of Two (10^2) is 100. We have Seven in this column, so our calculation is 7x100 (700).
Ten to the power of Three (10^3) is 1000. We have Five in this column, so our calculation is 5x1000 (5000).

Adding all of the numbers (5000 + 700 + 40 + 3) gives us 5,743.

What is binary?

The above explanation of decimal may seem basic and pointless, but it's going to help to explain what binary is in this
section.

Binary, like decimal, is just a numbering system. Unlike decimal, it is referred to as Base 2, only includes
the numbers 0 and 1 (two possibilities) and each column is a power of two.

Let's look at an example by breaking down the binary number 10100101. Unlike the previous section it's not immediately clear
what this number is, so we're going to walk through the same steps to find out.

We know each column in a binary number is a power of two so, starting from the right-most number, we can say:

Two to the power of Zero (2^0) is 1. We have One in this column, so our calculation is 1x1 (1).
Two to the power of One (2^1) is 2. We have Zero in this column, so our calculation is 0x2 (0).
Two to the power of Two (2^2) is 4. We have One in this column, so our calculation is 1x4 (4).
Two to the power of Three (2^3) is 8. We have Zero in this column, so our calculation is 0x8 (0).
Two to the power of Four (2^4) is 16. We have Zero in this column, so our calculation is 0x16 (0).
Two to the power of Five (2^5) is 32. We have One in this column, so our calculation is 1x32 (32).
Two to the power of Six (2^6) is 64. We have Zero in this column, so our calculation is 0x64 (0).
Two to the power of Seven (2^7) is 128. We have One in this column, so our calculation is 1x128 (128).

Adding all the numbers (128 + 0 + 32 + 0 + 0 + 4 + 0 + 1) gives us 165. So, as you can see, at it's most basic
level, binary is just a numbering system.

What are we building?

In the last two sections we learnt that binary, like decimal, is just a numbering system. We also, unbeknowingly,
detailed how to convert from binary to decimal (notice how we calculated the decimal representation for each binary
digit, and then added them all up).

We're now going to use this knowledge to write a programme that will perform this conversion for us.

The following sections will show you how to write such a programme in JavaScript and Go.

Note: Neither of the following sections are "production ready" - the code is to illustrate how to perform the conversion
from binary to decimal in code, and we have omitted error handling and type checking for brevity.

JavaScript Implementation

We know the best approach, to convert from binary to decimal, is to start with the right-most number/column. Let's start
by writing a simple binaryToDecimal function, which accepts a string (our binary number) and prints it out from the
right-most column to the left-most column.

const binaryToDecimal = binary => {
    for (let i=binary.length-1; i>=0; i--) {
        console.log(binary[i])
    }
}

Because we're only printing out the numbers, our function just contains a simple for loop (see Arrays and Loops
in JavaScript for a JavaScript specific explanation) which starts at end of the input
(binary.length-1), continues while i is less than or equal to 0, and decrements i by one for each loop.

binaryToDecimal("1000101") // 1010001
binaryToDecimal("1110001") // 1000111
binaryToDecimal("1000100") // 0010001

We know that each column, in a binary number, is a power of two so let's change our function to print out the exponent
of each column.

const binaryToDecimal = binary => {
    let pow=0

    for (let i=binary.length-1; i>=0; i--) {
        let r=Math.pow(2, pow)

        console.log(r)

        pow++
    }
}

We initialise a new pow variable to zero because, like we did when calculating manually above, we start with two to
the power of zero (2^0).

On each loop, we work out the result of two to the power of pow (2^pow), log the result and increment pow ready for the next loop.

binaryToDecimal("1000101")

/**
1
2
4
8
16
32
64
*/

We now have a function that accepts a string representation of a binary number, starts at the right-most column and
works out the decimal representation for each column. The last thing to do is to calculate each column, and add the
result together to get our decimal representation.

const binaryToDecimal = (binary) => {
    let result=0
    let pow=0

    for (let i=binary.length-1; i>=0; i--) {
            let r=Math.pow(2, pow)

            result += r * parseInt(binary[i],10)

            pow++
    }

    console.log(result)
}

We've now added a result variable, which we increment based on the result of r * parseInt(binary[i],10) where r is
the result of our power calculation and parseInt will yield either zero or one.

binaryToDecimal("10100101") // 165

And that's all there is to a binary to decimal converter. Keep reading if you'd like to see the Go implementation, or
visit our handy binary to decimal converter, which uses this logic, if you'd like to
test out some numbers.

Go Implementation

Like we discussed above, in the JavaScript implementation, we know the best approach, to convert from binary to decimal, is to start with the right-most number/column.

We'll follow a similar pattern by first creating a simple binaryToDecimal function, which accepts a string (our binary
number) and prints it out from the right-most column to the left-most column.

package main

import (
    "fmt"
)

func main() {
    binaryToDecimal("1000101") // 1010001
    binaryToDecimal("1110001") // 1000111
    binaryToDecimal("1000100") // 0010001
}

func binaryToDecimal(binary string) {
    for i := len(binary) - 1; i >= 0; i-- {
        fmt.Println(string(binary[i]))
    }
}

Because we're only printing out the numbers, our function just contains a simple for loop (see Arrays and Loops
in Go for a Go specific explanation) which starts at end of the input (len(length)-1), continues while i is less than or equal to 0, and decrements i by one for each loop.

Note how we are converting the value (binary[i]) to a string. We have to do this because looping over a string in Go
returns the byte representation of each character (48 for 0, 49 for 1).

Because we are using characters that fit into one byte (0 and 1) this is safe. However, be cautious about using this technique when you cannot guarantee each character
will fit into one byte as you may get skewed results.

We know that each column, in a binary number, is a power of two so let's change our function to print out the exponent
of each column.

package main

import (
    "fmt"
    "math"
)

func main() {
    binaryToDecimal("1000101")
    /**
    1
    2
    4
    8
    16
    32
    64
    */
}

func binaryToDecimal(binary string) {
    var pow float64 = 0

    for i := len(binary) - 1; i >= 0; i-- {
        r := math.Pow(2, pow)

        fmt.Println(r)

        pow++
    }
}

We initialise a new pow variable to zero because, like we did when calculating manually, we start with two to the power of zero (2^0).

On each loop, we work out the result of two to the power of pow (2^pow), log the result and increment pow ready for the next loop.

package main

import (
    "fmt"
    "math"
    "strconv"
)

func main() {
    fmt.Println(binaryToDecimal("1000101"))  // 69
    fmt.Println(binaryToDecimal("10100101")) // 165
}

func binaryToDecimal(binary string) int64 {
    var result int64 = 0
    var pow float64 = 0

    for i := len(binary) - 1; i >= 0; i-- {
        r := math.Pow(2, pow)

        i, _ := strconv.ParseInt(string(binary[i]), 10, 64)
        result += int64(r) * i

        pow++
    }

    return result
}

We've now added a result variable, which we increment based on the result of r * i where r is the result of our power calculation and i is the result of converting our character (0 or 1) to an int.

And that's how to create a binary to decimal converter in Go. Feel free to visit our handy binary to decimal converter, which uses the JavaScript logic, if you'd like to test out some numbers.

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

Writing for CodeTips

Si — Fri, 10 Jan 2020 16:32:13 +0000

CodeTips is not a Social Media platform like Dev, it's not an "open for everyone/everything" writing experience like Medium.

I like to see CodeTips as between a personal blog and everything else out there.

We're never going to have hundreds of writers, nor do we want to, that can write whatever they want like FreeCodeCamp. We want a handful of regular writers, that decide what to write about.

If you are interested in writing for CodeTips please leave a comment, or get in Contact.

Merry Christmas to all

Si — Wed, 25 Dec 2019 14:09:27 +0000

How To create a CRUD API, using Node.js and Express, on Ubuntu 18.04

Si — Thu, 19 Dec 2019 12:25:51 +0000

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

Introduction

An API (Application Programming Interface) is a way of interacting with a service, through a series of predefined requests.

Express is an open source web framework, for Node.js, designed to make developing websites, web apps, and API's easier.

In this tutorial, you will create a simple CRUD API on a single Ubuntu 18.04 server. The API will be accessible through a public IP address, allowing you to access it from anywhere with an internet connection.

To get started, sign-up for Digital Ocean using this referral link and get $100 credit!

Prerequisites

An Ubuntu 18.04 server setup, as described in the initial server setup guide for Ubuntu 18.04. You should have a non-root user with sudo privileges and an active firewall.
Node.js and PM2 installed on your Ubuntu 18.04 server, as described in How To Set Up a Node.js Application for Production on Ubuntu 18.04.
A basic understanding of CURL

Step 1 — Create a simple Express App that serves "Hello World"

In this step, we’ll create a very simple API, with one endpoint, that we’ll then build on in future steps.

To begin, create a new directory in a location of your choosing, and create a default package.json file, by running the following command in a terminal:

npm init -y

In the same terminal, install the express dependency:

npm i express

Next, open the project in a code editor of your choice and create a new server.js file.

Within the new file, add the following code:

const express = require('express')
const app = express()
const port = 3000

app.get('/hello', (req, res) => res.send('Hello World!'))

app.listen(port, () => console.log(`App listening on port ${port}!`))

Using the express application, we define a /hello endpoint, that will return the text Hello World!, and run our application on port 3000.

Note that the /hello endpoint will only match for GET requests, as we've defined it using the app.get method.

In your terminal, run the following command to start the application:

node index.js

You should see the following output as a result:

$ node index.js
App listening on port 3000!

Now open your favourite browser, and navigate to localhost:3000/hello. If everything worked successfully, Hello World! should be displayed in your browser.

Congratulations - you have created an API, and you can communicate with it via the /hello endpoint. We’ll build on this structure in the following steps, and make our API even better!

Step 2 — Extend the application to get a property from in-memory state.

At this point we have one endpoint, /hello, that returns the text Hello World!. While it’s awesome that we’ve created an API, as far as functionality goes it’s not that helpful.

In this step we’ll take our API and have it return some useful data. We’ll be using an example of employee details.

First, let's add another endpoint to our application that will retrieve a record.

const express = require('express')
const app = express()
const port = 3000

app.get('/hello', (req, res) => res.send('Hello World!'))

app.get('/employee/:id', (req, res) => {
  console.log(req.params.id)
  res.sendStatus(200)
})

app.listen(port, () => console.log(`App listening on port ${port}!`))

We define a new /employee endpoint, just like we did for the /hello endpoint, but we're also using a query parameter.

Query parameters are defined using a colon, and the preceding text is used to reference that parameter. In our /employee endpoint, we've defined a query parameter called id, and our console.log statement shows how we reference the value.

Stop and start the application, so the new code changes take effect, open your browser and navigate to http://localhost:3000/employee/wiggly.

You should see the following output in your terminal, as a result:

$ node index.js
App listening on port 3000!
wiggly

Notice how wiggly was printed to the terminal, which is what we used in the URL (/employee/wiggly). Change wiggly to anything you like, and you should see that printed in the terminal.

The power of this technique enables us to define one route, which can be used for many different scenarios. For example, an endpoint that can retrieve an employees details using a unique identifier, which is exactly what we're going to do now!

Let's create an Object, to act as in-memory state for our application, and add some fictional employees:

/**  
We'll use the Object key as the unique identifier, made up of the
first letter of the employees first name and whole of their last name.
*/
const employees = {
  'sbrown': {
    firstName: 'Steve',
    lastName: 'Brown',
    department: 'Engineering'      
  },
  'jsmith': {
    firstName: 'Janine',
    lastName: 'Smith',
    department: 'Marketing'      
  },
  'kjones': {
    firstName: 'Karen',
    lastName: 'Jones',
    department: 'Sales'      
  },
  'bwilliams': {
    firstName: 'Ben',
    lastName: 'Williams',
    department: 'Administration'
  }
}

Now, instead of logging out the id parameter value, let's return the employee details from our Object:

app.get('/employee/:id', (req, res) => {
  res.json(employees[req.params.id])
})

As we'll be returning a JSON object we're using the res.json method which, among other things, sets all of the correct headers and returns the response in JSON.

Restart the application and navigate to http://localhost:3000/employee/kjones in your browser.

You should see the following response in your browser:

{"firstName":"Karen","lastName":"Jones","department":"Sales"}

Try changing kjones to any of the other unique identifiers, in the employees object, and see the returned values change.

Now, try changing the id to something non-existent (e.g. http://localhost:3000/employee/wiggly) in the browser. Nothing is returned, which is correct, but we're not giving the user any indication why; did something go wrong, or does the employee just not exist?

Let's update the endpoint to check if the given employee id exists and, if not, we'll return a 404 Not Found response, otherwise we'll return the employee details.

app.get('/employee/:id', (req, res) => {
  const employee = employees[req.params.id]

  if (!employee) {
    return res.sendStatus(404)
  }

  res.json(employee)
})

Restart your application, and try the same URL in the browser. The response should now be Not Found, which is a lot more informative to the user.

In this step, we took a very simple and not very helpful API and transformed it into one that queries data using query parameters. We also learnt how to handle situations where a non-existent employee is queried.

Step 2 — Extend the application to add/delete a property from in-memory state.

We now have an API that can retrieve an employee, based on the employee id, but what if an employee joins/leaves the company? We need a way to add/remove them from our employees list, which is what we’ll achieve in this step.

Let’s focus on people joining the company first. When someone joins, we want to add them to our employees object so they can be queried later on.

To do this we will use a POST request, which we declare in the same way as our GET requests above.

app.post('/employee', (req, res) => {
  res.sendStatus(200)
})

Restart your application to apply our code changes.

Our new route doesn’t do anything, other than return a 200 OK status because, before we get into writing the logic, I want to talk a bit about how we can make a POST request.

When you enter an address into a browser, like we did in the previous steps ( e.g. http://localhost:3000/hello ), we are requesting a resource by making a GET request.

We can’t use the same mechanism to make any other type of request (POST, PUT, DELETE etc), so how do we reach these endpoints? There are quite a few different methods, but we’re only going to focus on one - CURL.

To make a POST request, to our new endpoint, using CURL, run the following command in a terminal:

curl -X POST 'http://localhost:3000/employee'

The only functionality we added to our new endpoint was to return a 200 OK status, which is what you should see as a response in your terminal.

$ curl -X POST 'http://localhost:3000/employee'
OK

Let’s build this logic out to add an employee to our employees object.

The first thing we need to do is to get the new employees details. If we look at our existing employees, we need three pieces of information - firstName, lastName and department.

In the last section we used the req.params property to extract the id URL parameter. When dealing with a POST request, we have the ability to use a request body.

Using CURL, we can combine the Header (-H) flag to specify a content type, which informs the server what format the request content is in, and the Data (--data) flag to pass through a JSON object.

We’ll sending a JSON object so we’ll set a Content-Type header or application/json, to tell the server we’re sending JSON, and we’ll specify our new employee as data:

CURL -X POST 'http://localhost:3000/employee' -H 'content-type: application/json' --data '{"firstName": "John", "lastName": "Doe", "department": "engineering"}'

We are now making a POST request, to http://localhost:3000/employee, with the above JSON object as our Request Body.

By default, our Express application won’t parse this JSON object, so we need to enable some middleware to enable it.

const express = require('express')
const app = express()
const port = 3000

/**
-- Employee object
*/

/** 
Middleware that looks at requests with an application/json 
Content-Type header and stores the request body, as JSON,
in req.body
*/
app.use(express.json())

/**
-- Other endpoints
*/

app.post('/employee', (req, res) => {
  console.log(req.body)
  res.sendStatus(200)
})

Before defining any of your routes, tell your app to use the express.json middleware. Then, in our new endpoint, log the Request Body.

Restart the application and make the request, with the JSON request body, using CURL. You should see the following output in the terminal running your application:

$ node index.js
App listening on port 3000!
{ firstName: 'John', lastName: 'Doe', department: 'engineering' }

We can now receive a new employee object from our new POST endpoint, so let’s build out our logic to ensure we get all three required fields (firstName, lastName and department), construct the id from the firstName and lastName, and then add it to our employee object if that id isn’t already in use.

app.post('/employee', (req, res) => {
  const { firstName, lastName, department } = req.body

  if (!firstName || !lastName || !department) {
    // 400 = bad request. It indicates to the user that
    // there was something wrong with their request.
    return res.status(400).send('One or more required fields are missing')
  }

  const id = (firstName[0] + lastName).toLowerCase()

  if (employees[id]) {
    // Provide a custom message so the user knows what the
    // problem with the request is.
    return res.status(400).send('A user with that id already exists')
  }

  // We set the employee properties explicitly, just in case
  // the user sends other fields through that we're not interested
  // in storing.
  employees[id] = { firstName, lastName, department }

  res.sendStatus(200)
})

Restart the application and try the following scenarios:

Make a POST request without one or more of the required fields.
Make a POST request with a firstName and lastName that makes an id which already exists (e.g. Sarah Brown which would conflict with Steve Brown).
Make a POST request that succeeds and then make a GET request that retrieves the new employees details.

Now, let’s use what we’ve learnt so far to create a new DELETE endpoint that takes an employees id and removes it from our employees object.

app.delete('/employee/:id', (req, res) => {
  const employee = employees[req.params.id]

  if (!employee) {
    return res.sendStatus(404)
  }

  delete employees[req.params.id];

  res.sendStatus(200)
})

You’ll notice this is very similar to our GET employee endpoint; we’re using the URL parameter, checking that the employee exists and returning a 200 status if everything succeeds. The only difference is we delete the employee, from the employees object, by their id.

Making a DELETE request in CURL is very similar to the POST request we saw above:

curl -X DELETE 'http://localhost:3000/employee/sbrown'

Restart the application and try the following:

Make a DELETE request to our new endpoint, with an existing employee id (e.g. http://localhost:3000/employees/sbrown).
Make a GET request to our employees endpoint, with the same employee id (e.g. http://localhost:3000/employees/sbrown) and see that you now get a 404 Not Found response.

Congratulations - you’ve created a CRUD API!

In this step we really took our API to the next level, by allowing our users to add and delete employees, and we learnt how to deal with POST data by enabling the express.json middleware.

Step 3 — Deploy the API to Digital Ocean

We now have an API that can create, delete and retrieve an employee. What we’ve done so far is awesome, but it only lives on our laptop. To take our application to the next level, we need to host it on a publicly accessible server that we can access it from anywhere in the world.

As per our prerequisites, you should have a Digital Ocean server. First, make a new directory on your server.

$ mkdir ~/simple-crud

Next, using a terminal in your local project directory, copy the necessary files to your server by running the following command:

$ scp package-lock.json package.json server.js ubuntu@YOUR_IP:./simple-crud/

Replace ubuntu with the user you created, and YOUR_IP` with your servers public IP address.

We’ve now copied our package-lock.json, package.json and server.js file to our new simple-crud folder on our server.

Next, while in the simple-crud folder on your server, install the applications dependencies:

`
$ npm i

Lastly, start the application using PM2:

`
$ pm2 start server.js --name "simple-crud"

To make sure the application has started correctly, you can run pm2 logs and ensure you see the following log line:

`
$ pm2 logs
0|simple-c | App listening on port 3000!

Next, we’ll amend the default NGINX server block to forward all requests to our application.

Use vi to edit the default configuration:

`
$ sudo vi /etc/nginx/sites-available/default

Then, replace the root location (location /) with the following code, which will forward any HTTP requests to our application.

`
location / {
proxy_pass http://localhost:3000;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_set_header Host $host;
proxy_cache_bypass $
}

In this step we took our application from only running on our laptop, to running on a Digital Ocean server, meaning our application can be accessed from anywhere in the world!

Step 4 — Use our new API, hosted on Digital Ocean, instead of localhost

We now have an application running on a Digital Ocean server, that can be accessed from anywhere in the world. We know how to access our API locally, but how do we interact with it now?

We just replace localhost with our public IP address in our CURL commands:

`
$ curl -X GET 'http://157.245.243.1/employee/sbrown'
{"firstName":"Steve","lastName":"Brown","department":"Engineering"}

$ curl -X POST 'http://157.245.243.1/employee' -H 'content-type: application/json' --data '{"firstName": "John", "lastName": "Doe", "department": "engineering"}'
OK

$ curl -X DELETE 'http://157.245.243.1/employee/jsmith'
OK

Conclusion

You have successfully created a CRUD API, with in-memory state, and you deployed it to a Digital Ocean server meaning you can interact with it from anywhere using a public IP address.

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

Two Sum

Si — Tue, 17 Dec 2019 18:01:57 +0000

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

In this article, we bring you another challenge from AlgoDaily called Two Sum.

We recommend trying to complete the challenge yourself, before reading our explanation, here.

The Challenge

Given an array of integers, return the indices of the two numbers in it that add up to a specific goal number.

So let's say our goal number was 10. Our numbers to sum to it would be 3 and 7, and their indices 1 and 3 respectively.

let arr = [1, 3, 6, 7, 9];
let goal = 10;
twoSum(arr, goal); // [1, 3]

You may assume that each input would have exactly one solution. Additionally, you may not use the same element twice. For example, if given a slice of [1,3] and a goal of 2, you cannot use 1 twice and return [0,0] as your answer.

Test Cases

Expect twoSum([1,9,13,20,47], 10) to equal [0,1].
Expect twoSum([3,2,4,1,9], 12) to equal [0,4].
Expect twoSum([], 10) to equal [].

Learn to complete this challenge using:

if you don’t see your favourite language here, feel free to leave a comment and tell us which one you’d like us to cover or check back at another time and see if we’ve added it.

The solutions and test cases for this challenge can be found on our GitHub account.

Go

First, let’s define our test cases in a file called twosum_test.go. We’ll use a Table Driven Test to keep our test cases free of unnecessary duplication and keep them easy to read/maintain.

// twosum_test.go

package twosum

import (
    "fmt"
    "reflect"
    "testing"
)

func TestTwoSum(t *testing.T) {
    testCases := []struct {
        nums []int
        goal int
        expected []int
    }{
        {
            nums: []int{1, 9, 13, 20, 47},
            goal: 10,
            expected: []int{0, 1},
        },
        {
            nums: []int{3, 2, 4, 1, 9},
            goal: 12,
            expected: []int{0, 4},
        },
        {
            nums: []int{},
            goal: 10,
            expected: []int{},
        },
    }
    for ix, tC := range testCases {
        t.Run(fmt.Sprintf("test %d - TwoSum should return expected output", ix), func(t *testing.T) {
            output := TwoSum(tC.nums, tC.goal)

            if !reflect.DeepEqual(tC.expected, output) {
                t.Errorf("expected '%+v' to equal '%+v', but it did not", output, tC.expected)
            }

        })
    }
}

Next, let’s create our TwoSum function declaration. We already know from the test description that we expect a slice of indices and a goal, as input, and that we should return a slice of indices that sum up to the goal, or an empty slice if a match isn’t found.

package twosum

// TwoSum takes a slice of ints and an expected goal, and returns the
// indices that sum together to reach that goal, or an empty slice otherwise.
func TwoSum(nums []int, goal int) []int {
    return []int{}
}

Note: going forward we will omit the package and import statements, but they can be found on our GitHub account.

Running our tests we get two expected failures, and one passing test (because we hardcoded a response of an empty slice).

go test -v ./...
=== RUN TestTwoSum
=== RUN TestTwoSum/test_0_-_TwoSum_should_return_expected_output
=== RUN TestTwoSum/test_1_-_TwoSum_should_return_expected_output
=== RUN TestTwoSum/test_2_-_TwoSum_should_return_expected_output
--- FAIL: TestTwoSum (0.00s)
    --- FAIL: TestTwoSum/test_0_-_TwoSum_should_return_expected_output (0.00s)
        twosum_test.go:36: expected '[]' to equal '[0 1]', but it did not
    --- FAIL: TestTwoSum/test_1_-_TwoSum_should_return_expected_output (0.00s)
        twosum_test.go:36: expected '[]' to equal '[0 4]', but it did not
    --- PASS: TestTwoSum/test_2_-_TwoSum_should_return_expected_output (0.00s)
FAIL

We need to compare two indices at a time, to see if they sum up to the goal. For example, when given an input of [0,1,12,20,9] and 10 we could write down the logic like so:

Take the number at index 0 (0)
- Take the number at index 1 (1), do the numbers equal 10? No, continue.
- Take the number at index 2 (12), do the numbers equal 10? No, continue.
- Take the number at index 3 (20), do the numbers equal 10? No, continue.
- Take the number at index 4 (9), do the numbers equal 10? No, continue.
Take the number at index 1 (1)
- Take the number at index 2 (12), do the numbers equal 10? No, continue.
- Take the number at index 3 (20), do the numbers equal 10? No, continue.
- Take the number at index 4 (9), do the numbers equal 10? Yes! Return index 1 and index 4 ([1,4]).

Let’s print the indices out first, to make sure we’re getting the expected behaviour.

func TwoSum(nums []int, goal int) []int {
    for ix := range nums {
        for i := ix + 1; i < len(nums)-1; i++ {
            fmt.Printf("Outer index: %d, Inner index: %d \n", ix, i)
        }
    }

    return []int{}
}

Now let’s add another test case to our Table Driven Test (below).

{
    nums: []int{0, 1, 12, 20, 9},
    goal: 10,
    expected: []int{1, 4},
},

And we’ll comment out the rest of the tests just to observe the Printf statements for our new test case:

go test -v ./...
=== RUN TestTwoSum
=== RUN TestTwoSum/test_0_-_TwoSum_should_return_expected_output
Outer index: 0, Inner index: 1 
Outer index: 0, Inner index: 2 
Outer index: 0, Inner index: 3 
Outer index: 0, Inner index: 4 
Outer index: 1, Inner index: 2 
Outer index: 1, Inner index: 3 
Outer index: 1, Inner index: 4 
Outer index: 2, Inner index: 3 
Outer index: 2, Inner index: 4 
Outer index: 3, Inner index: 4

Excellent, now all we need to do is check to see if the values equal our goal and, if they do, return the indices. If we never reach our goal (i.e. our loops end), we return an empty slice to signify that a match wasn’t found.

func TwoSum(nums []int, goal int) []int {
    for ix := range nums {
        for i := ix + 1; i < len(nums); i++ {
            if nums[ix]+nums[i] == goal {
                return []int{ix, i}
            }
        }
    }

    return []int{}
}

Let’s uncomment and run all of our test cases and make sure they all pass

go test -v ./...
=== RUN TestTwoSum
=== RUN TestTwoSum/test_0_-_TwoSum_should_return_expected_output
=== RUN TestTwoSum/test_1_-_TwoSum_should_return_expected_output
=== RUN TestTwoSum/test_2_-_TwoSum_should_return_expected_output
=== RUN TestTwoSum/test_3_-_TwoSum_should_return_expected_output
--- PASS: TestTwoSum (0.00s)
    --- PASS: TestTwoSum/test_0_-_TwoSum_should_return_expected_output (0.00s)
    --- PASS: TestTwoSum/test_1_-_TwoSum_should_return_expected_output (0.00s)
    --- PASS: TestTwoSum/test_2_-_TwoSum_should_return_expected_output (0.00s)

Four passing test cases! But we’re not done yet! Although this solution works, we need to consider if it’s a “good” solution.

Because we’re using two loops, we’ve introduced the possibility that our code will need to process every element in our nums slice n number of times (where n is the length of the slice)!

Imagine if someone passed in a slice with a million elements, and how many loops we’d be running! We can characterise this Algorithmic Complexity as Quadratic or O(n^2), which is very well described here. Luckily, there is a better way!

First, let’s comment out all of our tests, like we did before, apart from the one below:

{
    nums: []int{0, 1, 12, 20, 9},
    goal: 10,
    expected: []int{1, 4},
},

Next, we’re going to make a map of processed elements and will be constructed of the following:

Our key will be the result of the goal minus the current element.
Out value will be the index of the current element.

func TwoSum(nums []int, goal int) []int {
    processed := make(map[int]int)

    for index, currentValue := range nums {
        currentSubtraction := goal - currentValue

        processed[currentSubtraction] = index
    }

    fmt.Printf("%+v", processed)

    return []int{}
}

Running our tests again will fail, because we’ve not implemented all of our logic yet, but we should see the output of our processed map.

=== RUN TestTwoSum/test_0_-_TwoSum_should_return_expected_output
map[-10:3 -2:2 1:4 9:1 10:0]--- FAIL: TestTwoSum (0.00s)

Here we see the outputs of the goal (10) minus each element (0, 1, 12, 20 and 9) as the keys and their index positions as the values.

So how does this actually help us? Well, we know what the subtraction is of the current element, therefore we know what value we need in order to make the goal, we also know the subtractions of the elements that have come before it, so we can work out if we have an index that satisfies the TwoSum requirement.

That’s a really confusing statement, so let’s break it down step-by-step. First, let’s define what we mean by these statements:

Current subtraction - goal - currentValue
Required value to satisfy requirement - goal - currentSubtraction

Now, let’s go through the slice we’re using in our test case ([0, 1, 12, 20, 9] step-by-step:

Index 0, Value 0
- Current subtraction ( 10 - 0) = 10
- Required value to satisfy requirement (10 - 10) = 0
- Do we have an element in our map with a key of 0? No.
Index 1, Value 1
- Current subtraction (10 - 1) = 9
- Required value to satisfy requirement (10 - 9) = 1
- Do we have an element in our map with a key of 1? No.
Index 2, Value 12
- Current subtraction (10 - 12) = -2
- Required value to satisfy requirement (10 - -2) = 12
- Do we have an element in our map with a key of 12? No.
Index 3, Value 20
- Current subtraction (10 - 20) = -10
- Required value to satisfy requirement (10 - -10) = 20
- Do we have an element in our map with a key of 20? No.
Index 4, Value 9
- Current subtraction (10 - 9) = 1
- Required value to satisfy requirement (10 - 1) = 9
- Do we have an element in our map with a key of 9? Yes! So we return [1,4] which represents the index of the found item (1) and the current index (4).

And we can write this in code, using exactly the same logic, like so:

func TwoSum(nums []int, goal int) []int {
    processed := make(map[int]int)

    for index, currentValue := range nums {
        currentSubtraction := goal - currentValue
        requiredValue := goal - currentSubtraction

        ix, ok := processed[requiredValue]
        if ok {
            return []int{ix, index}
        }

        processed[currentSubtraction] = index
    }

    return []int{}
}

Now, let’s uncomment all of our test cases and run them one final time:

$ go test -v ./...
=== RUN TestTwoSum
=== RUN TestTwoSum/test_0_-_TwoSum_should_return_expected_output
=== RUN TestTwoSum/test_1_-_TwoSum_should_return_expected_output
=== RUN TestTwoSum/test_2_-_TwoSum_should_return_expected_output
map[]=== RUN TestTwoSum/test_3_-_TwoSum_should_return_expected_output
=== RUN TestTwoSum/test_4_-_TwoSum_should_return_expected_output
=== RUN TestTwoSum/test_5_-_TwoSum_should_return_expected_output
--- PASS: TestTwoSum (0.00s)
    --- PASS: TestTwoSum/test_0_-_TwoSum_should_return_expected_output (0.00s)
    --- PASS: TestTwoSum/test_1_-_TwoSum_should_return_expected_output (0.00s)
    --- PASS: TestTwoSum/test_2_-_TwoSum_should_return_expected_output (0.00s)
    --- PASS: TestTwoSum/test_3_-_TwoSum_should_return_expected_output (0.00s)
    --- PASS: TestTwoSum/test_4_-_TwoSum_should_return_expected_output (0.00s)
    --- PASS: TestTwoSum/test_5_-_TwoSum_should_return_expected_output (0.00s)
PASS

And now, we only ever loop through our nums slice once! We can characterise this Algorithmic Complexity as Linear or O(n), which is a much better solution.

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

Table Driven Tests

Si — Tue, 03 Dec 2019 15:48:30 +0000

In this article, we’re going to discuss the table-driven test strategy in Go, although this could easily be applied to other languages. Before reading, you should have an understanding of what Testing is.

Let’s start by creating a function that takes a string, and returns the reverse of it.

// ReverseString takes an input string and returns it reversed
func ReverseString(input string) string {
    runes := []rune(input)
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
        runes[i], runes[j] = runes[j], runes[i]
    }

    return string(runes)
}

As is common practice when we want to ensure a function does what we expect it to do, we'll add some tests.

If we weren't going to use the table-driven test approach, we might write our tests like the below (using subtests to break each test up into its own section):

func TestReverseString(t *testing.T) {
    t.Run("abiglongsentence should return ecnetnesgnolgiba", func(t *testing.T) {
        input := "abiglongsentence"
        expected := "ecnetnesgnolgiba"

        output := ReverseString(input)

        if output != expected {
            t.Errorf("Expected %s to return %s, but got %s", input, expected, output)
        }
    })

    t.Run("word should return drow", func(t *testing.T) {
        input := "word"
        expected := "drow"

        output := ReverseString(input)

        if output != expected {
            t.Errorf("Expected %s to return %s, but got %s", input, expected, output)
        }

    })

    t.Run("山上的人 should return 人的上山", func(t *testing.T) {
        input := "山上的人"
        expected := "人的上山"

        output := ReverseString(input)

        if output != expected {
            t.Errorf("Expected %s to return %s, but got %s", input, expected, output)
        }

    })

    t.Run("The quick brown 狐 jumped over the lazy 犬 should return 犬 yzal eht revo depmuj 狐 nworb kciuq ehT", func(t *testing.T) {
        input := "The quick brown 狐 jumped over the lazy 犬"
        expected := "犬 yzal eht revo depmuj 狐 nworb kciuq ehT"

        output := ReverseString(input)

        if output != expected {
            t.Errorf("Expected %s to return %s, but got %s", input, expected, output)
        }
    })
}

This doesn’t look great; we’re duplicating a lot of code and it’s not exactly easy to see all of our test cases in one glance. If we extended this test to 100 different permutations, we’d have to scroll down the entire test looking for the different input strings.

Luckily, our ReverseString method is small and simple so our tests are also simple, even if we are duplicating a lot of code.

Adding additional tests is straightforward, but we’ll be adding at least eleven lines of code for each new test case. Let’s look at how we can utilise the table-driven test approach to reduce the duplication and make it more readable.

func TestReverseString(t *testing.T) {
    testCases := []struct {
        input string
        expected string
    }{
        {input: "abiglongsentence", expected: "ecnetnesgnolgiba"},
        {input: "word", expected: "drow"},
        {input: "山上的人", expected: "人的上山"},
        {input: "The quick brown 狐 jumped over the lazy 犬", expected: "犬 yzal eht revo depmuj 狐 nworb kciuq ehT"},
    }
    for _, tC := range testCases {
        t.Run(fmt.Sprintf("'%s' should return '%s'", tC.input, tC.expected), func(t *testing.T) {
            output := ReverseString(tC.input)

            if output != tC.expected {
                t.Errorf("Expected %s to return %s, but got %s", tC.input, tC.expected, output)
            }
        })
    }
}

First, we make a slice of structs, that specify the input into our ReverseString function, and the expected result. Then, we loop over the items in the slice and run the same test logic we had before, except this time we only need to define it once.

Adding a new test is as simple as creating a new item in our slice, and our for range loop will handle the rest.

CodeTips is Changing

Si — Mon, 02 Dec 2019 18:02:04 +0000

Today, we're happy to announce three important changes to CodeTips.

No More Ads

We've come to the decision to remove all the Ads from CodeTips. Although we received no negative feedback, we feel they were getting in the way and we didn't think there was enough benefits to keeping them.

Instead, we've launched a Patreon page. If you'd like to contribute, we'd be very grateful, but there is no pressure whatsoever.

Comment Integration

We've added Disqus integration, so you'll be able to interact with the CodeTips writers directly through their articles.

No More Journeys

When CodeTips started, we wanted to provide a place for absolute beginners to come and learn the fundamentals of programming.

Originally, we thought the best way to do this was to create a specific "journey" that each programming language would follow. That meant that learning Go and JavaScript would follow a very similar path, and should help our readers understanding.

We are now changing that plan. We believe the articles we have already created provide a solid foundation for anybody wanting to pick up the basics, and now we're going to focus on each language individually. Our writers will now be able to create the content they want to create, for the language(s) they want to create it for. This means that our Go articles will move at a completely different pace to our Python articles, and may be on completely different topics, but we believe we'll be able to provide more quality articles this way.

Basically, we're moving towards a more traditional "blog" approach. This week you might read about Go pointers, next week you might learn the difference between the double equals (==) and triple equals (===) operators in JavaScript.

What does this mean for our readers? Hopefully this means more quality articles, on topics that you want to read about.

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

I don't code outside of work

Si — Sat, 30 Nov 2019 08:52:24 +0000

I've been a developer for about 6 years now, and I love my job. I've found a decent company, an awesome working environment, and I actually enjoy being a software engineer.

Unfortunately, in this industry, there can be an expectation that you'll be doing it in your own time, on your own projects, to keep up with new technologies.

Well, I'm here to tell you it's not a requirement to being successful.

Sure I've done my own projects, with varying levels of success, but they were born out of interest not requirement.

I have a young family, so any time not spent working goes on them. I could have probably learnt {insert newest JavaScript framework here}, but personal life is important.

Put whatever time you can into it, and don't feel guilty if you can't give more.

CodeTips strives to help beginners, with zero or very little experience, learn to code.

We do cross-post to other sites to reach a wider audience, but why not subscribe to our newsletter and get the newest articles straight to your mailbox?

The original source for this content is CodeTips. The original content is kept up-to-date, but other sources may not be the latest version.

3065 followers

Si — Sat, 23 Nov 2019 15:20:20 +0000

The last time I properly checked, I was on ~1000 followers, and I've just realised I've now surpassed 3,000.

Firstly, thanks to everyone that has hit the follow button.

Secondly, Dev is clearly helping people reach wider audiences; I don't think I got higher than ~50 followers on medium.

Thirdly, to those that are following me, I know I've not really blogging for a while. I recently had a child and started a new job, so have really struggled with finding the time. But, is there anything specific you'd like to see from me next?

Fourthly,and lastly, a shameful plug -you can also find me on Twitter at devdrake0 and check out CodeTips (@realcodetips)