DEV Community: Nando Theessen

How You Can Pick Up New Languages Quickly

Nando Theessen — Sat, 23 Mar 2019 22:43:15 +0000

One of the biggest misconceptions about learning a new concept, language or framework is how you can do so effectively.
I've learned with and worked next to a lot of great people that had an account with any of the big learning sites or had a big library of courses on technologies that wanted to learn and I myself had a similar library.

Sadly - in most cases - just following a tutorial or a course does not make you better in something new.
Often times it absolves you from thinking yourself and thus hampers your progress rather than speeding it up as you had hoped.

My Situation

I've recently started a new position in a company that uses a stack with which I have never worked with.

In my eyes, it’s a great opportunity, and I think a lot more people could benefit from considering jobs that they think "they aren't suited for".

A lot of companies out there are willing to teach you syntax on the job if you are a good candidate.

For them it comes down to if you are a good candidate: if you are understanding the underlying concepts, are coachable and a good team fit they will hire you regardless.

In this article, I'd like to show you how I approach learning a new language and how it enables me (and hopefully you) to contribute to something quickly and will do so on the example of Golang!

1: Find Resources That Are Useful

Finding good resources feels surprisingly hard these days. This mostly stems from the sheer amount of content that is out there.
On any given topic there are at roughly 15 video courses that take you from being an absolute beginner to mastery in 4 hours and around 200 blog articles accompanying them. Selecting out of that many options is hard.

What I like to focus on besides the basic syntax is how to translate concepts I'm already familiar with and see how they are implemented in the new language. This helps me develop a mental model of what is going on quickly.

My next step revolves around best practices.
These following resources are what helped me with Golang in particular.

Intro To Go

A great intro to the language's syntax is the official tour that you can find here.

It takes you through the basic concepts of the language and has concrete examples and exercises that help you familiarize yourself with the basics.

I think it's a great resource regardless of if Go is going to be your first language or you've worked with others before. Although it will be more challenging of course.

As a next step, I'd recommend at least reading through How to Write Go Code which is also part of the official resources.

Beyond The Basics

One thing that really helped me was reading up on best practices in Go and comparing those to other languages I have worked with.
Translating concepts I'm already familiar with into the new context helps me understand what is going on in a new codebase or how to design the new service I have to write for example.

A great resource for this would be Effective Go. I've also found a few talks that really helped me understand the Go ecosystem and gave me an in on the quirks that I should be looking out for: Go Says WAT or Things in Go I never Use.

2: Build Familiar Things!

For Golang, my first project was a REST API. It's a fantastic way to learn how the language handles HTTP requests, what tools are useful for this and it's simple enough to not take up multiple days of your time.
Also, APIs are used everywhere and are likely a core part of your (future) job.

In general, I think it is a fantastic idea to use a simple version of something you are already familiar with and port it into the language you are trying to learn.
If you are super comfortable writing an API, algorithm or toy program you can focus on the key differences and learn from them!

Logging Request Bodies For Golang REST APIs

Nando Theessen — Sat, 16 Mar 2019 14:43:50 +0000

Go does not support JSON natively, so our first step should be to learn how to decode the JSON format.
Thankfully Go comes with the "json" package which makes decoding easy and convenient to do.

A Basic Example

This simplified example comes from the Go docs:

const jsonStream = `{"Name": "Ed", "Text": "Knock knock."}`

type Message struct {
    Name, Text string
}
var m Message

dec := json.NewDecoder(strings.NewReader(jsonStream))
err := dec.Decode(&m)
if err != nil && err != io.EOF {
    // handle that error
}

fmt.Println(m.Name, m.Text)

After handing our JSON stream over to a Reader, we're using the json.NewDecoder() and dec.Decode(&m) to "translate" and read our data into the previously defined Message format.

The Request Body

When handling an HTTP request, we are doing something very similar already which helps us skip a step here.
I'll also show you a nifty tool, we'll be using for our logging output!

func (h *handlerShared) doSomething(w http.ResponseWriter, r *http.Request) {
    // we still need a type definition for the receiving struct! 

    type Request struct {
        CompanyName string
    }
    // create a pointer to said struct
    req := &Request{}

    // create Decoder to "translate" our data
    // you probably spotted the step we can skip already!
    // if you haven't: the request body already comes in a Reader,
    // we don't have to hand it to one!
    decoder := json.NewDecoder(r.Body)

    err := decoder.Decode(&req)
    if err != io.EOF {
        // handle the error 
    }

    // At this point, we can a) access the data we read into our Request
    // struct: 
    fmt.Println(req.CompanyName)

    // As well as log it using the logrus logger I've included on my handlers                    
    h.log.WithFields(logrus.Fields{
        "host":     r.URL.Host,
        "path":     r.URL.Path,
        "header":   r.Header,
        // as you can see, there is a lot the logger can do for us
        // however "body": r.Body will not work, and always log an empty string!
        "body":     req
        // this is why we'll log our crated struct instead.
    })
    // send a response!
}

This is a very easy example, but should give you a good idea how to implement logging for your endpoints.

I've seen a few examples that go an extra step and read the body into an input buffer, to then cast it to a string. That is not necessary.

If you know of an easier way to achieve this or have any other feedback please let me know. I'll update this article and am always eager to learn!

My Way Into Engineering - Part 1

Nando Theessen — Sat, 02 Mar 2019 12:17:03 +0000

What I did before becoming a Software Engineer

Before I decided a career change was in order, I dabbled in a lot of things.
After school I joined a PR agency in Berlin, raising funds for non-profit organizations like Amnesty International, the WWF and the SOS Kinderdörfer. After a few successful years, I turned into a professional online poker player and even owned my own small startup for over a year before closing shop.
I did not have any experience when it comes to engineering, although I'm pretty good with computers in general.

Since being a poker professional really can't be associated with stable income and the startup - while being a great learning experience - ultimately failed and we were planning to start a family, I needed to look for something more permanent and stable.

My Next Steps

During this time, I discovered that there were quite a few coding bootcamps that had started growing here in Germany.
Some of them taught web development, some taught Java, all of them cost quite a bit of money and were 9 weeks long.
On first glance this looked like a very good fit for me, it would give me a shortcut into a new industry, allow me to work with a computer and probably get me the job I was looking for.
They all worked with technology that I didn't quite like (funny how that works, I had no idea about things back then but already had an opinion 🤷🏼‍)

The School I Ended Up With

Still, I registered with one of the bootcamps here in Berlin and was about to start when I learned about Lambda School.
Their program came with a lot of promises that I found interesting.
It focused a lot more on computer science, taught JavaScript, Python and C and best of all there were no upfront costs.
It sounded a bit too good to be true to me to be honest.
As it turned out they weren't even taking international students, so I prepared for the start of my bootcamp in Berlin.

However, all of that changed quickly when Karen Zachary (who is fantastic and in charge of admissions over @LambdaSchool) reached out to me and told me that I was one out of 5 international students selected to join as part of a pilot project.

How School Was Like

During the following 7 months I learned a lot

We started with simple HTTP & CSS projects to get to know web development, but quickly entered the world of JavaScript, then React and then Express to become Full Stack Developers.
A day consists of two hours of instructor Q&A, a project to build, stand ups, pair programming with a sprint challenge every Friday to prove you understand and are able to use what you've learned.

Now, as you may have guessed this wasn't easy.
Sitting down every night from 5pm - 2am (the downside to join a school that is not yet in Europe) and learning foreign concepts, working with them and maintaining sanity at the same time was one of the toughest challenges I faced in my life.

But it was also one of the best. Not only did I learn a whole lot and am a Software Engineer now, but I also made a bunch of friends whom I share this amazing experience with.

How About You?

If you are looking for a way in and are living in the EU or the US I can wholeheartedly recommend Lambda School. There is no upfront cost - they get paid once you've landed your first job and exceed the salary cap - and they have an amazing team of instructors and project managers that help every student become the best engineer they can be.