14 ms·

What is everyone building in rust, and how do the killer rust features (mentioned in other comments) help you? I'm not anti rust in any way, it's more of havin

What is everyone building in rust, and how do the killer rust features (mentioned in other comments) help you? I'm not anti rust in any way, it's more of having limited time and so many languages problem. But I'm interested in the types of problems rust is good for, so I could consider it if/when I encounter them

pjmlp 4y ago
Only hobby coding. Java, .NET languages and C++ are what pay the bills for me.
mathstuf 4y ago
I've used it to build two "bulletproof" services that are never intended to go down (the first catches webhook events and puts them to disk and should never go down; the second processes the on-disk files separately so that reloading the configuration can't cause us to miss webhook events). It is far nicer to have error handling as a visible part of the workflow so that you don't get "whoops, didn't consider that" situations (we had this constantly in the Python predecessor that had problems with "uh, you forgot to mention this might not be pure-ASCII, so I'm going to fall over now" problems as various fields popped up with Unicode over time). Best parts IMO (not in any order and not exhaustive): - Not having to consider exceptions (panics are still there, but are much closer to the "exceptional" behavior exceptions are/were meant to convey) - Explicit error handling with (usually) good error types/representation (instead of the nebulous "`err` that is a string" I've seen in what little Golang I've done) - Threading without worrying about race conditions - Dependency management - Data structure focused (instead of object focused) - The built-in `#[test]` features are also great and make it easy to test internal code without exposing it in some strange way purely for testing purposes. FWIW, I find that it also makes your C++ far better because now you can more easily "see" lifetime problems that people tend to write out of habit (`return stackstr.c_str();` is a…favorite that compilers now warn about).
shpongled 4y ago
I'm building scientific software in Rust. Phenomenal performance, drop-in concurrency support (`iter()` -> `par_iter()` with Rayon), and a great ML-based type system that makes writing correct code easy. It also has some of the best developer UX/tooling out of any language I've used.
nynx 4y ago
I’ve written a bunch of embedded software in rust.
pornel 4y ago
Cloudflare is using Rust for network stacks, proxies, caches, compression, and image processing. Basically everything that you would use C or C++ for, but where security is also incredibly important.
jackmott42 4y ago
I've done some hobby projects in Rust. One was a SIMD abstraction library, where you could write code that looks more or less like SIMD intrinsics, but it would either at compile time or runtime select the SIMD instruction set for the target cpu. The traits/generics/macro system made that feasible, though messy. You can do similar things with templates in C++
Macha 4y ago
Rust has replaced Python for me in my personal CLI tools where I expect to use them as an ongoing basis. At this stage I am almost as fast writing Rust as Python, find the Rust projects much easier in terms of environment setup than the whole pipenv/poetry/pyenv world, and enjoy the instant response of not having to wait for a python interpreter startup. I also have some side projects like a gameboy emulator, where it's nice to have what is effectively a lower level language with the safety and features of higher level language. My day job is mostly Java/Javascript though, rewriting the world isn't yet worth it, but there's certainly one or two of our systems where if a rewrite in another language was on the table I'd make the case for Rust
- Scarbutt 4y ago
  At this stage I am almost as fast writing Rust as Python By generously use of copying?
  - oconnor663 4y ago
    The "One Simple Trick" that lets you port most Python code straight to Rust is to take all the aliasing "object soup" references that Rust doesn't like, shove those objects in a Vec or a HashMap, and use indexes/keys instead of Rust references. This does require plumbing the Vec/HashMap around through different functions, but if you do it this way from the beginning it's not much extra work.
    - int_19h 4y ago
      At that point, what's the benefit of using Rust over basically any other high-level language that has ADTs and pattern matching? Since you lose all the benefits of lifetime tracking that are unique to Rust.
      - oconnor663 4y ago
        > you lose all the benefits of lifetime tracking that are unique to Rust I think I understand what you're referring to, but stop me if I get this wrong. If you put a bunch of objects in a Vec and refer to them by index, you have to be careful with operations like .insert() and .remove() that shift Vec elements around and change their indexes. Also if you make each element an Option<T> to support deletion without .remove(), you still have to be careful about indexes of deleted objects, because you might put a new object in the same spot later. I have several thoughts about this: - If "memory safety without garbage collection" is one of the unique features of Rust, you still have that. A reused Vec index in safe Rust code will never corrupt memory or trigger a segfault or anything like that. It's strictly a "logic bug". - These logic bugs only apply specifically to the objects you put in a Vec and track by index. Creating a Vec<Foo> and getting an index mixed up doesn't change anything about Rust handles your local variable of type Bar (or for that matter, your local variable of type Foo). - These bugs are understandable for beginners, and you can follow what's going on with print statements. Contrast that with a dangling pointer into a C++ std::vector that just reallocated, where printing the freed object often appears to show good data, and explaining the bug means talking about malloc/new and the heap. Relatedly, unwrapping a None in Rust will always panic and will never coincidentally appear to work. (Your comment was comparing Rust to higher level languages, but I've heard similar comparisons to C++.) - There are good options for fixing the problem. Beginners might prefer to put their objects in a HashMap with an incrementing key. There's a performance cost to that, but it's familiar and relatively footgun-free. More advanced folks might reach for something like "generational indexes into a slab", which gives you back some performance in exchange for making you learn a bunch of new buzzwords and figure out which implementation to choose from crates.io. So yes, with those caveats, putting objects into a Vec does turn some compile-time bugs into runtime bugs. That is a downside, much like Rc/Arc/RefCell/Mutex come with runtime downsides. But I've heard folks describe it in terms like "turning off the borrow checker", and I don't think that's a very accurate way of describing it.
orthecreedence 4y ago
I do a lot of cryptography stuff in rust that is ported to various platforms and embedded in larger apps so I don't have to write the same logic over and over (desktop/mobile mainly). Also, lately working on some identity/p2p stuff.
ostenning 4y ago
I'm building commercial hardware products using embedded Rust, I love it. I cant really imagine going back to C. I haven't dug too deep into the offerings with this update, but none of the standard library stuff is relevant for me
kibwen 4y ago
I work on a project that's basically a mini-OS designed to host WebAssembly applications. The OS parts need to run on bare metal and do all sorts of cursed shenanigans, where Rust's separation of safe and unsafe code lets us better focus on proving to ourselves that the unsafe bits are working as intended (we also test our unsafe code under Rust's Miri interpreter/sanitizer for extra confidence). IOW, the killer feature is low-level control plus a reasonable expectation of safety. The actual WebAssembly interpreter is also written in Rust, which is a good fit because inefficiency in an interpreter leads to inefficiency in anything running in the interpreter. The killer feature here is performance plus safety. The overall package is bundled up into a CLI app that lets you deploy an instance of our OS with your application running within. Rust has a fairly nice wealth of libraries that make this pleasant, from CLI argument parsers to cryptography to OIDC and beyond. And it all gets packaged up into a single binary for easy distribution (even the OS and interpreter parts, which get embedded directly in the binary via `include_bytes!`). The killer feature here is great platform support (including cross-compilation) and small binaries (though you may reasonably disagree on "small"; altogether the binary (again, including the OS and interpreter) comes out to 25 MB). Finally, Rust's lack of a pervasive runtime and great WebAssembly tooling means that it's easy to compile Rust applications to run on top of all this as well.
- cultureulterior 4y ago
  This OS seems interesting! Link?
  - kibwen 4y ago
    Keep in mind that I'm using "OS" here loosely; it's a bare-metal program that exposes a subset of Linux syscalls so that the interpreter (which itself is compiled for Linux) can run in the extremely specific context that we target. It's still early days so I won't spend too much time shilling it, but all the code is open source and lives under the umbrella of the Linux Foundation: https://enarx.dev/ https://enarx.dev/
cliffcrosland 4y ago
We are using Rust to build a fast log event database. The workload includes a lot of asynchronous networking I/O and parallelized CPU-intensive work, like indexing and SIMD-accelerated string search. There are great libraries for what we need. The performance and low memory footprint are quite useful.
Hamuko 4y ago
I've written a small automatic file organiser in Rust that I run in a Docker container on my NAS. Docker reports that the container is using 1.5 MiB of memory, so that's pretty nice. Pretty sure I wouldn't have achieved that if I wrote it in Python like I normally do.
- pdimitar 4y ago
  That project sounds interesting and I think it aligns with what I need. Have you open-sourced it?
  - Hamuko 4y ago
    Nope. I've been meaning to, but I feel like I need to clean up the code up a bit before I do that. It's also quite niche, so I'm not sure if it's for everyone's use cases.
ekidd 4y ago
I've built a fair amount of production software in Rust. The best features are: - Rust is naturally pretty fast, on the rough order of C++ in many cases. Even unoptimized programs tend to be very snappy (as long as you remember to compile in release mode and buffer I/O). - Rust tends to warn me if I make a dumb mistake, rather than having my program mysteriously corrupt memory at run-time. - Rust has very nice support for portable CLI applications, both in the standard library and in third-party libraries. - With a bit of extra work, I can usually deliver a single, statically-linked Linux binary. Go is even better at this, but Rust does it well. - It turns out the "algebraic data types", what Rust calls "enum" and "match", are just a really nice way to write down every possible "case" or "state" of some value. If a piece of software involves hundreds of special cases, Rust allows me to think about them clearly. - Rust has surprisingly good third-party libraries for many things. (Not everything.) - Multithreaded Rust apps are a dream. Cons: - Rust forces me to keep track of whether things live on the heap or the stack, whether I'm passing them by value or reference, and so on. This is good when I want performance, but for other kinds of code, it's just a "cognitive tax." - Rust's learning curve is higher than Go, but arguably lower than C++. This is especially true if you've either never worked with stack/heap/pointers before. - Rust tends to favor "mostly functional" architectures over "mutable objet soup" architectures. This pushes you to use less-familiar designs for games and GUI libraries, for example.
- albrewer 4y ago
  > I've built a fair amount of production software in Rust. Any examples?
- wiseowise 4y ago
  > Rust tends to favor "mostly functional" architectures over "mutable objet soup" architectures. This pushes you to use less-familiar designs for games and GUI libraries, for example. How is that a con?
  - ikawe 4y ago
    One example would be the lack of pragmatic rust native GUI libraries. There are wrappers for GTK and Qt, which are probably your best option. The most popular pure rust ones are based on somewhat esoteric patterns and seem prone to being abandoned. Within that there are some interesting options, like for functionally reactive programming and immediate mode guis, but these paradigms aren’t all encompassing and in fact cover a pretty minority use case based on what GUIs are being created today. Maybe one day we’ll all only ever create purely functional GUIs and speak Esperanto, but until then, we’re a little hamstrung in rust.
teknopurge 4y ago
security. I dabble with system programs and it's nice to get the speed/portability of native optimized code and know most memory issues won't occur.
kylebarron 4y ago
I'm building WebAssembly bindings to existing Rust libraries [0] and lower-dependency geospatial tools [1]. Rust makes it very easy to bind rust code to both WebAssembly and Python. And by avoiding some large C geospatial dependencies we can get reliable performance in both wasm and Python using the exact same codebase. [0]: https://github.com/kylebarron/parquet-wasm https://github.com/kylebarron/parquet-wasm [1]: https://github.com/kylebarron/geopolars https://github.com/kylebarron/geopolars
- theptip 4y ago
  Oh, that’s really cool. Rust noob here, and I hadn't seen the tooling for building Python bindings. That looks like it could be a very powerful way to speed up your Python programs (much easier than the “just replace the slow bits in C” advice that was standard.) The mappings in https://github.com/kylebarron/geopolars/blob/master/py-geopolars/src/geoseries.rs https://github.com/kylebarron/geopolars/blob/master/py-geopo... for example look very easy to follow.
dymk 4y ago
I've written no code professionally in Rust, but a fair amount of personal project code. I've written C++ both professionally and as a hobby. At least for hobby use, comparing the two, Rust is wonderful. - It's easy to set up cross compilation. - Cargo makes dependencies easy. - Building is almost always just `cargo build` except for very exceptional projects, same with `cargo test`. - `cargo fmt` makes formatting easy and built in. - Clippy gives actually useful lints and can automate most refactorings. - Rust-analyzer is fast to index decently large projects, works with almost all language features (even complex ones like proc macros), and has some real time-saver automation built in. Working with the borrow checker can feel like a pain, but in many cases, feels like a fun puzzle (writing hobby code, I'm not under time pressure, so it's 'solve a puzzle' and not 'oh fuck deadline coming up'). But really, the tooling of the language is where it shines.
CJefferson 4y ago
Personally, I use Rust as a "better C++". Ways in which it is better: * A decent package manager * "Safe by default" (you have to use 'unsafe' to turn off the safety features), unlike C++ which is "unsafe by default" (v[i] is undefined behaviour if i is out of bounds, for all of C arrays, std::arrays and std::vectors). * Really easy to do multithreading -- I had reached the point with C and C++ where I was of the opinion it is "almost impossible" to write large thread-safe programs, and all communication should be between processes with pipes, wherever reasonable. In Rust I again feel I can safely and productively write multi-threaded code. The things Rust doesn't let you do (throw pointers around everywhere) can get a little annoying, but I find the extra safety increases my productivity enough that it's worth the tradeoff.
- dralley 4y ago
  >(you have to use 'unsafe' to turn off the safety features) "unsafe" doesn't turn off any safety features, it just allows you to do additional things which the base language does not, like: * use raw pointers * use mutable static globals * access fields of unions https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html#unsafe-superpowers https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html#unsa... All the rules of safe Rust still apply inside of unsafe blocks. The borrow checker still works, etc.
- tialaramex 4y ago
  You didn't say otherwise, but this is such a frequent misunderstanding from people who don't write Rust, or write only safe Rust (which is fine) that it's worth pointing out the unsafe keyword and Rust's choice to be "safe by default" are not directly related. Culturally obviously they come from the same place, but for example: v[i] is bounds checked in Rust even in unsafe. The unsafe "super powers" don't include "magically now indexing has no bounds checks" but because Rust's get function v.get_unchecked(i) is marked unsafe‡ you would need to mark code unsafe to use that function and that function doesn't have bounds checks. If you write: unsafe { println!("{}", v[i]); } The compiler will point out that unsafe isn't doing anything for you here, v[i] is safe, marking it unsafe is just a waste of everybody's time. C++ doesn't have bounds checked array access for its abandoned built-in arrays, but it does (these days) have bounds checked access for std::array and std::vector as a separate member function, however because they aren't the default few C++ programmers use them even where they undoubtedly should. This is an ergonomics issue, it's just easier to write needlessly unsafe C++. ‡ This said just get() before I edited it, but Steve corrected me, see below.
gattr 4y ago
I wrote a video acquisition tool for astrophotography [1] (and I dogfood it). Uses GTK3 for GUI. [1] https://github.com/GreatAttractor/vidoxide https://github.com/GreatAttractor/vidoxide
allisdust 4y ago
I use it to write backend web services. Some how it doesn't appear to be any less productive than typescript +nodejs combination. Library support used to be a mess but now a lot of good libraries exist to get the job done.
di4na 4y ago
NIFs for particular casting of numbers to other binary formats in erlang. NIFS for embedded database and data format in erlang. Main reason ? It works. The compiler has real error messages that are helpful making the onboarding of anyone having to fix problems a far far better situation than any of the competitors. It has a proper modern toolchain. All of these would be killer features. All together ? No competition. I also write cli tool and all kind of parsers for embedded language. The libraries here, in particular if you want good error messages and UX, are simply the best in all other environment i know of.
api 4y ago
ZeroTier version 2 is being built in Rust, with the main reasons being safety (it's a network protocol!), easier cross platform compilation, easier dependency management, and an all around better language than C++. It should help us greatly boost developer velocity while also be much safer from a security point of view.
- mwcampbell 4y ago
  That will also make it more attractive to other developers using Rust who want to embed the SDK. Speaking of which, I've emailed ZeroTier a couple of times now about licensing the SDK (the first email was last week), and haven't yet heard back.
solar-ice 4y ago
I write video streaming software in Rust. Rust helps us make sure we've got concurrency correct, has a very solid type system to help us make sure we've got general application properties correct, and seriously reduces the space where we have to go looking for segfaults and suchlike (primarily third-party C libraries and bindings to them).
huyage 4y ago
I'm building an HTTP CRUD app on top of PostgreSQL. I have previously used Go for various CRUD apps. The experience is better except for compile time. My favorites: 1. Much more expressive type system: no more `interface{}`. 2. Algebraic data type with `enum`. Exhaustive check. 3. `serde` crate is lightyears ahead of Go's `json:"wtf"`. 4. Compile-time checks against DB with `sqlx` crate. 5. Logging is a breeze with `tracing::instrument`. 6. Using macros to reduce boilerplate has better UX than Go codegen. What these give me is more confidence in development/refactoring because the compiler can guide me most of the way. Low lights: 1. Build time. 2. Async is still clunky. e.g. Try to implement an `actix-web` extractor or middleware. 3. Please just stablize nightly rustfmt features already.
- mjb8086 4y ago
  I'm looking to do a bit of CRUD on top of PostgreSQL as well. Currently mid-way through learning the language. Would you mind sharing some of your experiences? Do you find the 'stubbornness' of the compiler frustrating at all? How do you find the tooling? Also, I've considered Diesel for ORM, so was wondering if you've been using that too.
  - huyage 4y ago
    > Do you find the 'stubbornness' of the compiler frustrating at all? I actually love it. The more work I can offload to compiler the better. One simple example that frustrated me in Go was adding a field to a struct. You add the field the the whole thing still compiles even though the zero-initialized value probably broke your app logic. In Rust if I add a field to a struct, the compiler warns me about all the places that I need to double check. > Would you mind sharing some of your experiences? I highly recommend zero2prod book which is well-written, practical, but still teaches the essential principles (https://www.zero2prod.com/ https://www.zero2prod.com/). You basically deploy a CRUD app to DigitalOcean from scratch. The best way to ramp up IMHO. > How do you find the tooling? Cargo is sweet. rust-analyzer is all I need. I need less extraneous tooling to be effective. For example, in Go I might use a task runner to watch the repo and run tests when I change a file. But in Rust I can just follow the rust-analyzer highlights and manually compile less-frequently. > Also, I've considered Diesel for ORM, so was wondering if you've been using that too. I was not happy with GORM (https://gorm.io/index.html https://gorm.io/index.html) and never had a satisfactory experience with any ORM. I'm a fan of writing plain SQL, even in Go. It's just that with Rust sqlx I can get compile-time checks against the schema. It's not anything new (see Haskell), but it tightens the feedback loop and I have full control of the performance.
emadda 4y ago
https://table.dog https://table.dog (a CLI to download Stripe to SQLite). I considered Node.js, C#. I went with Rust for a few reasons: - Easy to build small portable binaries (as a primary language feature). - The type checker ensures type consistency when writing out to SQL tables (SQLite is loosely typed). Code that reads from the SQLite database implicitly benefits from Rusts strong type checks. - Macros to convert structs to SQL insert/updates. - Reduce the chance of errors at runtime. - Leverage as much as SQLite's write throughput as possible. - When converting Stripes Open API JSON spec into Rust code (using another Node.js program), the Rust type checker ensures I have a well formed HTTP client - the strict compiler makes it a good target for generated programs. Read more about this idea at (https://willcrichton.net/notes/rust-the-new-llvm/ https://willcrichton.net/notes/rust-the-new-llvm/).
- masklinn 4y ago
  > SQLite is loosely typed FWIW in recent SQLite you can turn that off using “STRICT” tables, however that means the available types are restricted to INT(EGER), REAL, TEXT, BLOB, or ANY. ANY is also “Stricter” in strict tables: it does no conversion whatsoever, whereas in normal mode it’ll try to parse literals to numbers, and store a number in that case.
bsnnkv 4y ago
I've built the most popular[1] actively maintained tiling window manager for Windows that is available today.[2] It would have been impossible for me to build this in any other language. I knew absolutely 0 about developing for Windows when I started this, but I quickly realized that the Win32 API is a very old beast with a lot of footguns that Rust saves me from on a daily basis. On top of that, with parking_lot I can quickly and easily detect incredibly rare instances of deadlocks, and in general have to worry very little about concurrency. All of this allows me to stop worrying about the noise and focus on the real work of how the window manager should behave. 1. Based on Github Stars 2. https://github.com/LGUG2Z/komorebi https://github.com/LGUG2Z/komorebi
marcosdumay 4y ago
I am currently writing a kinda complex GUI application intended to run on a browser. So it's in webassembly. Compared to Javascript, Rust safety features allow me to iterate quickly and improves my productivity from "I won't be able to complete this project" to "it's trivial, just some work". Compared to Typescript, Rust gives me some performance and types that actually represent the data I use, but I am not sure if I lost a bit of productivity (the TS tooling is horrible, so programing a bit slower isn't the entire story). I don't consider this a problem Rust is good for, but one that all the more suitable languages still don't support.
__david__ 4y ago
For me the killer feature of Rust is its nice broad scope. I've done: - embedded programs on avr hardware, which is impressive that something like rust can compile down to an 8 bit micro. Doing some sort of crazy map/iterator filter closures and finding the resulting assembly being nice and tight makes me super happy. - web servers and clients (a scraper that collects scores from a web page and serves its own page of aggregated scores to my family). - a low level opengl tmux/terminal client (Rust's Enums were a killer feature here) - a windows GUI program for installing a PC game mod (99% developed on a mac and cross-compiled) - a cli app to "compile" svgs down to png sprites for a web based game - a launcher for Emacs that uses native cocoa apis to display a dialog on error Each of these cases ended up pushing different parts of Rust for me. I would say the killer feature that spans all of those is Cargo and the crates.io registry. There are a ton of very good libraries out there—it feels like the heyday of CPAN or RubyGems to me. I also quite enjoy how many programming errors Rust finds at compile time. With Rust code I spend way more time fixing compiler errors, but when it compiles I typically don't find a ton of major logic errors. I personally find it extremely rewarding when I get something to compile and then it just works. This happens more in Rust than in other languages I've heavily used.
andrew_shay 4y ago
I've built a p2p file transfer program [0]. All my development experience had been in Python, but I really wanted to try a statically typed, low level language, and decided to give rust a try. It was hard to get going, and I still only know basics, but everything just works! Typing, borrow checker, the matched results, all of that makes code bullet proof. [0] https://github.com/transmitic/transmitic https://github.com/transmitic/transmitic

pjmlp 4y ago

Only hobby coding. Java, .NET languages and C++ are what pay the bills for me.

mathstuf 4y ago

I've used it to build two "bulletproof" services that are never intended to go down (the first catches webhook events and puts them to disk and should never go down; the second processes the on-disk files separately so that reloading the configuration can't cause us to miss webhook events). It is far nicer to have error handling as a visible part of the workflow so that you don't get "whoops, didn't consider that" situations (we had this constantly in the Python predecessor that had problems with "uh, you forgot to mention this might not be pure-ASCII, so I'm going to fall over now" problems as various fields popped up with Unicode over time). Best parts IMO (not in any order and not exhaustive): - Not having to consider exceptions (panics are still there, but are much closer to the "exceptional" behavior exceptions are/were meant to convey) - Explicit error handling with (usually) good error types/representation (instead of the nebulous "`err` that is a string" I've seen in what little Golang I've done) - Threading without worrying about race conditions - Dependency management - Data structure focused (instead of object focused) - The built-in `#[test]` features are also great and make it easy to test internal code without exposing it in some strange way purely for testing purposes. FWIW, I find that it also makes your C++ far better because now you can more easily "see" lifetime problems that people tend to write out of habit (`return stackstr.c_str();` is a…favorite that compilers now warn about).

shpongled 4y ago

I'm building scientific software in Rust. Phenomenal performance, drop-in concurrency support (`iter()` -> `par_iter()` with Rayon), and a great ML-based type system that makes writing correct code easy. It also has some of the best developer UX/tooling out of any language I've used.

nynx 4y ago

I’ve written a bunch of embedded software in rust.

pornel 4y ago

Cloudflare is using Rust for network stacks, proxies, caches, compression, and image processing. Basically everything that you would use C or C++ for, but where security is also incredibly important.

jackmott42 4y ago

I've done some hobby projects in Rust. One was a SIMD abstraction library, where you could write code that looks more or less like SIMD intrinsics, but it would either at compile time or runtime select the SIMD instruction set for the target cpu. The traits/generics/macro system made that feasible, though messy. You can do similar things with templates in C++

Macha 4y ago

Rust has replaced Python for me in my personal CLI tools where I expect to use them as an ongoing basis. At this stage I am almost as fast writing Rust as Python, find the Rust projects much easier in terms of environment setup than the whole pipenv/poetry/pyenv world, and enjoy the instant response of not having to wait for a python interpreter startup. I also have some side projects like a gameboy emulator, where it's nice to have what is effectively a lower level language with the safety and features of higher level language. My day job is mostly Java/Javascript though, rewriting the world isn't yet worth it, but there's certainly one or two of our systems where if a rewrite in another language was on the table I'd make the case for Rust

Scarbutt 4y ago
At this stage I am almost as fast writing Rust as Python By generously use of copying?
- oconnor663 4y ago
  The "One Simple Trick" that lets you port most Python code straight to Rust is to take all the aliasing "object soup" references that Rust doesn't like, shove those objects in a Vec or a HashMap, and use indexes/keys instead of Rust references. This does require plumbing the Vec/HashMap around through different functions, but if you do it this way from the beginning it's not much extra work.
  - int_19h 4y ago
    At that point, what's the benefit of using Rust over basically any other high-level language that has ADTs and pattern matching? Since you lose all the benefits of lifetime tracking that are unique to Rust.
    - oconnor663 4y ago
      > you lose all the benefits of lifetime tracking that are unique to Rust I think I understand what you're referring to, but stop me if I get this wrong. If you put a bunch of objects in a Vec and refer to them by index, you have to be careful with operations like .insert() and .remove() that shift Vec elements around and change their indexes. Also if you make each element an Option<T> to support deletion without .remove(), you still have to be careful about indexes of deleted objects, because you might put a new object in the same spot later. I have several thoughts about this: - If "memory safety without garbage collection" is one of the unique features of Rust, you still have that. A reused Vec index in safe Rust code will never corrupt memory or trigger a segfault or anything like that. It's strictly a "logic bug". - These logic bugs only apply specifically to the objects you put in a Vec and track by index. Creating a Vec<Foo> and getting an index mixed up doesn't change anything about Rust handles your local variable of type Bar (or for that matter, your local variable of type Foo). - These bugs are understandable for beginners, and you can follow what's going on with print statements. Contrast that with a dangling pointer into a C++ std::vector that just reallocated, where printing the freed object often appears to show good data, and explaining the bug means talking about malloc/new and the heap. Relatedly, unwrapping a None in Rust will always panic and will never coincidentally appear to work. (Your comment was comparing Rust to higher level languages, but I've heard similar comparisons to C++.) - There are good options for fixing the problem. Beginners might prefer to put their objects in a HashMap with an incrementing key. There's a performance cost to that, but it's familiar and relatively footgun-free. More advanced folks might reach for something like "generational indexes into a slab", which gives you back some performance in exchange for making you learn a bunch of new buzzwords and figure out which implementation to choose from crates.io. So yes, with those caveats, putting objects into a Vec does turn some compile-time bugs into runtime bugs. That is a downside, much like Rc/Arc/RefCell/Mutex come with runtime downsides. But I've heard folks describe it in terms like "turning off the borrow checker", and I don't think that's a very accurate way of describing it.

orthecreedence 4y ago

I do a lot of cryptography stuff in rust that is ported to various platforms and embedded in larger apps so I don't have to write the same logic over and over (desktop/mobile mainly). Also, lately working on some identity/p2p stuff.

ostenning 4y ago

I'm building commercial hardware products using embedded Rust, I love it. I cant really imagine going back to C. I haven't dug too deep into the offerings with this update, but none of the standard library stuff is relevant for me

kibwen 4y ago

I work on a project that's basically a mini-OS designed to host WebAssembly applications. The OS parts need to run on bare metal and do all sorts of cursed shenanigans, where Rust's separation of safe and unsafe code lets us better focus on proving to ourselves that the unsafe bits are working as intended (we also test our unsafe code under Rust's Miri interpreter/sanitizer for extra confidence). IOW, the killer feature is low-level control plus a reasonable expectation of safety. The actual WebAssembly interpreter is also written in Rust, which is a good fit because inefficiency in an interpreter leads to inefficiency in anything running in the interpreter. The killer feature here is performance plus safety. The overall package is bundled up into a CLI app that lets you deploy an instance of our OS with your application running within. Rust has a fairly nice wealth of libraries that make this pleasant, from CLI argument parsers to cryptography to OIDC and beyond. And it all gets packaged up into a single binary for easy distribution (even the OS and interpreter parts, which get embedded directly in the binary via `include_bytes!`). The killer feature here is great platform support (including cross-compilation) and small binaries (though you may reasonably disagree on "small"; altogether the binary (again, including the OS and interpreter) comes out to 25 MB). Finally, Rust's lack of a pervasive runtime and great WebAssembly tooling means that it's easy to compile Rust applications to run on top of all this as well.

cultureulterior 4y ago
This OS seems interesting! Link?
- kibwen 4y ago
  Keep in mind that I'm using "OS" here loosely; it's a bare-metal program that exposes a subset of Linux syscalls so that the interpreter (which itself is compiled for Linux) can run in the extremely specific context that we target. It's still early days so I won't spend too much time shilling it, but all the code is open source and lives under the umbrella of the Linux Foundation: https://enarx.dev/ https://enarx.dev/

cliffcrosland 4y ago

We are using Rust to build a fast log event database. The workload includes a lot of asynchronous networking I/O and parallelized CPU-intensive work, like indexing and SIMD-accelerated string search. There are great libraries for what we need. The performance and low memory footprint are quite useful.

Hamuko 4y ago

I've written a small automatic file organiser in Rust that I run in a Docker container on my NAS. Docker reports that the container is using 1.5 MiB of memory, so that's pretty nice. Pretty sure I wouldn't have achieved that if I wrote it in Python like I normally do.

pdimitar 4y ago
That project sounds interesting and I think it aligns with what I need. Have you open-sourced it?
- Hamuko 4y ago
  Nope. I've been meaning to, but I feel like I need to clean up the code up a bit before I do that. It's also quite niche, so I'm not sure if it's for everyone's use cases.

ekidd 4y ago

I've built a fair amount of production software in Rust. The best features are: - Rust is naturally pretty fast, on the rough order of C++ in many cases. Even unoptimized programs tend to be very snappy (as long as you remember to compile in release mode and buffer I/O). - Rust tends to warn me if I make a dumb mistake, rather than having my program mysteriously corrupt memory at run-time. - Rust has very nice support for portable CLI applications, both in the standard library and in third-party libraries. - With a bit of extra work, I can usually deliver a single, statically-linked Linux binary. Go is even better at this, but Rust does it well. - It turns out the "algebraic data types", what Rust calls "enum" and "match", are just a really nice way to write down every possible "case" or "state" of some value. If a piece of software involves hundreds of special cases, Rust allows me to think about them clearly. - Rust has surprisingly good third-party libraries for many things. (Not everything.) - Multithreaded Rust apps are a dream. Cons: - Rust forces me to keep track of whether things live on the heap or the stack, whether I'm passing them by value or reference, and so on. This is good when I want performance, but for other kinds of code, it's just a "cognitive tax." - Rust's learning curve is higher than Go, but arguably lower than C++. This is especially true if you've either never worked with stack/heap/pointers before. - Rust tends to favor "mostly functional" architectures over "mutable objet soup" architectures. This pushes you to use less-familiar designs for games and GUI libraries, for example.

albrewer 4y ago
> I've built a fair amount of production software in Rust. Any examples?
wiseowise 4y ago
> Rust tends to favor "mostly functional" architectures over "mutable objet soup" architectures. This pushes you to use less-familiar designs for games and GUI libraries, for example. How is that a con?
- ikawe 4y ago
  One example would be the lack of pragmatic rust native GUI libraries. There are wrappers for GTK and Qt, which are probably your best option. The most popular pure rust ones are based on somewhat esoteric patterns and seem prone to being abandoned. Within that there are some interesting options, like for functionally reactive programming and immediate mode guis, but these paradigms aren’t all encompassing and in fact cover a pretty minority use case based on what GUIs are being created today. Maybe one day we’ll all only ever create purely functional GUIs and speak Esperanto, but until then, we’re a little hamstrung in rust.

teknopurge 4y ago

security. I dabble with system programs and it's nice to get the speed/portability of native optimized code and know most memory issues won't occur.

kylebarron 4y ago

I'm building WebAssembly bindings to existing Rust libraries [0] and lower-dependency geospatial tools [1]. Rust makes it very easy to bind rust code to both WebAssembly and Python. And by avoiding some large C geospatial dependencies we can get reliable performance in both wasm and Python using the exact same codebase. [0]: https://github.com/kylebarron/parquet-wasm https://github.com/kylebarron/parquet-wasm [1]: https://github.com/kylebarron/geopolars https://github.com/kylebarron/geopolars

theptip 4y ago
Oh, that’s really cool. Rust noob here, and I hadn't seen the tooling for building Python bindings. That looks like it could be a very powerful way to speed up your Python programs (much easier than the “just replace the slow bits in C” advice that was standard.) The mappings in https://github.com/kylebarron/geopolars/blob/master/py-geopolars/src/geoseries.rs https://github.com/kylebarron/geopolars/blob/master/py-geopo... for example look very easy to follow.

dymk 4y ago

I've written no code professionally in Rust, but a fair amount of personal project code. I've written C++ both professionally and as a hobby. At least for hobby use, comparing the two, Rust is wonderful. - It's easy to set up cross compilation. - Cargo makes dependencies easy. - Building is almost always just `cargo build` except for very exceptional projects, same with `cargo test`. - `cargo fmt` makes formatting easy and built in. - Clippy gives actually useful lints and can automate most refactorings. - Rust-analyzer is fast to index decently large projects, works with almost all language features (even complex ones like proc macros), and has some real time-saver automation built in. Working with the borrow checker can feel like a pain, but in many cases, feels like a fun puzzle (writing hobby code, I'm not under time pressure, so it's 'solve a puzzle' and not 'oh fuck deadline coming up'). But really, the tooling of the language is where it shines.

CJefferson 4y ago

Personally, I use Rust as a "better C++". Ways in which it is better: * A decent package manager * "Safe by default" (you have to use 'unsafe' to turn off the safety features), unlike C++ which is "unsafe by default" (v[i] is undefined behaviour if i is out of bounds, for all of C arrays, std::arrays and std::vectors). * Really easy to do multithreading -- I had reached the point with C and C++ where I was of the opinion it is "almost impossible" to write large thread-safe programs, and all communication should be between processes with pipes, wherever reasonable. In Rust I again feel I can safely and productively write multi-threaded code. The things Rust doesn't let you do (throw pointers around everywhere) can get a little annoying, but I find the extra safety increases my productivity enough that it's worth the tradeoff.

dralley 4y ago
>(you have to use 'unsafe' to turn off the safety features) "unsafe" doesn't turn off any safety features, it just allows you to do additional things which the base language does not, like: * use raw pointers * use mutable static globals * access fields of unions https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html#unsafe-superpowers https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html#unsa... All the rules of safe Rust still apply inside of unsafe blocks. The borrow checker still works, etc.
tialaramex 4y ago
You didn't say otherwise, but this is such a frequent misunderstanding from people who don't write Rust, or write only safe Rust (which is fine) that it's worth pointing out the unsafe keyword and Rust's choice to be "safe by default" are not directly related. Culturally obviously they come from the same place, but for example: v[i] is bounds checked in Rust even in unsafe. The unsafe "super powers" don't include "magically now indexing has no bounds checks" but because Rust's get function v.get_unchecked(i) is marked unsafe‡ you would need to mark code unsafe to use that function and that function doesn't have bounds checks. If you write: unsafe { println!("{}", v[i]); } The compiler will point out that unsafe isn't doing anything for you here, v[i] is safe, marking it unsafe is just a waste of everybody's time. C++ doesn't have bounds checked array access for its abandoned built-in arrays, but it does (these days) have bounds checked access for std::array and std::vector as a separate member function, however because they aren't the default few C++ programmers use them even where they undoubtedly should. This is an ergonomics issue, it's just easier to write needlessly unsafe C++. ‡ This said just get() before I edited it, but Steve corrected me, see below.

gattr 4y ago

I wrote a video acquisition tool for astrophotography [1] (and I dogfood it). Uses GTK3 for GUI. [1] https://github.com/GreatAttractor/vidoxide https://github.com/GreatAttractor/vidoxide

allisdust 4y ago

I use it to write backend web services. Some how it doesn't appear to be any less productive than typescript +nodejs combination. Library support used to be a mess but now a lot of good libraries exist to get the job done.

di4na 4y ago

NIFs for particular casting of numbers to other binary formats in erlang. NIFS for embedded database and data format in erlang. Main reason ? It works. The compiler has real error messages that are helpful making the onboarding of anyone having to fix problems a far far better situation than any of the competitors. It has a proper modern toolchain. All of these would be killer features. All together ? No competition. I also write cli tool and all kind of parsers for embedded language. The libraries here, in particular if you want good error messages and UX, are simply the best in all other environment i know of.

api 4y ago

ZeroTier version 2 is being built in Rust, with the main reasons being safety (it's a network protocol!), easier cross platform compilation, easier dependency management, and an all around better language than C++. It should help us greatly boost developer velocity while also be much safer from a security point of view.

mwcampbell 4y ago
That will also make it more attractive to other developers using Rust who want to embed the SDK. Speaking of which, I've emailed ZeroTier a couple of times now about licensing the SDK (the first email was last week), and haven't yet heard back.

solar-ice 4y ago

I write video streaming software in Rust. Rust helps us make sure we've got concurrency correct, has a very solid type system to help us make sure we've got general application properties correct, and seriously reduces the space where we have to go looking for segfaults and suchlike (primarily third-party C libraries and bindings to them).

huyage 4y ago

I'm building an HTTP CRUD app on top of PostgreSQL. I have previously used Go for various CRUD apps. The experience is better except for compile time. My favorites: 1. Much more expressive type system: no more `interface{}`. 2. Algebraic data type with `enum`. Exhaustive check. 3. `serde` crate is lightyears ahead of Go's `json:"wtf"`. 4. Compile-time checks against DB with `sqlx` crate. 5. Logging is a breeze with `tracing::instrument`. 6. Using macros to reduce boilerplate has better UX than Go codegen. What these give me is more confidence in development/refactoring because the compiler can guide me most of the way. Low lights: 1. Build time. 2. Async is still clunky. e.g. Try to implement an `actix-web` extractor or middleware. 3. Please just stablize nightly rustfmt features already.

mjb8086 4y ago
I'm looking to do a bit of CRUD on top of PostgreSQL as well. Currently mid-way through learning the language. Would you mind sharing some of your experiences? Do you find the 'stubbornness' of the compiler frustrating at all? How do you find the tooling? Also, I've considered Diesel for ORM, so was wondering if you've been using that too.
- huyage 4y ago
  > Do you find the 'stubbornness' of the compiler frustrating at all? I actually love it. The more work I can offload to compiler the better. One simple example that frustrated me in Go was adding a field to a struct. You add the field the the whole thing still compiles even though the zero-initialized value probably broke your app logic. In Rust if I add a field to a struct, the compiler warns me about all the places that I need to double check. > Would you mind sharing some of your experiences? I highly recommend zero2prod book which is well-written, practical, but still teaches the essential principles (https://www.zero2prod.com/ https://www.zero2prod.com/). You basically deploy a CRUD app to DigitalOcean from scratch. The best way to ramp up IMHO. > How do you find the tooling? Cargo is sweet. rust-analyzer is all I need. I need less extraneous tooling to be effective. For example, in Go I might use a task runner to watch the repo and run tests when I change a file. But in Rust I can just follow the rust-analyzer highlights and manually compile less-frequently. > Also, I've considered Diesel for ORM, so was wondering if you've been using that too. I was not happy with GORM (https://gorm.io/index.html https://gorm.io/index.html) and never had a satisfactory experience with any ORM. I'm a fan of writing plain SQL, even in Go. It's just that with Rust sqlx I can get compile-time checks against the schema. It's not anything new (see Haskell), but it tightens the feedback loop and I have full control of the performance.

emadda 4y ago

https://table.dog https://table.dog (a CLI to download Stripe to SQLite). I considered Node.js, C#. I went with Rust for a few reasons: - Easy to build small portable binaries (as a primary language feature). - The type checker ensures type consistency when writing out to SQL tables (SQLite is loosely typed). Code that reads from the SQLite database implicitly benefits from Rusts strong type checks. - Macros to convert structs to SQL insert/updates. - Reduce the chance of errors at runtime. - Leverage as much as SQLite's write throughput as possible. - When converting Stripes Open API JSON spec into Rust code (using another Node.js program), the Rust type checker ensures I have a well formed HTTP client - the strict compiler makes it a good target for generated programs. Read more about this idea at (https://willcrichton.net/notes/rust-the-new-llvm/ https://willcrichton.net/notes/rust-the-new-llvm/).

masklinn 4y ago
> SQLite is loosely typed FWIW in recent SQLite you can turn that off using “STRICT” tables, however that means the available types are restricted to INT(EGER), REAL, TEXT, BLOB, or ANY. ANY is also “Stricter” in strict tables: it does no conversion whatsoever, whereas in normal mode it’ll try to parse literals to numbers, and store a number in that case.

bsnnkv 4y ago

I've built the most popular[1] actively maintained tiling window manager for Windows that is available today.[2] It would have been impossible for me to build this in any other language. I knew absolutely 0 about developing for Windows when I started this, but I quickly realized that the Win32 API is a very old beast with a lot of footguns that Rust saves me from on a daily basis. On top of that, with parking_lot I can quickly and easily detect incredibly rare instances of deadlocks, and in general have to worry very little about concurrency. All of this allows me to stop worrying about the noise and focus on the real work of how the window manager should behave. 1. Based on Github Stars 2. https://github.com/LGUG2Z/komorebi https://github.com/LGUG2Z/komorebi

marcosdumay 4y ago

I am currently writing a kinda complex GUI application intended to run on a browser. So it's in webassembly. Compared to Javascript, Rust safety features allow me to iterate quickly and improves my productivity from "I won't be able to complete this project" to "it's trivial, just some work". Compared to Typescript, Rust gives me some performance and types that actually represent the data I use, but I am not sure if I lost a bit of productivity (the TS tooling is horrible, so programing a bit slower isn't the entire story). I don't consider this a problem Rust is good for, but one that all the more suitable languages still don't support.

__david__ 4y ago

For me the killer feature of Rust is its nice broad scope. I've done: - embedded programs on avr hardware, which is impressive that something like rust can compile down to an 8 bit micro. Doing some sort of crazy map/iterator filter closures and finding the resulting assembly being nice and tight makes me super happy. - web servers and clients (a scraper that collects scores from a web page and serves its own page of aggregated scores to my family). - a low level opengl tmux/terminal client (Rust's Enums were a killer feature here) - a windows GUI program for installing a PC game mod (99% developed on a mac and cross-compiled) - a cli app to "compile" svgs down to png sprites for a web based game - a launcher for Emacs that uses native cocoa apis to display a dialog on error Each of these cases ended up pushing different parts of Rust for me. I would say the killer feature that spans all of those is Cargo and the crates.io registry. There are a ton of very good libraries out there—it feels like the heyday of CPAN or RubyGems to me. I also quite enjoy how many programming errors Rust finds at compile time. With Rust code I spend way more time fixing compiler errors, but when it compiles I typically don't find a ton of major logic errors. I personally find it extremely rewarding when I get something to compile and then it just works. This happens more in Rust than in other languages I've heavily used.

andrew_shay 4y ago

I've built a p2p file transfer program [0]. All my development experience had been in Python, but I really wanted to try a statically typed, low level language, and decided to give rust a try. It was hard to get going, and I still only know basics, but everything just works! Typing, borrow checker, the matched results, all of that makes code bullet proof. [0] https://github.com/transmitic/transmitic https://github.com/transmitic/transmitic