I Spent 18 Months Using Rust And Regret It - Çift Dilli Altyazılar
I spent 18 months rebuilding my algorithmic trading platform in Rust.
I'm filled with regret.
I would love it if this article was like I'm filled with regret for not doing it sooner.
Like how funny would All right, Austin Starks, take us on a wild ride.
I was a young hopeful rust fanatic on paper, rust scene.
Okay, this is not seeming very pro-rest.
This is not pro-rest at all.
On paper, rust seemed like the programming language designed by the gods.
Not only is it the fastest programming language out there, it's also one of the safest.
Technically, it's really hard for us to actually be the fastest language.
It's very easy for it to be not fast, and fact, it's quite optimized to be not fast and due to the safety.
But C++ is not faster, C is not faster, none the languages are faster, anything that's at the tippy-top.
Just remember, right?
The of the performance pyramid is going to be filled with managed memory language.
So you got Rust, you got C, you Zig, you I'm sure there's other ones.
Nim might fall in there,
but the reality is the reason why rust often goes from the fastest to the next level is because you use things like RCs,
ARCs, and to effectively get around rust, right?
Or more so clone.
Yeah, I guess Odin would be in here as well.
So this is like a very typical This is like the typical problem Here right wait people don't use arcs in C++
I mean you use arcs if you use shared pointers in C++
And if you look at the bottom of this if you look at the bottom of the pyramid you find a snake and a big yellow square
Go go laying falls under like falls into these two categories,
right go as fast right once you have runtime managed memory which is our season arcs it's no Right,
you fall down into, you fall down into garbage collected, right?
I put a heavy emphasis on garbage collected because there's not garbage collector,
but you are no longer managing, you're no longer managing your own memory.
You are letting some something else manage your memory.
Java doesn't exist, it's just a fantasy.
It Where did Java hurt you?
I'm not alone in thinking Rust was this perfect language.
If you read about Rust programming language online, you'll likely encounter overwhelmingly positive opinions.
Every guide on medium, every post on Reddit, every answer on Stack Overflow, everything is glowing.
I can't wait to catch a bullet by this.
to bullet by Rust.
Given this, I decided to migrate away from TypeScript, rewrite my entire open source algorithmic trading system in Rust.
I gave Rust a natural rating, a neutral rating before.
I take that back, dang, dang.
Okay, I really hope that we get some really good ones.
Right, I hope we get something really good here.
By the way,
if you're doing algorithmic trading,
I assume you'd want to be able to react really,
really fast so I could see you using a very, I could see why Rust would be a natural decision.
Typically, you don't wanna do algorithmic trading in slower garbage-collected language because a couple hundred milliseconds could cost you the time.
trade, right?
Just real talk, that it makes sense why you'd want to use something that's better than TypeScript.
I wrote my, let's say I wrote about my experience with Rust four months ago.
In my last article,
I concluded that while I really like the speed and some aspects of the language design,
such as enums and strong typing, I didn't really love the language.
What you're discovering is that you don't in love in post safety.
That's what you're discovering.
My article is met with harsh criticism on Reddit, including one highly upvoted comment that accused me of Dang.
This is, uh, this is a lot of upvotes for something that is literal, uh, that literally isn't true.
I use chat GPT to write any of my blogs.
I just simply don't.
I hate how it sounds.
This is just how I write nowadays.
I don't even use chat GPT to correct my writing.
This is genuinely my writing style.
Dude, I'm right there with you.
I actually tried to use chat GPT to help me with some, some stuff and it, it just became very frustrating.
I became very, very frustration.
What if he is a robot?
Ooh, ooh.
Anyways, after posting, I had thought that I'd given that I didn't give rust a fair shot.
Maybe I was just naive or came in with misplaced expectations.
Now, after working with the language for a little while longer, I can confidently make one.
conclusion the language absolutely fucking sucks I think the language is great
so maybe I'm not that intense but dude this is funny but I've always said I think
Rust has this rust feels better than it is because when you're solving a black box problem it's like really It's really really great.
He can still turn it around.
He can still turn it around.
There's some things that make Russ really good at.
Like I love it for basic command line operations along with like marrying that with some some like file reads, transforms, and stuff.
It just is really good for that.
What I despise.
I want, let's see, if you want to find an article about what's right with Rust, look literally anywhere on the internet.
You'll be hard pressed to find anything less than neutral about the language.
This article will be focused, uh, focused rant about what I despise about this crabby language.
Alright, let's see if we can, let's see if we can figure this out.
Herendis verbose unintuitive syntax and semantics.
Yes, when you get into this level, this is what I always say.
The moment you start getting into this world, this is where things start getting, like, good Rust becomes shitty.
Like really like once you like when you hit into like a dude a pinbox dine future is crazy like this is crazy
It's a Haskell dressed up as sea-like language to trick normies Haskell has this exact same problem.
Yeah, that's due to Async I know I've always said Async is where things just get all F
And the moment you get into a sink land and you try to do something that's really clever dude every single time
What is what is this okay, so Send means it can cross, it can go across, it can go across Hacing Boundaries, correct?
And then plus tick underscore means the unnamed lifetime, if I'm not mistaken.
This is where I start breaking down too.
It's once we start getting into this world,
this means it can cross Acing Boundaries and it can, and it has a lifetime that you don't need to, that we're not mentioning, right?
So that means the function that you're passing in F is a mutable function that takes in a client session that returns a
future at some point in the world that can be crossed over the boundaries
and has an output of R where R is send and static.
Acing is very hard.
It's very, very hard.
Yeah, like I generally get what I'm looking at here.
I generally get what I'm looking at.
It's just that once you get into this world, it is.
It's just super hard.
Like generally speaking, it's very, it gets very, very hard.
All right, so all of this looks pretty good.
All of this looks pretty good.
None this looks like, see the rest of this looks pretty good, right?
I would say that everything else in here just looks pretty straightforward, right?
Anybody who ever said that rust doesn't have atrocious semantics is lying to your face.
I see the thing is,
I think one thing that's really nice though that you're kind of,
you're kind of missing is the fact that you can go operation session await.
If it's okay, we do this.
If it's not okay, we do that.
Like I think this is actually really nice, right?
I think that this is a really nice thing.
And then you have a for loop, you have all of this.
It actually reads really nice.
Like this part, this is what I'm talking about when rust looks really good, is this right here.
This is really nice.
And there's a lot going on here that is actually shockingly crazy, right?
You to start a session which awaits something.
You have to start a transaction which awaits something.
You then have to do this operation and then match on the errors and if you get the error
then you return out the result else you're going to go max retry as exceeded.
This is really, this is nice code.
It's this part right up here that just gets so effed up.
This part gets so effed up there are certain things where if you don't have access to an extremely powerful large language model
Then writing the function becomes literally impossible
I don't want to spend 90 minutes figuring out why where clause in my run transaction
Let's see figuring out the where clause in my run transaction.
Yeah, the where clauses become exceedingly frustrating I'm on your team and if you define your generics in the wrong place run clauses can be super
frustrating Like they they can become super super frustrating
That's why I like a language like O camel though having an exceptionally similar type system gets away with a lot
Is because it's garbage collected it can just simply drop some of these difficult?
And that's that yeah,
the large language model is an interesting is a very interesting call out saying unless if I have access to this I to me
It says you just need to understand more about rust internally for you to be able to do this
And so this is that language curve You know,
I jokingly made that video where I said rust learning curve is like this once you hit async.
It's non-different It's because this like skill issues here.
The problem is that the borrow checker when you're learning is like a steep It's like an upright curve and then you get it and that's it once you get the borrow checker
It's easy, but then when you add in lifetimes.
It's like another's just upright curve And then when you add in async,
it's like just such it like goes it goes And it becomes so hard because it's just really difficult when you marry all the concepts of
lifetimes, of traits, and of async.
When you put these all three together, now you get this whole problem that's really, really difficult and it is most certainly a skill issue.
It's most certainly a skill issue.
But it's a very excessive and difficult skill issue.
So rust curve is the Debian logo.
Exactly right my god The curve is non-functional.
Yeah, I know in the end I had to abandon the idea of a helper function entirely Yeah, so again, this is just that's because you're writing it the not rust way don't write a helper function
Can we all agree?
This is one of those things that I always made a problem of is that in JavaScript you abstract out these similar functionalities across async operations in Rust you don't want to do that because you
will find that?
You do.
You find that you hate your life and it sucks a whole bunch because you do this and you just,
you have to like be okay with code duplication at some level or you have to be a genuine master of Rust or just given to ArcMutex.
ArcMutex?
Makes it very easy.
Oh, I read that one.
Okay You say he's also making it complicated by using a Mongo transactions
I'm not sure if that's true a lot of people want to use um,
by the way this code girl I can see your experience is showing right here wrong duplication is better than wrong abstraction.
Absolutely Hands down 100%
correct Because you can always fix an abstraction you can always or you can always fix code duplication with a function
Very hard to fix it, to fix abstraction.
By the way, I forgot what else, oh no, my cam died, my cam died.
It actually wasn't my camera, it's my, it's my, what do you call it, my HDMI converter, hold on.
Almost there, almost there, whoopsies, hold on.
Hold on.
There we go.
I blame Karen.
I thought it was my Linux.
No, there we go.
You're moving again.
There we go There we go.
All in the end I had to abandon the idea of a helper function entirely because I literally I quit literally let's see because I quite literally
Couldn't get the code to compile.
Yeah I mean dude
I've made this mistake a lot with rust and I feel like you make the same mistake with Zig as well
I think the prop I truly think the problem here is what I would like to refer to as JavaScript brain JavaScript brain,
or really dynamic language brain, dynamic language brain says abstract on all forms of code duplication.
And so you kind of adopt this without realizing it, you adopt it really quickly.
And also a big problem about dynamic programming.
programming, along with structural programming, such as Go, is that you adopt structural patterns, and you think a certain way.
You think in interfaces, and again, Rust does not necessarily make traits easy, and Zig, they don't even have traits.
They don't even have...
they don't even have them at all.
And it makes things really hard.
What's the meme with like the four people talking about like talking about something and then there's the last guy that's like,
you guys have interfaces?
What's that meme called?
Dry is overrated and people overuse the concept.
Absolutely, they use it constantly and it is very, very dangerous.
It's true, I've been coding in C89 lately and I find my JS brain really leads me into the wrong, into some bad places, yeah.
What is it called?
We the Millers.
Oh, yeah, this one, this one, this one.
Something along the lines of like JavaScript, uh, TypeScript interfaces are great, right?
Go-laying.
It's something along like the lines of go-laying structural.
I'm sure there's...
There's some sort of, there's some, I'd have to think about this more, but this is happening.
I think about, I gotta think about this still.
I know there's a joke in there.
So we'll just make this, we'll make the quick any.
which I'll just grab the first one, right?
I know sometimes it broke cooked for nothing.
I know there's something, there's something there.
There's something, there's something there that's really good, and I don't know what it is.
Zig draft shit post, it's a draft shit.
There's definitely something there that's really good.
It's just it's gonna take too long to think about, and so we say move on.
Okay, this is not what it looks like.
When people claim as Russ biggest strength a stretch compiler to eliminate
errors is one of Russ biggest flaws just just give me the garbage collector and
let me do what I want to do real talk this is real this is absolutely real Russ
biggest strength is also its biggest weakness which is also very reflective
of all other ones JavaScript's biggest strength is the fact that you can just
add a property to anything JavaScript's biggest weaknesses you could just add a
property to anything
It's the price every language has the exact same problem right in contrast if I were writing this exact same function and go
It would look like something like this well go is actually really great though
I mean go gives you the abstraction ability of typescript with the with the 99%
speed of rust It's it's it's very impressive run transaction do all this one.
Yeah.
Yeah And we go to first session and yep, do all this thing, grab all that good stuff, do this one.
Yep, this is all looking good.
Grab this stuff.
Oh, yeah.
Oh, yeah.
Oh, yeah.
Oh, yeah.
Oh, yeah.
yeah.
Do the returns.
Do the attempts max.
Yeah.
Go is just so simple, right?
Go is just so dang simple.
Right, it's just so simple.
That's what makes it so fun.
So easy to read and understand.
It really is easy to read and understand and all the people I see a bunch of people saying if air equals nil blah blah blah
If we were to do this in TypeScript 1 2 3 4 5 of those
Would be hidden errors in which you would not know you need to catch or not.
So you would just get randomly bored Whereas at least in Go,
I know when I'm about to get borked and I can handle it, okay?
So come on.
Don't even try that with me.
Don't come on.
Come on.
While the core of the function remains relatively the same You don't have to do backflips to figure out how to make the dang code
work It just works agreed horrendous air handling.
Oh, that's interesting.
I would kind of argue my only problem I will say this about rust
One of its big problems is that due to the question mark operator, you defer a ton of air handling really easily.
The convenience of not handling is so easy that I often find, I think, less about errors, and I often find myself oopsie-dazing.
It's skill issue, skill issue.
Fair, please, please.
It's a skill issue.
But nonetheless, I find it so convenient that I forget to really think about how I should handle this.
Rust does have some very nice things with errors, as long as you avoid unsafe unwraps.
Well, yeah, you can, uh, you can be a damn sure that at the code will run and keep running.
No pointers, exceptions and unhandled errors just don't happen anymore.
Yay, right?
Wrong.
Because when your data is wrong or something unexpected happens, you'll be fighting to figure out what the hell happened.
Maybe I'm just an idiot and can't figure out how to enable stack traces.
But when an error happens in my application, I have no idea why.
Well, I mean, back, back trace.
Rust underscore back trace equals one.
Am I incorrect on that one?
I don't think so, right?
Right?
Definitely skill issues on that one.
For prod, why not?
I mean, if you're going to have exceptions, why not?
Why not have a trace?
Assuming that you've handled 99% of your exceptions or your errors, and this one you couldn't have.
handle.
Why not?
Like, I totally get when you have one and you handle it, you don't need a stack trace, right?
By the way, this also would be largely this, this also is very, uh, very nice to consider with, um, assert.
running a bunch of simulations and asserts and ensuring that you can't have these kind of things.
You can really figure out a lot of your application before you actually have it running with actual money doing trading.
You know what I I still use X errors and %w for stack traces and go.
See, I haven't used, I haven't used X, X errors.
I just still use errors and pretty much do wrap stacks still, right?
In contrast, I actually like it goes handling, right?
I like the fact that you don't have stack traces.
Instead, you just build your own stack.
stack and I build my own stack and so I get all the relevant bits in where the error happened
and I actually find it to be really nice.
Generally speaking, I find it to be very nice.
In contrast with the language like Python,
you get these beautiful art-like stack traces that tell you exactly what happened down to the line number.
Even in Go,
you errors wrap, which enable you to look at the entire error stack in your application, which is only the places you're really concerned about.
Perhaps I,
I'm a goddamn idiot because when I encounter an air and rust,
I'm like,
I'm in Lala Land trying to figure out what happened to the,
uh, to the, uh, or happened, wait, trying to figure out what the hell happened, why I could not read that again.
I'm going to say it again.
The question mark operator due to the extreme convenience of it all, I think leads more people down this.
There's this concept.
There's a very important concept in programming that you need to internalize, which is called the pit of success.
You want to make it so that doing the right thing is so easy that people just fall into the right manner.
move.
And that's one of the problems with Russ extremely convenient air handling is that a lot of people just question mark out the errors really quickly.
And so you end up handling an error like 10 functions higher with absolutely no indication into what's going And I see this a lot.
I see this quite a bit.
I'm not saying that if air is better,
if air equals nil is better,
but at least you have to think about it a little bit more holistically in go, even though it's more boilerplate.
You have to think about it.
You have to wrap it.
You have to add context.
It's also why I like anyhow.
I can add context.
And by adding context at every level, I get go-like air handling, but with the convenience of rust.
A dinair is just crazy.
Don't do dinair.
A is nuts.
Anyhow, and here are friends, yeah.
I need this e-print LN litter throughout my application.
In fact, no, I'm not an idiot.
This is a flawed language design.
I think this is just, again, I think he's just, when you use Rust, you don't fall into the pit of success.
And by not being in the pit of success, I think it's very easy to blame the tool as opposed to the knowledge of it.
And I'm just, At this point, I am not a Rust lover.
I am not a Rust lover.
I think it has a lot of things going forward, but I actually think that Zig is significantly better.
I think it gives you the right amount of safety with giving you the right amount of control over your program.
I think it's the best of both worlds.
And I would say that this right here is definitely much more of a skill issue.
That's very obvious.
Like, you goofed up.
You goofed up.
Hey, dude, it took me like a year to really get a good grasp
on errors in Rust, like to really understand a nice way to hand the Rust.
It a long, oopsie daisies.
It took a long time.
And so I definitely...
Crabby community, hot take, the Rust community isn't as nice and cool as they pretend to be.
Absolutely.
Rust is probably, I would say the least friendly.
Zig might be the least friendly community, but then Rust is right afterwards.
I JavaScript and TypeScript generally have a pretty friendly community.
Alright, like, I can shit, oh okay, PHP has the nicest community.
we can all agree to that.
Anyone that disagrees that PHP is not the nicest community, I would like to I would like to mention Adam Elmore and Aaron Francis.
Okay, you can you cannot beat Adam Elmore and Aaron Francis as the nicest people in the universe.
Yeah, PHP is a very nice.
They're super super nice.
Very, very nice community.
And I would like the reason why I'm going to Laravelle is that our laracon is that I am obsessed with how well
and how good their community is, and I want to learn from it.
I want to bring it in.
I want to bring it to the mainstream software world where we can stop,
like, Where we can actually be a lot better like even notice this I'm not like I'm not dunking on this guy
I'm not being mean to him.
I'm saying hey, this is a really natural conclusion.
I think a lot of people run into I'm fully on his team I'm trying to like I'm trying to bring the goodness of that PHP community outside because I think it's really healthy
And I'd love to see more of it and I agree fully I think rut the rust community
specifically in the more leadership roles are some of the meanest people I've ever interacted with in my entire lifetime.
Like the meanest people.
It is shocking.
It is shocking how much of their superiority.
Now there's some good ones.
I can think of...
it's Shepherd, something Shepherd.
Gosh, why?
Dude, I see his name.
Dude, his name is like Derp Shepherd or Derp something, Derp Shadow.
Gosh, why can't there Really a chef master You know derp yeah derp really nice guy Shepard's Oasis, Shepard's Oasis, there you go.
I actually think he's a really nice guy, and he's an exceptionally talented person, like outrageously talented, and still communicates in a really nice way.
Like I actually think that just genuinely a huge amount of respect for the guy, right?
Absolutely, huge amount of respect.
All right,
because MongoDB is shitty,
MongoDB is not a real database, it's a key value dock stored in no squeal storage system that literally did a dime for marketing metrics.
It didn't even provide support for asset or transactions till more recently.
And the longest time, it just blindly corrupted your data due to its poor Q2 right design.
There are better databases.
Don't make rust look bad for using MongoDB.
I mean, this is actually just a advice.
I mean,
really, the thing that he was struggling with is having helper functions,
which is typically I find to be very difficult for doing a retry over some async operation, right?
You could generalize this to retry over async Amongo not gonna make it, for sure.
Mongo not gonna make it, but this response is wild, right?
But again, I'd also like to say that random response on the internet is not reflective of the community.
So.
Just remember this that I don't think you know I mean someone just said something and it's very very true
I think generally speaking when I when I think of when I think of the Rust community
I think of I just come back to this picture often and I can't I can't undo it
Because once I once it's in the once it's in the brain.
It's just stuck there It's just stuck there forever.
I'd really love to see a turnaround in the community and be a little bit more approachable For example,
I asked the question on the rust subreddit how to improve error handling with MongoDB rust great The it my answer range from switch to postgres
Why am I using MongoDB at all MongoDB is bad and go and Python to and actually help will suggest and to improve error messages?
Okay, that's good.
That's good I do I always find this strange when somebody asks a question.
How do I handle this situation better?
I've always found it such a strange answer to be like used postgres like I will or to TJ,
but I would never say that to an internet random person.
You what I mean?
That just feels weird.
There is no other programming community that's as cult-like as Rust.
They ignore all the giant glaring flaws with the language,
like it's crazy learning curve, verbosity, horrible error messages, crazy syntax, and questionable language design choices.
They'd rather say it's a skill issue when the...
with the developer.
That's insane to me.
I do think you're definitely having some level of skill issues.
I one of the hardest parts about writing in different languages is adopting the mindset of that specific language.
And it's very, very hard.
And so I'd revisit this maybe a bit more like I'm on board with you that I don't think rust fits all
situations But I think that horrible design choices.
I actually think a lot of the design choices are really good I think there's a lot of really cool things like dude
Impel Impel uh what's it called Impel uh from and try from is like one of my favorite things of all time Yeah,
he's doing it solo with no mentor.
Yeah, that's very very hard start.
Imple from and Imple try from is probably my favorite design feature of all time.
It's so good.
It's like shockingly good.
I wish more like that I dislike shadowing in Rust a lot.
Funny, you know, it's funny you should say that
because I was on your team, I thought shadowing in Rust was like such a bad idea, and now I love shadowing in Rust.
And the reason being, and the reason being, I have an example somewhere here, I can just search the word maybe, there we go.
I always am like, hey, get an index of something.
If it equals null, I wanna just return this back out, but if it doesn't equal null, I want to unwrap that null.
Cause I just, I generally hate indenting, I try not to indent, so I'm not gonna have the inverse of this.
And then getting out of it and so I wish I could I really wish I could just do this right like I actually wish I could
shadow I think shadowing is really really nice.
I actually really do like shadowing now that I understand it before I didn't like it Even when I used it and I did understand it.
That's kind of a dick phrase to say I did understand it, but I just didn't now that I've used enough times.
I really really Right what is shadowing just what I just did right there.
This right here is a maybe you size This right here is a you size.
So you a shadow is to change its type.
I'm gonna change its type from Option you size to you size you can use or else yeah,
yeah, I those are things that you know This is me.
This is like Like, this is like some of my first zig I ever wrote.
I know there's better ways.
I know there is like an oral something, something, something.
I haven't quite got there yet, right?
I'm still learning all the things.
You I like to write a language in a way that's familiar with me, how to handle it.
And then as I get better, I like to try to get.
You know, I to kind of like it like as you can see right here.
I'm kind of getting good at the catching right I'm getting there.
I'm getting there.
Just please let me let me get there.
I'm getting there slowly though I do agree with you.
I do agree with you that I guess I could do something along the lines of oh Whoopsies,
I just realized that I was yanking the whole wrong thing whoa whoa whoa whoa whoa that was crazy so you're saying I can go or else return
null right that's really really nice thank I know I was yanking wrong.
Very, very beautiful.
Like these things, like this again, Zig has some really nice operations here.
This is very, very nice.
But again, what's the use case of shadowing?
When you wish to change a variable type, but keep the same name, right?
Very, very nice.
All right, final words.
With this being said, Rust has some pros.
It's fast and well, that's mainly it.
No, no, no, no, no, no.
Multi-threaded programming, I to be generally speaking.
Multi programming in Rust is pretty enjoyable.
Just multi-threading itself.
Of course, I cheat with ARK mutex and or clone, forgive me.
But if you clone and or ARK mutex, Async is really not that bad.
There's plenty of reasons to actually really like it.
Erz's values, I think, generally, is a good way to go.
go.
But if you're trying to get maximum performance and async, I find it very difficult.
I do like the idea of having the reminder of like, Hey, you can't f this like here's a good example.
If you use channels with go, there's like these four rules of channels that just make it super, super hard to work with.
And I hate it.
Whereas when you work with channels with rust, because it has an.
it actually makes it really, really easy to use a channel.
You can't get stuck in a whole set of things, and this just genuinely makes async programming significantly nicer, just at an entire level.
I can't remember though, let's the four bad things about go-laying channels, right?
There's like the four things you gotta know.
I know there's one whatever I don't even want to I don't even want to look for it
We're not even gonna look for it
But there's like these four rules of things that are very very annoying and Russ just doesn't have it due to the options that means
Like, here's one thing.
If you return a nil through a channel, you close the channel, if I'm not mistaken.
Whereas with Rust, because you have options, you can have effectively some null, right?
You can say, hey, this is empty.
There's like, there's a bunch of stuff.
Close channel is only, you're mistaken, I'm I'm gonna mistake it on that one.
Okay, my bad, my bad, I don't use channels a lot.
I thought there was like no nils reading from a nil channel panic, yes.
Reading from a nil panic, nils and...
channels.
I there's a hole in it.
Okay.
Yeah.
I know there's like a whole bunch to it.
Like I said, I'm not great at go.
I use almost all my go has no channels except for a couple.
And I find channels to be really great.
But I know that Rust had a really nice, it has really nice ways to know what to do here.
Okay, let's look at this.
The accident channel send to let's see a send to a nil channel blocks forever.
Like that sucks.
Can we all agree that this is bad?
That's one really nice part about Russ is that it just returns an error and says, Hey, channel use of closed channel.
It's very, very nice.
Receive from a nil channel blocks forever it can't you get around this by doing a receive with two arguments?
Can't you you can get around that by doing a a like a receive with X and done, right?
Can't you get around that now with that?
So isn't that isn't that axiom kind of a generally dead yet?
No, it's okay.
Yeah, yeah, yeah, yeah, it's the valo K pattern.
Yeah, that's I didn't I didn't want to write all the stuff.
You know what I mean?
Let's see send to a closed channel panics also again That's pretty reasonable I'd rather have it return an error though.
The weird part is that go make such usage of errors I'm surprised that they didn't just send an air back right?
I like the usage a channel too would be really nice if they had errors instead
And then what's that receive from a closed channel returns the zero value immediately This is a course because they don't have options, right?
So if you had an option you can tell that a channel is closed because it returns a nun, right?
That means there was nothing there as opposed to something that's empty, which is very, very different, right?
So an option would be really, really nice.
And so I would prefer that over this.
I knew there was some quirkiness, right?
And so I find that this one is like a very, I find this one to be very difficult.
Yeah, you can always use valoque.
You can always use valoque.
And that should be used.
Okay, it's just, I would rather have an option type, that makes sense.
And so what I find that is when I read from a channel,
so I do this thing,
I forget where I do it,
but I do a thing where I check for results, and how I check for results is that, what I do is, what is it?
Is that I do a like a function call,
like a function get,
I'm way too zoomed in,
and I'll do like a select,
and then I'll do like a pull,
from X and then I'll also do like a default return return return something
right and so that way I have like a default return and this and that way I
don't it's like a non-blocking quick value select and I know this is like a
this is some level of a pattern anyways I thought know this article this
article is skill issues but I think I think the thing that you
You have to pull from this is that just because their skill issues doesn't mean there's not real issues as well
I think the pit of success with Rust is a bit shallow
I think it's very easy to do the wrong thing and that's why I think it's pretty universally agreed that with Rust
People find that they build something, they refactor it, they build it new.
They refactor it, they build it again.
They refactor it right and they find themselves in this constant refactoring thing because they're not it's very hard to write it
Right the first time or even write it good enough the first time
And so I find that it's just that rust doesn't doesn't have the same ability to just fall into the into the correct way
At least that's my general perception of it.
I think if I wrote it all the time, I could I could fall into the right way Very easily.
I think that if I just had enough just had enough reps.
I rust would be very easy At all points, including But I think cuz I don't have enough reps.
I do it 40 50 60 hours a week I don't fall into that there you go the pit of skill issues
It's it's a pit of skill issues more than anything else rust is fun with its rust less practical sure
I guess it's also safe to if we compare it to C++.
It's obviously the better language I do feel like that's also,
again, I think that when I hear this phrase, what I hear is that you're either comparing it to C++11 and below, or B, you've never really done
C++ and you've heard it's stupid, and so therefore you kind of dunk it.
If you use unique pointers or shared pointers and everything, it's pretty easy to do the right thing and go.
I mean, in C++.
I like can we all agree it's more verbose than we like but generally speaking long as you do
As long as you stick to a certain things, it's pretty easy.
And of course, there's also all the crazy operation overloads and the weird, crazy copy constructions that all values are.
There's some hard parts that I think take a long time to learn.
To master C++ is like mastering Rust.
I'd have my application to take a few dozen milliseconds longer to run if it means my development time is cut in half,
which is an interesting trade-off to make for an algorithmic trading.
Because algorithmic trading, I would assume a few dozen milliseconds can be impactful.
On the bright side, if we choose to write my application in Go, I'd also probably have some regret.
What if it could be faster?
I'd think to myself, there's yet another article about how Rust is the best thing since sliced bread, oh geez, I made a mistake.
At least the, I mean, article FOMO, influencer FOMO is real.
Like real talk, influencer FOMO is super real.
By the way,
I did build an arbitrage across,
uh, w Across different trades for cryptos and we used Bellman's Ford's maximum flow problem to detect multi leg arbitrage
And it was pretty sweet I made some money,
but the biggest problem is I just didn't have ten million dollars to put in or I literally could have made an incredible amount of money back in the day when there are such inefficiencies in
the market.
At the very least, now that I know Rust, I feel like I can learn anything.
Maybe I'll pick up OCaml for the hell of it.
It can't be much worse than Rust, can it?
OCaml's great, but I think you're going to run into things that you dislike about OCaml equally, but probably less.
I spent this whole weekend fixing it's just milliseconds performance dude.
do that, you can learn anything.
Just in the time, you can learn anything, you really can.
Thank you for reading.
If you're interested in algorithm trading and AI, subscribe to Aurora's Insights.
Want to see how fast Rust really is?
A accounts on Nexus Trade.
Today!
Interesting.
Let's see what the comments are.
Oh, are there any comments?
I wondering if there's comments.
Let's check out some comments.
I completely lost it in the low IQ article.
Damn.
Dude, it's so much nicer to the word skill issues.
Dude.
I do like this.
Well Cornell I went to see a meme I am a gem fellow and I'm a software engineer making six
figures What about me is low IQ wingy face,
you know, you need to judge yourself a little little little word a little word from the Experienced, you know what instead of that.
I'll just show you go to YouTube Go to the and I have a short that I thought was very,
very good, which I tried to make it as obvious as possible.
I have a short that I thought was really, really good.
All right, right here.
We're not gonna listen to it.
Nope, nope.
And the comments are just man discover asserts, then we call this defensive program, that sounds like strong typing with extra steps, right?
Like completely miss what asserts are about, and they say a bunch of stuff.
So instead, in 20 years, just imagine what else this guy hasn't figured out.
So instead, you just don't.
you just don't respond sound like you sound like a loser you just don't respond because honestly
it's easier and I'm okay with that and I try I try just never to respond because I'm just like man
you know it's just it just makes you feel shitty and then they then they're like trying to talk
dude it's just like I ain't about it uh that's still let's see that's still a not rust that's
just MongoDB crate you're complaining about brother You're supposed to write your own errors and overload the source methods for the stack trace.
Anyhow does a good job dot context.
You can't blame Rust for you choosing the wrong language for your use case.
If didn't care about compile time safety and needed faster iteration, you should have known to use language like Go or Python instead.
The problem is that you can say these things.
Personally, I don't know those things until I do them, and I get burnt by them, right?
Because you can generalize this advice to a whole bunch of, you should haves, right?
You ought to have known.
And I find that I- until I have goofed up several times.
You know what I mean?
And I think that that is really, really, really, really obvious.
Only when you're on the other side.
Prime wants to agree and disagree at time.
Exactly.
No, I do.
I do want to agree because it is correct, but it's so hard to tell somebody that.
You know, you don't know until you know.
Like, you know, I've known about asserts for so long.
I've seen them in code for so long.
I never used them then all of a sudden I used them and I really understood them.
Now I can't stop using them, right?
you could not have explained it to me until someone named Jorin, the Tiger Beetle Database guy, gave such an impressive presentation.
I said, I must be missing something.
I will figure this out.
And that I have, now I effing love it.
Despite the fact that I've known about them for like a decade.
Oh, you too, after Tiger Beetle?
Yeah, it's just one of those things that's like, it's super hard to explain something.
Experienced it programming the negative space article.
Yeah, it's it's good.
It's very hard You know you should explore and you should use technologies incorrectly because you'll never know why to use
them performance matters standards standard let's say for high frequency trading
yeah standard algo bots that do crypto not so much okay okay you should see the FPGA and
algos that are nanoseconds second sensitive yeah you're talking about like Jane Street
OCaml on stuff dude it's crazy but in this space for almost a decade and there are some
wild stuff out there rusco etc are not even considered where big money is yeah isn't it
like just you're burning FPGAs I know that when it comes to forex exchange it's or forex
it's all about it's all about FPGAs and nanoseconds sleep the beat I the subs appreciate that.
Anyways, children learn by exploring.
Yeah, and I think that's, we shouldn't discredit exploring.
We really should be very careful about that.
Don't.
don't I think it is good insights in the sense that the pit of success is extremely hard to fall into with rust and I think that if you're going to do rust you got to learn
the language really really well to be effective and that is a huge danger to most people is learning the language Well,
before jumping in,
so before you rewrite your stuff,
maybe spend six months really learning the language,
read through the book, understand about allocations, read through the async book, understand that, practice, pin, pin project, all that crap.
And then once you get it all done, then maybe, you know, it can be better.
Anyways, the name.
Çeviri Dili
Seç
Daha Fazla Özelliği Açın
Trancy uzantısını yükleyerek, AI altyazılar, AI kelime tanımları, AI dilbilgisi analizi, AI konuşma vb. dahil olmak üzere daha fazla özelliği açabilirsiniz.
Büyük Video Platformlarıyla Uyumlu
Trancy, YouTube, Netflix, Udemy, Disney+, TED, edX, Kehan, Coursera gibi platformlar için çift dilli altyazı desteği sağlamakla kalmaz, aynı zamanda düzenli web sayfaları için AI kelime/cümle çevirisi, tam metin etkileşimli çeviri ve diğer özellikler sunar. Gerçek bir çok yönlü dil öğrenme asistanıdır.
Tüm Platform Tarayıcıları
Trancy, iOS Safari tarayıcı uzantısı dahil olmak üzere tüm platform tarayıcılarını destekler.
Çoklu Görüntüleme Modları
Tiyatro, okuma, karışık ve diğer görüntüleme modlarını destekleyerek kapsamlı bir çift dilli deneyim sunar.
Çoklu Uygulama Modları
Cümle dikte, sözlü değerlendirme, çoktan seçmeli, dikte ve diğer uygulama modlarını destekler.
AI Video Özeti
Videoları özetlemek ve hızlı bir şekilde temel içeriği kavramak için OpenAI kullanın.
AI Altyazılar
Sadece 3-5 dakikada doğru ve hızlı YouTube AI altyazıları oluşturun.
AI Kelime Tanımları
Altyazılardaki kelimelere dokunarak, AI destekli tanımlarıyla kelime anlamlarını öğrenin.
AI Dilbilgisi Analizi
Cümle dilbilgisini analiz ederek cümle anlamlarını hızlıca anlayın ve zor dilbilgisi konularını öğrenin.
Daha Fazla Web Özelliği
Çift dilli video altyazılarının yanı sıra, Trancy ayrıca web sayfaları için kelime çevirisi ve tam metin çevirisi sağlar.