#rustlang

[daniel-nerd]

got myself some thigh high socks that means my code will compile now! right?

#:3 #196 #egg irl #traaa #rustlang #rust #computer science #coding #programming

[bizarre-furry-bastard]

#linux #programming #rustlang

[youboirusty]

If your language doesn't have a yeet keyword what are you doing with your life

#funstable #codeblr #programming #rustlang

[aeriavelocity]

Rust is DOOM Eternal

Rust makes you want to learn functional programming just by the fact that variables are immutable by default - and if you want to pass a mutable variable through a function, good luck.

You have to declare "&mut variable" in not only the function call, but also the damn function signature.

Compare that to Python where variables can't even be immutable.

Of course - this is probably a good thing. I'm a devotee of functional programming myself, so I'm biased, but to be fair, I didn't even know what functional programming WAS before I learned Rust.

If C is the Dark Souls of programming, Rust is the DOOM Eternal. (and Python is the Garry's Mod)

#rustlang #programming #codeblr #c #python #doom eternal #dark souls #gmod

[zephiris]

Java is a trash language that should burn in the parts of hell where hitler is

Rust on the other hand is a bratty lil language that should burn in the parts of hell where queers party

#rustlang #trans #java #codeblr #I wrote this in response to a transfem on tinder telling me about how she took a Java class over covid #programming #t4t

[habble0]

#rust #rustlang #coding #programming #computer science #trans #transgender #transfem #trans femme #transfemme #meme #funny #can confirm rust really does do that

[cant-think-of-a-good-one]

This Newly Discovered Lizard Species Makes Saliva that Contains Revolutionary De-Oxidizing Compounds

#fuck now im getting more coding videos recommended to me #i havent been coding that much lately #all my coding projects are peacefully sleeping right now #progblr #programming #lizards #rustlang

[cerulity]

The more you can recreate something in itself, the better it will usually turn out

Geometry Dash is a perfect example of giving a community many small tools to make great things. You can recreate the entirety of the main levels, and it stops far from there. Levels like WHAT, Limbo, Acheron, and many more are prime examples of the community using the tools to their fullest extent. From creating fully animated 3D effects, making the most unique memory level, to the outright hardest level in the game, all with top notch decoration, there's so much you can do.

Rust is also an example of recreatability. The compiler, standard library, and underlying low level implementations are all Rust. You can recreate a Vec with ease, simply using a Box<[T]> and a couple lines of unsafe code. Want to use low level AVX? SSE? AES? core::arch::x86_64 my friend. You can peek into the code if you really want to know what something is doing. Hell, it can even teach you about how things like atomics, reference counting, and deques work. Recreatability in Rust stops at intrinsics, which are added and implemented by the compiler (for good reason, being optimization and homogeneity), but all of them are available for you to use.

#geometry dash #robtop #2.1 #2.2 #rust #rustlang #programming #coding #engineering #software engineering

[itsjunetime]

I built cargo-restore, a tool to migrate installed crates across devices

As the title says, I'm open-sourcing a tool I've been working on called cargo-restore, which helps you reinstall all your crates on a different device. You can read about it and my process in making it here! If it looks interesting to you, feel free to contribute or share your experience using it (either good or bad) - hope y'all enjoy :)

#rust #rustlang #progblr #programming #codeblr #cargo

[chqnnn]

A snippet of code from the project I am using to learn rust. A CLI media player that will hopefully mimic a lot of the functionality of CMUS & foobar2k. I want to design the user interface in the vein of CMUS with the ability to support plugins like foobar2k.

#rustlang #codeblr #studyblr

[ladyargento]

Lost my job as an instructor due to Circumstances. I wanted this outcome so it's not a bad thing but being jobless sucks regardless. I didn't feel motivated to work on Projects for the sake of LinkedIn so I decided to try building a game in Godot Using Rust bindings, and it's been super fun.

#coding #codeblr #development #developers #ladyargento #code #godot #rust #rustlang #game development #gamedev #indie dev

[zipp-os-official]

Starting Production🎉🥂

ZippOS is an alternate operating system for stand alone “spacial computing” devices. The goal of this project is to provide end users, who at their own discression, void their warranties to replace pre-packaged software bundled with their hardware. As the lead developer of ZippOS, and as an end user of a “spacial computer”, I am displeased with the current operating software, and the decisions of parent companies that distribute these products are inheriently unstable, brown-nosing share holders and consumers, and completely unaligned with the end users. As these devices are marketed as computers, I want to provide software for said computers as a choice for the end-users who feel the same as I do.

ZippOS will be a lighter(get it?), faster booting operating system built from scratch with Rust-Lang and some ARM/RISC-V assembly code to replace both the BIOS (ZIOS) and the operating system. The operating system’s goal is to have the same user functionality and multimedia multi-instancing in a mixed reality setting, citing BeOS/HaikuOS as inspiration. This operating system will have security and graceful degradation as the main focus for user safety because the main enemy for ZippOS is the companies who made the stock software it replaces on the end-user’s spacial computer. Users can also enjoy various stimulating options for navigating the software (i.e. “rolodex” style hub menus, table-top program/application storefront, “grabbing” and “throwing” programs/screens to be cast/mirrored to and from realspace and cyberspace, etc). ZippOS is a project software operating system under development, and currently has no plans to publicly publish to the open net, nor are there any current plans to open-source the software.

#ZippOS #Zipp-OS #Zipp OS #rustlang #rust-lang #operatingsystem #OS #linux #assembly language #assembly programming #riscv #arm64 #mixed reality #virtual reality

[nixcraft]

#c++ lang #rustlang #programing #programmers humor

[disincentivized]

#rustlang #rust #transgender #trans #lgbtq

[voltradar]

Got my tights, skirt, heart choker, and hoodie. Anything else needed to complie my Rust?

#rustlang #sfw femboy #coding

[autisticrustacean]

How I comprehend pointers (in rust)

the main pointer types are:

&T

&mut T

Box<T>

they each have different properties;

&T can read T, but the compiler (borrow checker) statically analyzes your code to make sure that no writes occur to the pointee while there is a reference to it.

&mut T allows mutability, though only by it, and the compiler makes sure nothing reads from T while there is a mutable reference, and that there is only one mutable reference to T at at time.

Box<T> is fairly different, to own a box to T is to own a T, it automatically drops T when it's dropped, and it always points to the heap.

one of the interesting parts is when you decouple these types from their behavior (I comprehend types as pairings of data and behavior), their all the same, their a usize integer that points to a byte. there is no fundamental difference to what usize*, &T, &mut T, and Box<T> store. the difference is all in compiler checks and behavior, the Drop trait for Box<T> tells the computer to run drop on T, where as the other two just drop themselves.

Wide Pointers

there is another important component to pointers, 'metadata', as best as I can tell a pointer is equivalent to (usize, T::metadata), metadata coming from the (unstable) Pointee trait, and it's what makes a pointer wide or thin. Pointee is defines metadata as a type other than unit (()) for three types, slices ([T]), str, and dyn Trait. slices store the number of elements as usize, str does bytes, and dyn Trait stores another pointer to it's vtable.

for slices and str this allows the program to know how long the array at the end is, so that you can iterate til the end, and for bounds checking, as well as how &[T] can be obtained from [T][{Range}] and know where it's bounds are, the pointer points to the range's lower bound-th element (or the first element if it's not lower bounded), and the upper bound is stored in the metadata as the difference from the first element in the borrow. I don't really want to get into what vtable does here though.

Points to where though?

this is FAR beyond the scope of my knowledge here, so maximum 'grain of salt' here. I envision three spaces a pointer points to, I consider them large chunks of contiguous, but largely ineffable memory.

the Stack where your local variables and execution is

the Heap where larger or unsized data goes

the Binary where you're functions, vtables, and string literals are stored (that's why string literals are &'static str) everything here is unwritable and it holds the actual 'program' part of your program

*as I get to later, wide pointers are a bit more than a usize

#rustlang #pointers #programming #idk what im doing