I'm Coming Around To Go...
Vložit
- čas přidán 5. 03. 2024
- After years of being, well, not fond of Golang, I think I'm seeing the appeal. I doubt I'll touch it (still spend my days in Typescript), but the benefits are clear. Sorry Rust.
Enjoy reacting to this one, Melkey
Check out my Twitch, Twitter, Discord more at t3.gg
S/O Ph4se0n3 for the awesome edit 🙏 - Věda a technologie
Like a certain other programming youtuber once said: "GO MENTIONED!"
LESGO!
"FIIIIIVVVEEE DOLLARS A MONTH"
Primeagen
"Welcome to Cosco"
Lua will always be the real party starter.
TBH the real strong points of Go are:
- single static binary (the EASIEST for deploy)
- simple language (few keywords)
- cross compiling is as easy as set GOOS and GOARCH
- Pretty decent performances (not the best, not the worst)
- MOST of the stdlib has consistent behavior
- MOST of the 3rd party packages have consistent behavior
- Simple and effective package manager
- Perfect fit for backend services, literally, it is perfect
- Absolutely perfect retrocompatibility (Rust, Python and TS haven't guaranteed it even with minor or patch version)
About dev velocity: i have spent a lot of time time dealing with TS, npm errors and stuff. By that time, i finished two services in Go.
That's subjective, but a consistent ecosystem is a great value to me.
PS: esbuild is not going to solve the compilation problem, since the DX is slowed down by the TSC which is slow AF. Esbuild transpiles without type checking.
Rust also can build static single binary, but takes 10x more time, plus needs relying on muslc, which is not as loved as glibc in linux space :)
the single static binary is a killer feature that is underrated.
currently working on something interesting where we're trying to tackle the "better than WordPress" problem where WP is so easy to install that non-tech can reasonably deploy their own instance of WordPress.
Go is the strongest candidate as it compiles into a single portable binary, but it can also carry contentful stuff (like JS files, images, and many others) in its binary. So, a Go Binary program effectively becomes runnable zip files.
technically they do some breaking change on the stuffs with buggy behavior (fixing, to be precise). Yes, no one should use those buggy behavior anyway, but it also mean that you can't carelessly update the project without some checking where external package might use that thing.
Upvoted
Go was literaly our only option. We use Go with AWS Lambda and is not only about CPU performance but RAM usage, even with Bun, JIT and interpreted lanjuages like JS and Python can't handle 1M+ records in a 256mb RAM container, even Java or C# have a memory overheat due to their VM. So basicaly Go was our only alternative to cheap microservices with a good support for AWS SDK and low learning curve. Also, cross-compiling works great, since we use ARM based Lambdas, reducing the cost even further, all in just a 10 - 16 mb binary.
I've heard of teams using graalvm instead of the JVM with some success
Yep
Iterate fast and prove the solution with go
Then optimize with zig once proven
Win
@@jordanstewart225 My experience is a few years out of date and I didn't dive super deep, so you'll probably want to double check, but Graal isn't a complete replacement from what I remember. It definitely helps with cold start times, but it's still real chunky in terms of binary. I don't remember how memory consumption compared though. I'm very much not a fan of Go, but for lambdas it's 100% the choice I'd go with since anything else that hits all of thee pros Go has doesn't have anywhere near the same market share. Which now that I think of it is kind of just Go in a nutshell. The one pro of Go in lambdas versus Go on a server is that since lambdas are relatively small you don't run into some of the annoyances of scaling Go codebases.
@@jordanstewart225 The thing that makes me anxious about the idea of using GraalVM is... am I going to run into a situation one day where my program doesn't run on GraalVM anymore because I need to use a library that can't run on GraalVM because it uses reflection?
I suppose I could just switch from GraalVM to a traditional JVM at that point, but what if I'm really relying on the small memory footprint, small binary size, or fast startup? Is that going to be feasible? Is my project going to hit a brick wall because of a compromise that's impossible for me to make? And then it needs a rewrite?
I will say, Go has one of the best AWS SDKs of any language I've used.
I've been programming in Go for 2 years now, and the book 100 Go mistakes and how to avoid them describes it quite fittingly from my perspective: "simple to learn but hard to master". The language constructs can be learned very easily, but learning to write solid idiomatic Go is pretty hard.On first sight the pull requests from juniors and seniors appear similar, but at my job, in a team of around 30 developers with varying experience, it is also easy to identify who has more Go experience.
Damn. Thanks fornsharing the book. I was looking for a good reference to prevent bringing my mind from other languages to go
I would expect this to be the case for almost any language. What language can you pick up and write like an experienced dev? Definitely not TS and definitely not Rust.
@@manofqwerty I have not stated anything contradicting this.
Absolutely agree. Because Go's ecosystem isn't absolutely dominated by one paradigm (think about Java's Spring, .Net for C#, React for TS/JS...), it's infinitely easier to write shit Go code than any other high level language I have worked with.
So what you're saying is, people who have more experience in the language are better?
This is truly a revolutionary and unique thing about go.
I see your points about type system and other choices Go made but in general I’d say Go has even greater velocity than JS/TS. My justifications are as follows:
- You don’t need to worry about the tooling around your dev environment, such as prettier, test runner, package manager, etc. because all of them come with the language.
- The language itself is really small and one can learn all of it in one day. It’s even possible to read the whole specification doing that.
- If you use something like htmx, then you can even get away with not touching any JS.
- The one way of doing things is especially important when you want to read an open source project’s code. Also, the community mostly shares the simplicity mentality, so projects are mostly higher quality and easy to pick up.
So, in my mind, the Go streches to the end of the velocity spectrum and they are exploring if they can also stretch to the perf end of it. The hesitation is mostly around not messing the dev velocity/ simplicity part.
I started with GO last year and came to love it so much. It is so easy if you are already familiar with another language. For web apps, I would recommend building some boilerplate and keeping it as a repo that you can pull whenever you want to start a new app.
The biggest plus point is how simple it is to set up a Go project, there is no complexity behind the scenes and things can be managed with ease because you control almost everything about your application.
exactly !. That what I don't like langues like java. it hides so much with magic and anything goes out of the boilerplate java way , good luck fixing that .
I heard people say Go is Node on steroid, is it correct?
@@ttdat89 there is some sense to it if you are starting a node web project from scratch using express and installing several third party packages to get things going. You might as well spend the same amount of time building a Go project.
@@ttdat89 but yeah if you know node then learning golang isn't a going to be a big deal. You are already familiar with fundamentals of any project and you only need to learn how to do things golang way
can you tell me some other stuff that can be build with go?
One great concept GO has implemented is errors as values, yes, they are annoying, but one day I decided to implement the concept in al my TS code with a simple helper return type that forced me to handle the error first before the actual return values were considered completely defined types, and from that moment I *never* had anything crash on me. I don't even need so many tests now because the control flow is so much better. When you throw and catch errors, you actually have no idea where the error will be caught and how it will be handled, which in itself could cause subsequent errors and crashes.
Yes! it makes error-handling explicit and defined in the function signatures. I did the same thing you did and it made my life so much better.
I do that too in JavaScript, I return an array, one value of which is an error (oftentimes just a boolean whethere there is an erro). And below the call is Just handle it like in Go. I still have try catch inside that thing that I call, but it's better this way, and in React/Nextjs which re-renders, you instantly have access to the error and not on the next render. Because with only try catch you need to set some error state inside the catch and that is only available on the next render, but what if it's a checkout button and you don't want your user to go further if there's error. It makes it easier to handle.
Yup, errors as values are the way to go. I copied the Either type from fp-ts, doing isLeft everywhere is kinda annoying but it is worth it
where can I find an implemention of this error handling in TypeScript?
@@belkocik
const myFunction = async () => {
try {
await do stuff and get data
return [data, null]
} catch (err) {
console.log(err)
return [null, err]
}
}
//usage:
const [data, error] = await myFunction()
if (error) { handle error }
I think you hit the nail on the head with "Writing Go doesn't make me feel clever." This is IMO why so few people contribute to Go projects, there is nothing to learn. Go is the perfect language to just get shit done. Its the Toyota Corolla of programming languages. Sure, some people turbo and race their Corollas, but most people just go from A to B and couldn't care less.
PS: This is why I like Go so much. C++ and JS show the personality of the lead programmer in the codebase, no 2 codebases look the same.
Coming from an enterprise space, trust me, we *don't* want "clever" people. We want predictable results built in a predictable manner to deliver in a predictable timeframe. Go fills nicely that very important role. And yes, I 've been just checking out a bit Rust, and yes, toying around with it just a bit always made me feel "turbo hacker". But you know what? Most companies and most services and most situations don't need - or even worse - don't want turbo hackers. They want engineers who build proper stuff in a proper manner.
Remember children, "boring is good".
@@PhilipAlexanderHassialisthank you. Go is the manifestation of the KISS rule. If you don't like a programming language just because it doesn't allow you to flex how clever and senior you are, then your head is in the wrong place.
@@PhilipAlexanderHassialis Being a "turbo hacker" and also an engineer who properly plans and executes on projects aren't mutually exclusive. The company where I work is entirely Rust based and I don't think there has been any point where the engineering team has not at least planned a whole project out before executing on it
Its perfectly and bureaucraticly mid, and we love it that way
@@joshmo3611ahh... to be a part of the select few... most companies/projects aren't like that.
Go is simple and practical. You don't overcomplicate it with like what formatter, linter, or framework you use. A wise man said "Less is more"
I haven't done much Go, but I use TS and Rust regularly and _strongly_ disagree with the developer velocity thing, not because it's subjective but because we often forget what it takes to make software other than "just writing code".
Correctness, edge cases and error handling, maintenance and even just "reading the docs" are all things we software engineers have to do a lot of, and all of them are easier in Rust.
Can I write a bit of software faster in Typescript than Rust, sure, if I don't care about bugs and weird behaviour, telling people what I've done or whether this will still work in a few months time.
I think that's the general mindset of theo/startups: get an mvp out the door, worry about safety later.
However when not in a startup I'd say that Rust is overall faster than TS, considering everything that goes in sw dev. I wrote a bankend for a new project in Node, and sure it was "available" faster, but then a lot of my time went into debugging and catching errors and transpiling and managing dependencies and so on. So I decided to rewrite it in Rust, and the initial version took more time, but it worked without errors (except some minor logic errors).
@@araozu Definitely agree, that's what I've seen working at a lot of "start ups" but it _can_ also be very short sighted.
The two most egregious examples I've seen in my career:
- Code that's broken, but no one realised it was broken because when you use `as` in TypeScript it doesn't actually convert from one type to another, which is what everyone seems to think it does (please never use "as" and also, dear TypeScript devs, please change Json.parse() to return "unknown" instead of "any")
- Teams ballooning under the stress of trying to add new features while dealing with the interest payments on mountains of technical debt. This is still a problem in Rust, but much much less exaggerated than TypeScript
It really doesn't cost as much as people think to do things... maybe not "right", but "better" the first time and you save yourself so much time later.
As an aside on short-sightedness in start ups, I recently interviewed at a company who took pride in not writing tests because they wanted to go fast, but also talked about how developers were frustrated at having out of hours incidents and I literally couldn't believe the person interviewing me couldn't put those statements together.
`as` is definitely the example I was going to use in my OP. Using "as" makes type casting seem trivial, but it doesn't actually check that you're right and in the best case, you get errors at runtime (but probably not where you did the "as" but where-ever you tried to use the data), and in the worst case, its just right enough that you don't get any errors, your code simply does the wrong thing and you may not use it. To do it correctly in TypeScript you need a type predicate which can be huge and easy to mess up and then you still need to generate an error when you use it. The Rust equivalent in a library like Serde is `from_str(data)?`
@@araozu keep in mind that you already solved most issues during your first version (in TS) and then rewritten it to Rust. You probably would be even slower starting from scratch in Rust just because you would have to think about more things, not just porting existing logic where you already solved things.
And on the topic of "being faster working with a language" is not really a language thing, but your familiarity with it. If I write TS for 3 years and switch to Rust for a month, I'm quite sure I won't be faster in Rust because I have all this TS experience under my belt. Developer experience and velocity is a subjective thing really, but objectively yeah Rust does solve some things better depending on your use case.
@@rand0mtv660 Great points! Gave me goose bumps. I personally think one should write everything first in TS, it's fast enough with bun and elysia or fastify and get it out there quickly. If the money starts rolling it, rewrite it in Rust or Go. I also think writing a proof of concept in Rust is a mistake, it's just too slow to use.
I've been developing in Go for a bunch of years now - 6? 7? Anyway, I love it. I came from Assembler, then C, C++, Python and now Go. I've started to learn Rust, but I learned Go to a usable level in an hour, whereas Rust is like walking with rocks in your shoes - you can do it, but it's painful every step of the way. I'm excited by rusts possibilities, and I love the correctness and efficiency of it, but it has a super steep learning curve.
As for the difficulties of writing serious projects in Rust, I've seen a number of devs, famously Prime, who discuss programming challenges that are trivial in Go but become trait monstrosities when it comes to Rust, particularly around databases and shared data.
Since you haven't done much go, why not actually spend a week and try to write something useful and productive. I'm sure you'll surprise yourself with how easy it is, and how fast you can go.
Imo that "uncanny valley" you described... also contains C# and Java themselve (+Kotlin), which all have very good tooling. Granted C# and Java arent exactly "Shiny" modern languages, but they do deliver.
Java is just horrible, but I am totally agreeing on C#. C# also goes way to the left as .Net can perform even faster than native code in some cases.
I really agree. C#'s and Kotlin's syntaxes are very similar to Typescript (if you aren't already going absolutely insane with Types in TS), but the performance ceiling is significantly higher. The performance wins in dotnet over the last few years have been pretty significant and also don't require large changes to the application to adopt those new wins.
I cannot really say wholeheartedly that JVM has "good tooling" as much as it trying to save us from itself.
Just today, I tried to have usable Java setup that does not revolve around Jetbrain's IDE. Basically almost impossible without us spending time managing heap allocation and VM Daemon on every occasion.
Skip that and you'll have unusable mess where 80% of your system memory eaten up by idle Daemons..
Problem is the mentality with c# devs, they have this oop/patterns everywhere mentality that sucks
literally every static typed language with GC. JVM based, C# based, Haskell, swift, dart, even JS with the new static Hermes is literally in that "uncanny valley".
Compilation speed does matter. I worked on a team that used Go, and I could push to a dev branch and it tested, built, and deployed to the dev environment before I could bring up the CICD page lmao.
Yes GO is a programming language. Thank you for coming to my TED talk.
Go’s dev velocity is by far better than Typescript’s when you are trying to build a production grade tool with robust fault tolerance and synchronization. You might go faster in typescript, but are you confident you are handling every error graciously? Are you sure if you need to change a library or two it’s not going to take weeks? Are you sure that the new developers can read through your codebase and understand in an efficient manor. This is where I feel Go has the edge.
Also it’s quite amazing to not think about asynchronous code at all. No function coloring is one the of best things about Golang. Sometimes making a function async in Typescript propagates all over the codebase requiring major refactoring.
Go code is not intuitive and easy to read
How do I make structs with required fields in go? I remember trying it for some time and it was such a deal breaker with it's zero values
@@Nekroido the most wrong statement ever
@@rerere1569
type person struct {
age int
name string
surname string
}
// Required to use New function because the person struct is not exported
func New(age int, name, surname string) person {
return person{
age: age,
name: name,
surname: surname,
}
@@rerere1569 You could use the validator/v10 library to label the fields with validate:"required"
For those not anti microsoft, you can write zero garbage collection C# and go extremely fast. Like the kestrel web server with does zero allocation request handling.
I've been loving go. Pointers are weird, but once I realized they are an "opt in to mutability" flag, it all clicks.
I find the Go code I write is easy to understand 6 months later. The language pushes me towards simplicity. Delightful! I just wish the type system could catch nil pointer mistakes.
THIS. I wish it had type guards against nil pointers, interfaces etc.
What do you mean by opt in to mutability? To clarify, I fully understand how references work in Go. I'm just not sure how exactly thinking of them as a mutability marker makes them make more sense.
@@arobie92 The point about mutability comes from Jon Bodner's *Learning Go*, a great intro to the Go idioms. Initially, pointers seemed foreign to me. What Bodner clarifies is that other languages also use pointers, they just hide them from the user. Consider this Python code:
class MyThing:
def __init__(self, name):
self.name = name
def rename(thing):
thing.name = 'a totally different thing'
def main():
thing = MyThing('steve')
print(thing.name)
rename(thing)
print(thing.name)
main()
python3 main.py
steve
a totally different thing
In Go, the syntax of pointers make mutability explicit. By default, function arguments are immutable copies:
package main
import "fmt"
type MyThing struct {
name string
}
func rename(thing MyThing) {
thing.name = "a totally different thing"
}
func main() {
myThing := MyThing{name: "steve"}
fmt.Println(myThing.name)
rename(myThing)
fmt.Println(myThing.name)
}
go run main.go
steve
steve
The explicit syntax, I realized, has my best interests in mind! The design clicked, the mystery around the asterisk went away.
Anways, I am still very junior, and will likely run into some quirks. But for now, I'm enjoying Go.
@@user-il8jv5gh1u One thing worth noting is that you can use interfaces as a guard against nil pointers. If you define an interface and use value receivers instead of pointer receivers for the methods defined in the interface, it results in only values being able to implement that interface. It would be impossible to use a pointer to an instance of that struct for that interface. It would only be possible to use a value of that struct. The compiler would guide you.
@@arobie92 It sounds like what they mean is that mutability is the thing that is enabled for them when they use pointers. In reality, what people are opting into when they use a pointer is for memory to be shared (e.g. from a calling function to a called function). That can help with things like memory efficiency (not copying around big chunks of data needlessly) and allowing a called function to mutate something. It's the mutation that they really care about.
the biggest reason I'm an advocate for making a full breaking change go v2 is to allow for the breadth of that uncanny valley it covers to widen. expanding the type system coverage to make it better to use, as well as adding performance things like arenas, or better methods of excluding the gc and forcing more efficient memory. the fact that go has calcified as it has, is both it's biggest feature and it's biggest detriment imo.
also, today I learned that there's a good chance I've worked on the same code as Theo, given the tiny bits of exlixer I've touched at twitch lol.
My experience has been Python for the past few years because the tasks at my job were able to be done in an afternoon with it. Incredible velocity and happy management. What I learned was having to dig up one of these projects to add a new feature was painful. Moving fast in a dynamic language is a blessing and a curse.
I used go for advent of code and was impressed that it compiled to windows and Linux out of the box and it was fast. Both in performance and velocity. This year I have replaced 2/5 of my python services in an etl pipeline which allowed us to turn off half the VMs. Adding additional features has been easier with less bugs.
"if you look at this contribution graph" wow, that reflects exactly how much I want to contribute to someone's Go codebase 🙃
I will enjoy reacting to this :)
Let’s goooooooo, Go mentioned. But imma be honest, go’s simplicity is what I like. My team was able to migrate from Python to Go quickly with me being the only experienced Go guy.
Golang is so trivial, I've built simple video server to play random video/music on my harddisk in browser. I did it in 5 minutes or so. No dependecies, just plain go and it's stdlib. not even http framework like echo or something. And you know what, it only cosume less than 10mb of memory, even when playing videos
Go is simplicity. Currently, this is gold
on his ts v go v rust video, prime said golang was the language he had the least experience in and the one it took the least amount of time to write.
He said rust was his most used language, and that i took around 5x the time to write it.
and go won in that performance comparison, because apparently he didn't write rust the "correct" way, which just shows that in most cases, go actually ends up being faster eventhough rust has the potential to be faster.
Go is 90% the speed of Rust and 90% the productivity of dynamic languages.
I am learning a bit of go. Honestly very nice languge and a lot of the patterns you would use In C still hold.
You also have very good c Interop.
So I can see a world where you use go and when you think you need preformance you take out c.
With unsafe go and c you can probably do stuff very close to full manual memory managment.
IMO C# is one of the best Languages for the "Valley", I've used it for a CAN-Bus Hardware driver as well as a Blazor SPA, and work mostly with process control, and desktop applications
Thank you very much Theo for this insight with the Performance versus Developer Velocity spectrum. As a web dev myself leaning towards C++ thought of learning manual memory management language so that "I have easy time" with high level languages. This video will help me decide what to do after I am done with what I wanted to learn from C++. If the thing I am making is super rigid sure I will pick Rust or C++, if the thing demands constant iterations safe bet would be TS/JS but if this thing is amphibious like we will have iterations but not as much as a JS framework and not as rigid as some OS firmware in this term Go becomes a lucrative option.
Rust compile times - are sloth-slow only if you're compiling for the first time, often every time fresh, inside a Docker container. Instead, if you're repeatedly compiling on a development machine during normal development, incremental compilation times are pretty fast. Not Go fast, but pretty quick. As for time-to-market, yeah Rust has quite a bit more friction than Go, and even slightly more than C++ I'd argue.
As for C++ vs. Rust, I'd argue that developer velocity / friction with C++ varies a lot with boundary conditions. If your project uses a package manager and employs decent tooling (static analysis, sanitizers) to mitigate most common footguns, and you have a small and decently experienced team, I agree that C++ will be more nimble than Rust.
If you manage dependencies with CMake or some "bespoke" build environment, without state of the art tools and have a more heterogeneous team in terms of experience, I would bet that you get things out the door significantly slower than in Rust.
ONE OF US,ONE OF US,ONE OF US,ONE OF US - Really nice overview of Go's use-cases. Thanks a lot
Excelent insights. Thank you. I am in a startup using typescript /NextJS and adopting Rust for backend services and desktop apps integrated with local llms and vector databases and Rust seems like an excelent choice. Also, Rust makes me feel just like you felt about Elixir. Totally agree that rust is not for prototyping or testing approaches or concepts. I do it in typescript then write in Rust. Amazing how, if it compiles, it works with no bugs. At least it gives me that strong impression.
Regards from Brazil.
I didn't think I'd love it and there are a fair few very strange decisions made in the language design (no immutability? that weird loop variable footgun which has been fixed now, small thing but gofmt not putting spaces in 1+1, etc.), but the concurrency is just so easy and fun. Building with Go feels like a breath of fresh air coming from TS as well. Everything is just so... simple, and fast! I always thought the whole if err == nil would bother me more as well but it sure beats exceptions. Copilot helps a lot with that stuff as well. It also is kinda nice to go back to writing just regular ol procedural code when everyone else is going in the functional direction. It feels cool at first to write arr.filter(...).flatMap(...).reduce(...) etc. but it does hurt me deep down knowing how much memory I'm wasting
You've explained your thoughts very clearly and they make a lot of sense, thanks theo
When you watch theprimeagen videos too often, you will feel JavaScript is too low and TypeScript is just a JavaScript linter and Rust is too hard and Go is just fit for my level.
The thing that fits in the middle right is going to be Java/C# (virtual machines that can have pretty good optimisers). The thing middle left is Golang. It's a compiled language with a garbage collector but doesn't have access to creating your own good data types.
Types are great in Go! It was a conscious choice to leave out inheritance which makes a mess of types anyhow. Most people know at this stage that Composition has proven to be much better than Inheritance when constructing more complex types.
I would love to see you and Low Level Learning go into the rust compile time rabbit hole!
I started out with Rust about a year ago. As in starting to code in my 30's without much prior knowledge. As you talk a lot about velocity/speed, i wanted to say that i think Rust might be slower to code, but in my experience its actually a language to learn coding with pretty fast! And i don't even think its over complicated since I didn't learn any other language really :D And the Rust compiler taught me everything I know about coding by now
Axis of reliability would also be interesting on the other end, where I'd argue writing very fast developer velocity Python will often be way slower than fast velocity JS/TS, since you're almost never running in a JIT. I often first write something as a simple for loop just to test out ideas, then rewrite the loop with Numpy functions. (Could be skill issues) That first version will definitely be slower than Node code.
Theo Go back-to-back
You know it's because of the mustache
I'm certainly interested in that rust compile time video. What an irony, it can compile other languages faster, but not itself...
Also sending to a nil channel blocks forever, lmao cut to me laughing for an entire day like Mr. Burns in that Simpsons scene
the way you explain stuff Theo is just perfect .
The first thing you mentioned for not liking Go is exactly one of the reasons it’s so good 😂 it’s a preference I guess. But I like that you learn Go and you can work on any Go project, you don’t have to be a “framework engineer”
Exactly, the senior junior thing doesn't exist in Go. Its just imperative programming paradigm. That's why its often debugging C is lot easier than C++
This is a good take. I listened to a presentation on Zig - and for one-shot CLI command's, memory safety isn't necessary at all. In fact, you can purposefully leak memory and just let the operating system clean it up once you are done. So if you want maximum possible speed, but a better developer experience than C or C++ then Zig would potentially be a better choice than Rust. But I'm also really interested in Go too. Maybe Go is an easier transition for Javascript devs if they want to help contribute - although this hasn't been the case as you pointed out for esbuild.
Yeah... Zig is pretty easy to get going especially if you just leak or use a giant arena. There's some annoying first-time user edges that will piss off some people, which is unfortunate, but you can model your types almost as well as typescript (expressive but simple), and crank the speed to 11 when you need to optimize.
A video on the difficulties of rust compile speed would be really cool. As someone who has dug into the internals of it before but not in a while, I'm interested in what I've forgotten and what has changed.
Your video sparks my interest in go. When I heard code from junior devs and senior devs was not much different, my tiny brain was just filled with joy
When people rebuild tools in Rust, I think they were afraid that Go would eventually become the performance roadblock
As a former Go hater myself, I’ve come around to it and I am far more productive in Go than I ever was in TypeScript. I do disagree with many of your views but you do bring up some valid points to consider
I've seen this from a kilometer away. While my team was bragging about "We learn it because it's fastest, because it's hard", and then being stuck, not going anywhere, I was more like "Enjoy it then, masochists, I'm off to Go land"
Even just learning the tradeoffs exist between languages is a massive help for newer devs. Thanks for all your insights. I'm coming to go from js/ts, and view rust as a YAGNI language. All depends on use case, of course. Time will tell.
Can I just say, I think Swift would span the farthest in that diagram from both having very solid performance and being very easy to learn and use. And in its latest versions it's focusing a lot on adding better and better compiler guaranteed safety against data race conditions in concurrent and multi-threaded code.
This video seems to solely focus on Go being exactly what it sets out to be.
Go aims to be simple and plane while bringing a good balance between performance and velocity, I really think you are under valuing Gos velocity.
Yes Go does not have as much top end development speed as TS or Python but it really reels it back in in the long run on consistency.
For me at least my job being a marathon rather than series of sprints has really increased the quality of my work life, yes you miss out on some of the excitement but over all the outcome is better.
As someone who has spent a *long* time working with Go, Garbage Collection is almost always not your performance bottleneck. It's an easy one to blame, but it's usually, in most use cases, not the actual problem. Most Go software is going to be dealing with data I/O that has latency an order of magnitude or more above the penalty created by the Go run-time. It's easy to create benchmarks that show that Rust is *much* faster, but the actual efficiency and speed in real-world code is minimal, and the development / iteration time becomes more important.
If you're doing DSP, massive amounts memory bound processing, memory-restrained programming, then Rust will definitely be the right choice. For "normal" use, Go is practically as performant as Rust, and much faster to iterate.
i was planning to study go from past 3 weeks, guess i will give it a try now!
Honestly, I'd go for Go just cause Rust make me feel stupid.
Something you're overlooking is that developer velocity is also impacted by how easily/confident one can be doing changes in a large codebase.
Typescript is a massive improvement over JavaScript there, but it's just not at the level that Rust is.
Great video. Describes my love-hate relationship with Go really accurately
i need to go as far as i need... that's go, it is just good enough for most and easy enough to go fast. no type massaging, no massive frameworks in the way
I don't know many orgs that re-wrote all their stack, so I think this seems like a strange discussion talking about a line to rewrite at.
Can't be too far out either way if you Go for the middle.
I found that it's really easy to make large changes in Go so the type system is really helpful to finding errors before you even need to compile, it also helps you at runtime, something python, JS, TS need extra libraries to achieve with greater complexity which comes along with them
For sure. I think the fact that esbuild is maintained effectively by one person, yet the newest latest and greatest rewrites are struggling massively, says a lot about progress within the space. It's just like you said above dev velocity. It's interesting to see Rust excel in other parts of the space, like WASM, though. It wouldn't take more than a TS to Rust translation layer to have me writing Rust fulltime.
The reasons for Rust's compilation time are very interesting. It is a combination of the extensive type system, static analysis, and relatively little parallelization. Take a look at it, the Rust compiler is really fascinating.
These videos came at the perfect time for me in my decision making wrt next project tech. Thanks.
I think the contrast is that the middle is a perfect place to have a performant enough language and overall ok velocity, we don't invest too many time on building the project and it doesn't stink on performance
In serverless architectures, go is the best language for now. Near Rust cold starts, very low memory usage, quick, cross compiles to arm64 Linux from any OS without a fuss. Has good ecosystem of libraries. A large enterprise integration project written in Go processing tens of millions of messages costs less than 10$ a month in AWS Lambda costs and if you want to have a permanently running container - a naked go container that has less than 1mb overhead on top of Go binary gives you incredibly fast container start times and possibility of usage of the lowest cost ec2 instances.
Developer performance will always depend on a developer, a person with mature C++ ASIO experience would be able to whip out a production level server on top of ASIO as fast as intermediate Go/TS developer.
Hey Theo, nice to see you talking about languages other than typescript/javascript system, your rust video was also based (good take and advice). I'm curious to know your thoughts on a language that is known as the one created to replace querky javascript and also has types DART.
From your past tweets I understand you don't like flutter, apart from that what are your thoughts on Dart the language. If there come a parser that painlessly parses dart to js or google just decides to support dart in its browser with DOM APIs, would you consider switching to it or typescript will still be your choice.
(PS: I've not used DART much, not a flutter dev so forgive me if I'm wrong about some assumptions).
On your (brilliant) spectrum diagram, I think lisp would be a black cube suspended in a translucent sphere. Or a phase-shifting keytar. Is SBCL fast or slow? Is it super productive to work directly in ASTs or is it the very definition of mental stack overflow? The answer mu surprise you.
go also provides good tools for code quality. i just love built in test solution. it make scalability way higher than js and python.
i also do not want to do extra work with rust or c++.
i think go sits in great place and it will be next big thing in web dev
From what I can tell nobody enjoys writing go, but they enjoy the result of it
the fun thing is, i always want to go back writing go whenever I have some weird issues with typescript or tons of complex java dependencies or whatever. sure, go isn't exiting and in some cases annoying, depending on what you wanna do, but the simplicity is nice in its own way.
@@MrLordLowbob the "fuck it, ive gotta get this done" moment
though i wonder why Theo barely acknowledges the standard GC langues in his graph explenation
For me, I don't hate writing go, its just meh, but i enjoy the results and enjoy seeing whatever i'm doing work much more with GO because of how fast i get to that point. I also think its worth mentioning that other languages can be frustrating in a way that GO simply isn't. You might say at that point that switching to GO can be a net positive in enjoyment! That's subjective of course...
I do
If you don't like writing Go, you don't have to endure it a lot.
Rust has the opposite problem, you juggle the types around like a chief for an hour just to produce lemonade 😂
Great video! But I am missing C# in this list. Performance-wise, C# is often even faster than Go and has a lot of semantic sugar, allowing it to develop fast.
Would be cool to see how elixir fits in that scale, is the reason it’s not included bc it’s not an extreme point language and is therefore not relevant for the vid focused on Golang or is there something about elixir that makes it not relevant?
I agree! Elixir is a little different because it's far less "general purpose" than these languages. You'd probably want that 2D axis Theo mentioned. That said I'd love if he covered it since he always speaks so highly of the language
I love the fact that, The result of 2 pr one from a sr and a jr looks indentically similar and go's one way doing things
I don't see a problem with it, I wish that as a js dev. I am tired to do one things that can be done in multiple ways and weighing pro's and con's and considering various scenarios in mind.
Very interesting, what is the tool you are using to describe the programming languages? looks very nice.
I've tried Rust and it's really hard to do stuff in Rust when your knowledge is not strong enough, but I think it is great. I have Python background and on big projects it's dynamic type system is not your friend. So no I want to try Go :)
mans gonna make us a go + react framework ;)
People griping about Rust's compiler being slow just don't get how much heavy lifting it does for you, saving you from endless hours of sorting out weird bugs that pop up all the time in other languages.
Just because it is awesome doesnt change the fact it *is* hella slow
@@fish3977 first compilation - maybe so (but even on medium sized projects it takes one and a half minute on my machine). But the key thing is incremental compilation on the second and all the following runs - it usually takes a few seconds.
I adore GO and still was interesting to watch your video, theres no need to make things complicated when they’re absolutely simple. But yeah like any language out there, there are better and worse choices.
Just wanted to correct you, there is a way to poll on a channel and realize if it’s closed or not:
regularly u get one value from a channel, but much like a map u can actually do this:
value, isOpen :=
You quickly brushed over maintenance being harder in Typescript. Maintenance is hugely important when it comes to velocity (when we're not just spiking a PoC). There's much more overlap with Go and TS/JS on the velocity side, especially when projects get larger and more complex, I actually think go overtakes JS for velocity. That's where Go's main strength is: similar velocity to TS, but gets you a lot further performance wise. Another one is less need for 3rd party dependencies.
Also, I'd argue that dev velocity should be combined with compilation time into a single category: something akin to "Lead time".
Go was conceived when the landscape was different. It solves issues with the main options at the time: java (packaging, memory), python (packaging, perf, dx on big projects), c++ (packaging, dx, dev speed), ruby (packaging, perf), etc
That's exactly how I feel as well, well explained Theo.
I'm certainly in the C# camp for Dev velocity and through to Uncanny for backend
Thanks for the video - Out of curiosity, what's the drawing tool you're using?
Excalidraw
The typescript developers problem is with the garbage collector is the wildest take I could have imagined. Thank you for keeping us guessing what the your going to say next
Language for writing compilers is another problem. Go does not really have anything specific to support building the compiler, I remember needing to have interfaces with one empty method to mark structs as AST nodes which just felt so wrong. Rust on the other hand initially seems really attractive with ADTs.
Later down the line you might get stuck with Rust, for example if you want to represent recursive types in your compiler in Rust you will have to implement some kind of handle system as references are not really an option. That gets a bit annoying, in Go you could just hold a pointer. When choosing the language to write compiler in I think people tend to focus on the start or end of the process (parsing, simple analysis, vm) in which case Rust is really attractive but forget about data representation for typechecking and so on.
But as compilers prefer immutable data structures and visitors/folders to operate on code I wonder how much that is actually a problem. I can tell from my experience of writing compiler in Rust that it slows down my development time initially as I need to think about central database that holds all the types so that they can be queried later. But maybe i would need to do this thing with Go anyway later and Rust just shifted it left?
maybe sending to a nil channel should return something like Result where the Err indicates an IO error and the Option indicates whether or not the channel is closed
I like Go and I like code in Go. A good first backend language that will carry you very far.
Wait did you just call Terraform a bad thing? Do you have a video on your opinions about why?
yea that caught me off gaurd too
The longer you work with it, the worse it gets… Especially in enterprise environments it’s just a pile of technical debt and let’s not even start with hcl 😅
OpenTofu, search that up.
@@gro967 the enterprise cloud-infra function I belong to is heavily invested in Terraform. It's how we manage landing zone, and infra patterns application teams consume.
It's been a challenge but after 5 years -- at scale -- we're doing great. But it has taken much planning, a lot of thought, good design, and making the right decisions to get to where we are.
I know what you're saying, and it's defo possible to get it wrong and end up with tech debt. We had that for a while.
The inconvenient truth though, is that Infra is hard and what else is there that is fit for purpose?
It's cold here in Theo's shade XD
"just 'go' to the other side" I lold
And then there's Mojo 🔥
it fills the whole line.
Is the TS developer velocity not biased to the devs experience. I.e is it a skill issue? If you are more proficient in Go I would expect that Go would be very near to if not in the same spot as Go here.
there's this saying that "Perfect is the enemy of the good enough" and I think that applies here.
I love programming in Go; I find solutions to everything without much headache. I would also love to do frontend development in Go, but the TypeScript ecosystem is simply better suited for that purpose. So, I have to acknowledge that using the right tool depends on the purpose. Opting for Go over TypeScript prevents a significant number of bugs and requires fewer tests thanks to its strict typing.
Introducing JS/TS to the server seems like a big mistake to me, but I understand that managing a single codebase for both sides can be beneficial. However, one must be aware of the challenges that come with wanting to program with JS/TS on the backend. As for Rust, I've tried using it for my backends, but it's too dense. I would love to use it more often in my projects, but it doesn't allow me to implement features at the same pace as Go. I hope to be able to do that someday.
What made Go click for me was moving from "the love of writing software" to "the love of solving problems".
Interesting take. In my opinion as a (gasp!) "enterprise" guy, I believe that Go's main battle will be in that area. Can Go dethrone Java? (and to some extent C#). This is in my opinion the best battlefield for Go, the best place it can pick a fight and gain traction and mass adoption. Now, this is becoming increasingly harder since both Java and C# are pushing forward with their own versions of AOT and "native" (or heck, even proper-ish native) images for the executables they produce.
Go in the "FE tooling" space, well, it's a very *VERY* narrow scope for a language you can literally pick up in a weekend and actually write meaningful production-level (not just "stable") code within the next week.
P.S. I understand where you are coming from, but you should remember that the *vast* majority of "enterprise backend" code is written in these two aforementioned behemoths - and they do have both their ecosystems and their clientelle. I would love to see Go, well, go (pun intended) hand-to-hand with them and deliver faster, more memory efficient solutions that would bring meaningful changes in terms of resources used (both in materiel and in time, incl. dev time).
What diagramming software are you using on that "Go and its place" visual you built? Love how simple and fast it looks
Excalidraw. Has a VSCode plugin also.
Excalidraw
@@mattbettcher thanks!
@@charliecarrot I saw your question while I was searching through for the same answer! Pretty cool tool.
I'm confused by the take that python can be faster than js because it's significantly slower in all the benchmarks, maybe the only exceptions are libraries that are wrapping c++ code but you can accomplish the same in node so i really don't see python being any faster than js in any situation.
He just talk nonsense. Maybe it's for some reason, but he make a lot of this mistakes
Could be thinking of Mojo?
Depends on the interpreter. For example PyPy is much faster than CPython. Also, there are projects such as Numba which actually compile Python into native machine code, so you are still writing Python even if it's technically another tool written in C++ that's making it fast. The argument that "X language is not fast because really it's just C/C++ under the hood" does not make sense. You could argue in the same fashion that C or C++ are not really fast languages, acskhually it's the machine code generated by the compiler that's fast.
When comparing Python vs. JS/TS performance you have to take all of these factors into account. Which Python interpreter are you using? Which JIT, if any are you using? Which JS runtime are you using? Just making blanket statements that one language is faster than the other one is not useful for much of anything.
@@fluud7220 i'm talking about CPython that is the "default" vs NodeJS that can be considered the "default" as well.
I love to use Golang and Svelt/Vue since what i need is the ease to style and build a Dropdown that works like i expect inside the "Templates". I can accept that i need spinup a "Frontend" server but integrating the backend server and have Request and Response Types is a Pain when the Backend is not in Typescript.
I think that and SSR are the only reason for having a backend in TS: we need a TS framework for the frontend, and we can reuse the type definitions. Because otherwise there are a lot of better languages for backend.
I haven't done a lot of Go, but in Rust I can just declare structs with the expected datatypes and serde deals with (de)serialization. I imagine Go must have something similar. Then the only pain point is maintaining those definitions up to date in both sides.
Have you ever used Vue and Go in the same project?
I really like this video, but I think dev velocity is a lot more subjective than you lead on here. I feel like every time I spin up a TS project I have to faff around with configs and dependencies for far too long before even starting the project. I can move much faster with Go because of how much is built into the core. It really depends on what you are most comfortable/experienced with
Your former managers example of two PR's is so insightful
I was hovering between liking and disliking this video and ultimately went with liking it. I don't necessarily agree that working in JS/TS will make you faster and "Dev Velocity" as a metric is very subjective. It can feel fast using JS array operations to break down data quickly. For example array.map().filter() feels like a more elegant solution and is much faster to write than writing for loops, but when you're debugging issues it's much easier to do that with for loops than functional operations. Yes JS/TS has a richer third-party ecosystem, but how much time are you spending having to audit and upgrade your various packages? This is less of a problem with Go due to its rich standard library meaning a lot of these packages are less necessary (and less tempting to automatically reach for when you need to left pad).
I do think this is a good breakdown of the tradeoffs between these different languages, and well worth a watch though. One of the reasons I stay subscribed is it's nice to get a perspective from someone I often disagree with but still has valuable insights. Keep up the good work :)
You're coming around to go? Go where??
A better question is why would you come to go, why not just go
Go Theo! But stay there!
He's going to come around to go come around to going
Infinite loop detected
Ok, I don't know if this will be seen, but I have an idea I think is good.
You know how Go could use arenas to move temporarily left on your chart? Rust could add a sort of anti-arena feature where specific scopes of code are garbage collected and safety checks can be ignored, in order to temporarily move rust further to the right. We could call it something like "unfast."
If unsafe temporarily turns Rust into C, unfast temporarily turns rust into Go. You could use unfast as a temporary solution to more quickly draft code you'll want to optimize later, or as a permanent solution on code you'll never need to be perfect.
Thoughts?
I agree - I never really get excited using Go, it is by design a very boring and simple language. But that simplicity makes it a lot more approachable to new devs to something like Rust, while having performance and memory wins. Go is just very good at working as a backend. If you have a new project in the backend then I think Go should definitely be near the top of the list of considerations.
I think while Rust is cool and has its use as a systems language to potentially replace languages like C and C++ as a safer alternative in drivers, operating systems, games etc, it is great. But the vast majority of people are coding on the frontend or backend, where I just find it is overkill, which can get quite dangerous if you don't know what you are doing and can actually make things slower if you do things badly.