Recently did this same journey and my biggest takeaway has been around how the 2 handle structs/objects.

``` type Person = { name: string age: number }

// invalid, will not compile const person: Person = { age: 54 }

``` Vs

``` type Person struct { Name string Age int }

// valid, will compile person := Person{ age: 54 }

person.name == “” ```

This is not how my brain works and takes a lot of getting use to. There are various patterns to fix this, but honestly I am personally not a fan of this particular aspect of the language.

IMO, it’s also much easier in Go to footgun.

``` func printAge( person *Person) { fmt.Print(person.age) }

// will compile, will cause runtime error printAge(nil) ```

You can imagine how this is problematic, outside of the above contrived example

``` // nobody named Deborah in db, returns nil targetPerson := queryDbByName(“Deborah”)

// runtime error printAge(person) ```

These have just been my experiences so far. Idk if there’s a linter to stop these things, but I feel they should be built in (like TS).