rust complainers .. they just don’t know how to code by rust, with c++ background to make their experience worst .. perfect

39 min to discover this is actually a tutorial on how to wrap a Shuttle infomercial inside a go vs rust tortilla.

CHROOT!

Hi Prime, just came across your youtube channel a couple of days ago and accidentally put it on 1.75 speed. It change my life…

The fact the article spends the majority of the time explaining how you would or could do it in Rust should tell you everything you need to know.

This never make your own auth is not because its hard but because u r gona fuckup the security.

Like if I decided to do that I would keep raw pass codes.

I recommend you try Tinda Masala if you ever get the chance.

So, Every Rust vs Go thing I see just seems like desperate attempt by Rust people to conjure up things to make Rust look good but in-turn they end-up making GoLang look good due to its beauty and simplicity in providing elegant solutions, may be without realizing.

Both suck for larger projects tbh

How much did rust pay you for this video bro?

It’s gipitygenagen

27:12 So, I suppose one have to know which functions you need to do await on then, as it’s not obvious? Such as normally a function would return when it’s done, but here it could be a magic separate asynchronous function…..

Fair Article + Fair Reaction 🔥

The absolute metric shit-ton of code you have to import to get something that doesn’t feel like complete ass in a Rust web service is honestly ridiculous and then people add a bunch of dependencies just to deal with errors as well. Also, good luck debugging all of these layers hiding behavior in Rust. You’re probably already fairly set up to debug most of the Go stack.

more a comparison of web frameworks than of programming languages

you not destroying performance with arcmutex, where you got that idea?

afaict the original developer of Actix left the project and created Ntex, which is just a fork of Actix

imho some people underestimate what rust will allow you to do longterm. Embedded, machine learning, gaming,… I honestly think it’s the surface of rust that is the true USP.

I’m waiting for Rust vs Mojo🔥

“Quietly guiding” he said 😂. Rust quietly guides you, hands lightly rubbing your shoulders while whispering into you ears “YOU’RE F@#KING DOING IT ALL WRONG, GO BACK TO JAVASCRIPT”. The sound of Kenny G’s saxophone wistfully dancing in the air.

politics of Rust ruins it , go is actually no so bad

I was hyped about rust, I even installed mold to compile rust 4x faster. Yet, when I tried Axum, the hello world example just won’t compile. a lot of people complained why the maintainer won’t update his examples, yet the maintainer doesn’t listen. I fail to see why it’s the top library for http when you can’t even compile the examples.

No performance benchmark?

Rust code is so ugly omg.

There has been the argument, that error handling distracts from the business logic. One of the main reasons for me to prefer Go right now is, that the way of error handling it enforces, encourages me to see errors which can occur as part of the business logic, when writing.

“Rust allows you to put all the sh*tty code in the basket”. That’s exactly why I love this language. The From trait, the macros.
I feel so unproductive writing generic functions in JS/TS with if/else/switch, whereas in Rust I simply do x.into() or do_x!() and I call it a day

Go devs: “You must manually check every error every time always. No the language will not help you with with that”. Elixir devs: “just let it crash lol”

Monads are docker-containers

sorry but the one who created rust made it unreadable

0:23: 🤔 The ease of use for non-trivial projects is what matters when comparing Rust and Go.
4:52: ! The video discusses the different web frameworks in Go and compares using the standard library with adding routing libraries versus using a full-featured framework like Gin.
9:23: 🌦 The video explains how to extract weather data using a specific code.
13:51: 🎥 The video discusses the differences between the web frameworks Actix and Axum in the Rust community.
18:09: 📝 The video discusses the process of fetching latitude and longitude using Go.
22:56: 📚 The video discusses the concept of monads and the confusion surrounding the ‘monad as a burrito’ analogy.
27:44: 🌤 The speaker discusses the process of fetching weather data and creating a weather display.
32:44: 🤔 The speaker finds the combination of HTML and form confusing but is interested in exploring Rust.
38:02: 🔑 The video discusses the deployment options for Go and Rust applications, highlighting their flexibility and compatibility with various hosting environments.
42:00: 🔑 Rust allows for clean and readable code, but requires additional work behind the scenes.
46:53: 📚 The speaker discusses the evolution and benefits of using OAuth2 and the stability and maturity of Rust for production use.
Recap by Tammy AI

47:18 A decade ago, we needed some authentication. I wanted something more serious than BasicAuth over TLS, so I implemented WSSE.
100% of implementors were confused because they didn’t understand how the website could verify the password was valid if they sent a hash.
On top of it, the documentation stated that the password had to be based twice. So, you had to ask for the salt for a specific username (the website would return a hash even for nonexisting users).
Then you had to hash your password a first time with the provided salt, then a second time with a timestamp and nonce you created.
If you used twice the same nonce in the same interval (5 minutes), the website would reject the authentication.

When I left, the company abandoned it to use BasicAuth because it was too complicated for implementors.

Another huge point of confusion was why Basic Auth was wrong, even with HTTPS. People couldn’t understand that HTTPS is not enough. So, I referred to an article from Microsoft about naked bikers ^^ Yet, people still had trouble wrapping their heads around. But I was persistent, and that’s why we did WSSE.

The big downside was that I was the only one to know why it was done that way, even if I tried to educate my peers. It was already too complex.

It’s not. Check “hmac,” and you will see it’s straightforward. It’s just that, at the time, people were not used to that kind of security, and there were no plug-and-play libraries.

Marketing content

Most programming is done at a level lower than it needs to. Rust is suited for low-level control and thus not a good choice for general application programming, but neither is Go, IMO.

On JSON tags in Go, you only need them if the JSON you’re decoding has different field names from your struct field names, or if you want to enforce casing/different names in JSON encoding. If you’re decoding you don’t need the tags if your field names are the same as the JSON input keys because it’s case-insensetive. Friends don’t let friends pointlessly add JSON tags.

.await?.expect everywhere is annoying

akshually monad is like Schrödinger’s Box

Lets FF 5, 10 years and see how many of this super duper frameworks, command line utilities, webservices in RUST are still maintained and how many developers are there and still understand the codebase. THAN we can make a comparison. I bet RUST will rise to its top when micro webservices in tiny wasm / wisp container will be THE THING. Time will tell.

The team that wrote that Axum extraction thing got really inspired on how Symfony do things (Symfony has the best DX, change my mind ♥️)

have you chanting chroot noooo XD XD

been using Axum for quite a while now…

33:43 the oracle crate doesn’t have derive-from-row 😓😓😓

33:50 template-in-code is a big issue at my current job. I’m trying to maintain/update an old PL/SQL web server but all of the HTML templates are distributed in bits and pieces throughout the tightly coupled source code. The first thing I did was write static templates to replace the ones created by the PL/SQL code

20:40 I wonder how Prime feels about Option::ok() handling instead of matching.

Imagine how much less code it would be if they were to use Elixir, Phoenix, and ETS instead.

who has 50 minutes to watch your take on an article? lol

I spent 9 weeks in HS learning C++, once! I learned Go! I couldn’t even figure out Cargo (Trust me! I love the concept of Rust!)!

15:00

Using an oauth library is a gotdam sight from rolling your own auth. Using a library is definitely not rolling your own.

Never roll your own auth*.

*If you think this doesn’t apply to you, there is a 100% chance it applies to you. There are people who can roll their own auth, but they’re not in the youtube comments.

25:03 These two code block are alternative implementations. Both are mapping the error: the first is mapping the error in the pattern matching case; the second is using the `.map_err` method.

19:55 NO! You do NOT “lift” by exiting the elevated world. A “lift” take a value and wraps it with the idiomatic next level up.

`Ok(value)` is a lift.

Unwrapping it is the opposite.

6:43 I’m not offended by having to handle errors but I’m offended by the result type being (nil + result) * (nil + error) rather than result + error. 😛

I’d just like to interject for a moment. What you’re referring to as Rust, is in fact, Rust/GPT, or as I’ve recently taken to calling it, ChatGPT plus Rust. Rust is not a fully usable language unto itself, but rather another free component of a fully functioning Rust/GPT system made useful by the suggestions, autocompletions, and problem-solving capabilities provided by a tool like ChatGPT that make writing Rust possible.

Most Rust programmers utilize this combined system every day, without admitting it. Through a peculiar turn of events, what is essentially a Rust/GPT system is often referred to as just “coding in Rust”, with many developers unwilling to accept that they would otherwise be incapable of writing idiomatic Rust.

There really is a Rust, and these people are using it, but it is just a part of the system they use. Rust is the language: it provides the syntax and libraries, laying the groundwork for software projects. Rust is an essential part of the programming experience, but useless by itself; it can only function with the aid of a large language model. Rust is normally used in combination with the ChatGPT interface: the whole system is basically ChatGPT with Rust added, or Rust/GPT. All the so-called “Rust programmers” are really just experienced prompt engineers.

Thanks for this, was a great article, and great job reading it! I appreciate you not playing music, cause I watch all content in 2-3x.

What website is he using?

This go example illustrates why you’d prefer try/catch – you really don’t care about “failed to parse JSON” case – it getting caught by global exception handler and converted to a 500/logged with a stack trace perfectly fine, and if it’s not it’s trivial to wrap the external call in a block that’s as granular as you’d like. There are a bunch of error cases I can do nothing about except some logging and return the same error response + rollback – try/catch/finally works just fine. I get that this isn’t true for systems programming where you want to be rigorous about error handling – but in this example (web app talking to external services), or stuff like GUI, it’s superior IMO.

who would ever say that Go “offers a batteries-included development environment”

Fearless cost abstrurrency.

Rust isn’t a cult.
It’s a Foundation™

likely hot take:
I actually dislike the ? operator

16:11 – this is why I tune in

It kind of sucks how much code is written to support crap technology when we should be replacing the crap technology instead. No more HTML/CSS/JS, but instead replace all that garbage with something sane. Even weirder still how so many people will just suggest a new programming language to deal with the garbage rather than something preexisting that has all the tools to deal with it already. If you’re going to suggest a new programming language, why are you still using the old garbage with it?! This is why I can’t take these comparisons seriously. Don’t suggest some new language to then just use HTML/CSS/JS again, replace it all or replace none. Either be pragmatic or don’t, but don’t halfass it.

go has the potential to be a perfect language. however in my opinion, it lacks safety. sqlx can’t check sql validity at compile time. struct fields are not mandatory (that’s by design) and most of the time errors are just strings and not typed, so if a user can’t access a s3 file, i would have to check of the err string contains “not found”, “no access” or even better, there is an update and the messages have changed without you knowing💀

rust vs Vlang, go but fast

0:04 was so unexpected It made my heart hurt out of laughter 😂

I disagree with this idea that Go’s error handling is good. Most of the time, people agree that exceptions are a bad way of errors. But when Go has a system very similar to exceptions suddenly they are good? Sounds inconsistent to me

I’m proud to say that I’ve converted my company to use both
Go for more “general” microservices and rust for the microservices that are a bit cpu/ram heavy

I just let Redux library handle the errors.

Good reason to use Go is there actually being jobs looking for it

Rust is rotten and so it GO

Isn’t programming managing errors all about ?

this is absolutley garbage TWO GARBAGE LANGUAGES

Just working on my new web page base skeleton, using axum, minijinja as templating, htmx/hyperscript and currently I chose UIKit3 as css (unsure yet), and my first customization was to add a markdown macro into minijinja to enable markdown syntax rendering in my templates, styled with markdown.css, and i was amazed how fast it started to come together.

I plan to slap on media management, an admin etc. later on, but for now my next step is integrating diesel and providing a basic database auth middleware.

Honestly if there was a rust syntax based language with garbage collection, or some way to fast compile while developing without full safety, even some kind of development interpreter, I would use rust for everything.

i.imgur.com/blA0Oi4.png rustlets getting BTFO by boomer OOPs

every time i put on a youtube video and space out for a bit, i come to and hear ThePrimeTime talking about javascript

Listen man, we are not living in the 80s anymore. Writing ‘if err != nil’ feels like old school C apis. If that’s how go does things, then I genuinely feel bad for people who use it.

The best thing about building web services with go is that you can easily replace developers. With rust everyone has their own way of doing things and this lower maintainability.

the code at 6:55 is so clean, I can’t believe someone could make an argument against it

It’s pretty funny when Rusters gasm over little things like having the framework automatically populate query parameters into their handler function but conveniently miss the mass of await.clone.unwrap() ‘static derive-everything-everywhere in front of them

I have always used middlewares in axum with:
let users_routes = Router::new()
.route(“/logout”, post(logout_user))
.route(“/validate”, get(validate_user))
.route_layer(middleware::from_fn(guard))
.route(“/login”, post(login_user))
.route(“/”, post(create_user));

Where the guard:
pub async fn guard(
Extension(database): Extension,
mut request: Request,
next: Next,
) -> Result {
Ok(next.run(request).await)
}

You can also use Arc> which is non blocking for reads and only blocking for writes, that way you can reduce contention.
If you think you don’t need those things in Go, good like chasing data race bugs later.

didnt watch the video, but here to tell you that
finally used htmx in a project, and it went really well
htmx is my go now if the project requires a centralized back-end

It’s also worth mentioning that any external dependency is a liability to a project. Go standard library is very stable, so from my experience it’s much easier to maintain in the long run, as the project matures.

as javascript dev, i can say… yeah, i hate handling errors in javascript. I love how go does it.

6:52 a “backend dev” at my previous company

javascript/typescript developers are inferiors to java/go/rust developers

Rust, may not be easy to learn. Rust may not have the best leadership. But it is by far, the best language for EVERY situation. The problem is, people want “easy” and people want “simple” so since it doesn’t have every possible library, and it doesn’t have a 2 day learning curve, it gets a lot of flack. but the world would 100% be better, if every language except rust, was eradicated. I’m not a fan boy, but it is the only compiled language with out garbage collection, that has forced garbage destruction. it’s ultra fast. it’s ultra light. the slow compile time is just a biproduct that hardware will reduce more and more.

And then you can write it in python in less than half the time. You are going to be IO bound anyways on both sides, the network and db, so why does the language performance matter all that much? Example problem, I get it, but indicative of a lot of the types of problems people have to solve.

Concurrency in rust is fearless, but not painless

I remember watching the end of this video on live. What’s a really good article you have read. Also you make me discover in this live the existence of this amazing golden library that is templ. Some may said it’s just TSX in go but it’s truly make me remember that good old days with Laravel and Blade.
(Btw I don’t have a Lamborghini yet and I don’t know if it make sense for me cause I’m living in the middle of the sea -_-)

lol I was java programmer and I had good experience with go recently and I was wonder what if I learn rust for my new project. so I searched and found Primes former video about rust and go and to see other video , I searched and reached this vid that has uploaded in 2 hours ago. love you and I’ll watch it after this comment ends

6:47 JavaScript Devs :~ Errors are Errors why to handle them 🤔💀👀😂

i like to live dangerously and code c,javascript,rust,go in a single project

Javascript error handling is trash.

12:43 Some People are just plain ignorant. GDPR relates to personal data of EU Citizen. Weather Data is not Data of EU Citizen – unless you track the Weather in your underwear. Bloody hell.

Go w/ Cobra for awesome CLIs

i like axum more because i can use tokio main

“but it also distracts from business logic”
Error handling SHOULD be part of the business logic.

gjengset has a fantastic video on how Axum handlers work.

Is rust just becoming a web language now, honestly i believe a great number of js devs are hopping onto the rust train and bringing in their js influence iver the language, i personally am very fine with GC languages fir web related stuff, but webgpu has got me a bit worried, i am a c++ embedded developer that builds graphical programs as a side hustle. Web assembly and web gpu has gotten me a bit excited for web grphic programming, cht what ddo say about c++ for wasm webgpu i’ve looked into dawn library/framework but as ive researched i get the gist tht rust is more fvoured in terms of toolchain and library availability for webgpu, is rust too difficult to learn, heard of the borrow checker being difficult to handle for gpu or low level tasks, im not afraid of getting hands dirty with unsafe code as well. Anyone in chat with their 2 cents is appreciated, hope you have a good dy

does `nil` work in go like it does in lua?

For choosing Go Web Framework and ORM: Don’t, try to use the standard libraries (it’s much better since 1.21) and Sqlc first instead. Most of the external libraries and frameworks have some shenanigans that are not (trying to) conform to the HTTP/WebSockets, etc. specs.

Before I start the video, I’m betting the whole video to be “look, I made some stupid backend in rust and go, oh and look, memory spikes in go! Who would’ve guessed! Oh look low and predictable memory consumption in rust! OMG what a surprise! Oh and look go us not that far behind rust in performance!”

And primeagen at some point makes a comment “use rust if you hate your life” or “rust is very hard, go is very simple” or something like that

Why do people even compare those two??

Go vs C# would be far better

can you finally stop creating content by only reading articles? I really enjoyed the vim series and more but i cannot stand these videos.

“everybody loves tokio except that for that one person that writes those articles like ‘don’t use async rust’ and tokio is inveitably mentioned in it” literally the same author as this article 🤣🤣🤣

Assembly language is the king

If let Ok(res) = result{}

Which language should I use to construct a low-latency backend: rust or Ocaml, zig, or go

Go Rust Brother

rust is a language for networking and I don’t use it for anything else.

Let me bet: Rust faster, but not much.

First