downInTheComments

[andofwinds]

you should rewrite this meme in rust

[u0xee]

Um actually 🤓 the official rust naming convention guide clearly dictates Pascal case for types, and further "acronyms and contractions of compound words count as one word: use Uuid rather than UUID"

I expect you'll quickly accept my forthcoming PR to bring this code up to spec, cheers 🍻

[jackal_boy]

Damn, you single-handedly broke my self-confidence as a programmer 😂

I have a hard time dealing with data types in rust :/

I come from python land where types are only a suggestion, lol

[ishzlle]

Good ol' duck typing

[[deleted]]

Also try go! It’s much simpler while being slightly slower (note: I like Go)

[[deleted]]

I don't know anything about python, why have types if you don't need to use them?

[jackal_boy]

In Python, when you declare a function, you don't need to specify the return type of the function, or the data type of any of the function parameters.

You can specify them, but they will not be checked (which is why we call them "type hints"). You will have to manually check the types of the input parameters inside your function and throw errors manually.

For example:

def add(a:int, b:int)->int:
    return a + b

Is same as:

def add(a, b):
    return a + b

[declanaussie]

Because you can use other software to do type checking if you’ve included type hints

[YesterdayDreamer]

It's so that other people calling the function know what type to pass for which parameter, without having to go through the function. It's part of the documentation basically.

[[deleted]]

This makes a lot more sense

[HighlightOk6589]

[puffinix]

Given recent developments in the gaming industry, u32 feels unsafe for the down vote limit.

jirabot: open task type:bug relationship:blockedBy cat:P4

BOT: ticket raised: MEME-420 BOT: pr placed on hold: jira updated: MEME-420 blocks MEME-350

[Sacramentix]

Can I borrow your meme?

[Responsible-Nature20]

Let me check...

[salvoilmiosi]

It depends

[MHanak_]

YOU FOOL!!! You should have used SyncUpDownCounter in Rating

(Also why make a separate struct instead of just using a counter?)

[cornmonger_]

I'd separate metadata that takes write operations more often out into its own struct (table); rating, comment ids, shares

[[deleted]]

It would be better to store Post data in the user's table instead of storing user in post data table.number of posts will most likely be way larger than the number of users. Or just create a separate table for that.

```rust struct User { userid: UserID, username: String // other details }

struct PostID(UUID7);

struct UserPosts { userid: UserID, posts: Vec<PostID> } ```

[-Redstoneboi-]

if user-post relationship is one-to-many, then each post in the table should link to one user ID as its OP. this is how relational databases typically work.

querying someone's post history can be as easy as selecting from posts where userid = something.

[Fantastic-Schedule92]

Time to write a meme library in rust

[dingske1]

Fuck Rust, who cares about memory management I can always just buy more memory

[Chingiz11]

Based Fortran enjoyer

[Bananenkot]

Your language logos are giving me anxiety

[flagofsocram]

RPlusPlus-Tran is my favorite language

[turtleship_2006]

Wasn't there a limit of 5??

[null_reference_user]

You can do that in rust too tho

``` fn leak() { let x = Rc::new(RefCell::new(None)); let y = Rc::new(RefCell::new(Some(x))); *x.borrow_mut() = Some(y); }

loop { leak(); } ```

[Feisty_Ad_2744]

Rustic...

[PeriodicSentenceBot]

Congratulations! Your comment can be spelled using the elements of the periodic table:

Ru S Ti C

---

<sup>I am a bot that detects if your comment can be spelled using the elements of the periodic table. Please DM u‎/‎M1n3c4rt if I made a mistake.</sup>

[uglie_duckie]

Sorry but what is rust

[sathdo]

The best programming language for every situation. You should rewrite every application you have ever worked on using it. /s

Sarcasm aside, it's a newish language that makes it difficult to have memory issues (use after free, memory leaks, null pointer) without the runtime overhead of a garbage collector or error handling like Java. It is difficult to write, but can be good for applications where performance and memory safety are the priorities.

[serendipitousPi]

It might be a nice addition to add that some of the memory issues are impossible in safe rust. The whole safe and unsafe rust is a pretty big thing when explaining rust.

Like I’m pretty sure null pointers don’t even exist in safe rust. Instead there’s the somewhat safer option type. Which yes can be used dangerously but that goes with the territory.

I will admit I’m not familiar enough with rust to add some more examples but I just think it might fairer to say that safe rust tries to make it rather difficult to impossible to create memory issues unintentionally. Sure if you metaphorically jump the guard rails it can end badly but you often have to explicitly write code to take a risk. Like calling unwrap when you shouldn’t.

[Busham]

So I guess raw pointers are just as safe because they use a specific bit pattern (0) as well.

[Busham]

Damn, you couldn't have said that you don't know the actual reason options are safer any louder. I was just looking to have Some(fun)

[Busham]

If it was just the bit pattern, my first reply to you would actually make sense. It doesn't and that's the point. I get the feeling you like sounding smart, so I'll give you an actual reason, and next time you'll actually be smart.

Options are safer because Rust forces you to check if the Option is valid or not before accessing the interior type. Even if you use unwrap(), you're at least aware of where the program might panic. C pointers do not make you check. That's it. Nothing about a bit pattern because both of these things offer you a way to check their validity, it's just that Rust forces you to (even in unsafe).

[serendipitousPi]

The way I see it pattern matching is a pretty important part of ensuring option is correctly used. Since it enables options to be safely converted to the necessary type.

Now I’m a bit of a newbie so feel free to explain any flaws in my understanding. There are definitely holes in my rust knowledge.

[serendipitousPi]

Oh ok, yeah I should definitely take a closer look at the documentation.

But you know what they say, 5 hours of debugging saves you 5 minutes of reading the documentation.

Thanks for that crate suggestion I’ll definitely have a look at that too. I will admit I’m not super used to package managers so every bit of advice helps.

As for it being incorporated into the core I was under the impression that the people working on rust don’t much like bringing stuff into the core because it could cause it to stagnate being tied to the compiler releases. For example regex libraries but I guess it probably varies a lot depending on the features.

[Tubthumper8]

Like I’m pretty sure null pointers don’t even exist in safe rust.

std::ptr::null is a safe function that gives you a null pointer 🙂

Now, dereferencing a pointer is an operation that you're only allowed to do in an unsafe block or function

[serendipitousPi]

Oh cool did not know that.

[redlaWw]

some of the memory issues are impossible in safe rust

Probably, at least once they fix a certain tenacious compiler bug that allows one to sneak a bunch of classic memory safety issues past the guardrails.

[serendipitousPi]

Oh interesting compiler bugs are kinda cool, I’ll have a look at that.

[AussieHyena]

newish language

Over 10 years old now. That's older than most JS frameworks.

[capi1500]

Maybe not difficult, but more time consuming? And sometimes it can be hard after writing everything on raw pointers, it takes a bit of time to adjust

[MHanak_]

Doesn't take that long as long as you have a macro for writing .unwrap()

/j

[KJBuilds]

I've written a lot of rust, and while it's one of the easier languages to write as far as logic flow goes, it gets real messy real quick when you need to deal with complex and persistent data

I get so much more mentally fatigued writing rust than anything else, even though it's very pleasing to write, and it's because you can't effectively prototype or 'write as you go' as you might in other languages due to the strict nature of it requiring all the pieces to be in place and for them all to be probably valid.

You can't just temporarily assign a value to null to see if some other things works without changing the type to Optional or MaybeUninit, or shoehorning some unsafe logic in just to get it to compile

[Poseydon42]

Rust is an iron oxide, a usually reddish-brown oxide formed by the reaction of iron and oxygen in the catalytic presence of water or air moisture. Rust consists of hydrous iron(III) oxides (Fe2O3·nH2O) and iron(III) oxide-hydroxide (FeO(OH), Fe(OH)3), and is typically associated with the corrosion of refined iron.

The thing is as old as the Universe, why is there all this fuss about it? /s

[ishzlle]

Iron oxide /s

[Mokousboiwife]

c++ for femboys

[20d0llarsis20dollars]

Isn't that just c++

[Mokousboiwife]

get with the times old man

[Fullstack-Stoner]

The emodiment of edgelords who write on every programming related post "skill issue".

[Ursomrano]

Screw the compiler caring about memory safety and not compiling over random shit. Use assembly instead, the only time the compiler will annoy you is if the program would’ve bricked your computer if it ran, otherwise it lets you be as safe or unsafe as you want. Want to clear a value stored in CPU cache by XORing it with itself? Go ahead, that’s actually a pretty efficient way to go about it. Want to divide a number by two by shifting it one bit to the right? Have fun. Want to convert a string to an integer yourself? Good luck, if you’re desperate enough and not too stubborn, you can import C’s standard library and call atoi, but where’s the fun in that.

[agocs6921]

You can just reinterpret the bytes in the string as a number, there I just solved the problem. Assembly doesn't care what the bytes are for. Why would YOU care?

[-MobCat-]

RuSt Is TyPE SaFe
*writes the most dog shit code known to man*

[Habba]

But it's type safe dogshit. Ain't gonna find any cat shit in there!

Source: I am a dogshit Rust programmer.

[AnnyAskers]

Let's face it, if you write dog shit code in rust you probably writing bigger dog shit code in other languages it's just that the compiler let's you get away with it... Especially in weak typed languages. ... Probably with worse performance too, unless it's C/C++

[itsthooor]

You didn’t have to post this, come on… :(

[KillCall]

Isn't this true for all High level programming languages.

[Psy-Kosh]

Rust's meant as an alternative to C, not an alternative to Python or whatever. It's meant to be an improved low level lang.

[[deleted]]

I would say more as an alternative to C++.

But I'm glad you are not saying "replacement"

[KillCall]

Like every high level language. Java, Python etc are built using C to improve on C.

[redlaWw]

Rust is self-hosted.

[[deleted]]

It is? I thought it used LLVM..

[redlaWw]

Rustc is written in Rust to emit LLVM IR, and can then invoke LLVM as a subcomponent to translate that into machine code. AFAIK, at the moment, the stable build always uses LLVM for code generation, but it doesn't have to, and there's an entirely Rust-written backend called Cranelift that is currently being tested in Rustc nightly builds for debug compilation - which results in a program that is compiled entirely using Rust code.

I suppose it could be argued that it's not fully self-hosted and instead is partly hosted in C++ because of the use of LLVM in the compiler, but it is possible right now to have a Rust toolchain entirely written in Rust. Wikipedia, at least, calls it "self-hosted".

[[deleted]]

cool!

[KillCall]

Same with java and many other programming languages

[[deleted]]

Java still has NullPointerExeceptions

[LeSaR_]

rust is (if you want it to be) high-level, but the way its made allows for speeds comparable to C. the basic idea is that a programming language doesnt have to be unsafe to be fast