Rust’s abstractions and type system are difficult to grok for new programmers, especially for those who aren’t familiar with statically typed languages. This, combined with Rust’s strictness and memory safety rules, can make it challenging to become productive in the language.

What's your experience when you were starting with Rust?

This book breaks down these concepts using plain language and practical examples and comparisons to other well-known programming languages to help people quickly achieve mastery. Very useful.

Cheers,

Rust is commonly advertised as "better than C++" because it is safer and as fast as C++.

However, I see the benchmarks in C++ Dataframe project between it and Polars, and at least in the benchmarks, Polars is sensibly slower.

Is not Rust supposed to be on par with C++ but safer?

How does Polars compare to C++ Dataframe?

https://github.com/hosseinmoein/DataFrame

Hey, fellow Rustaceans and Web Dev enthusiasts!

🌟 RustGPT: A Rust-Powered ChatGPT Clone!

I have ~ a decade of experience in web dev but I'm Rust enthusiast newbie who recently started to learn the language seriously.I've decided to dive deep into the combination of Rust and HTMX to build web applications.Today, I wanted to share with you my latest adventure: RustGPT, a ChatGPT clone that blends the efficiency of Rust with the simplicity of HTMX.

I hope it will motivate more people to use Rust for web development.

🚀 Building ChatGPT clones

Creating ChatGPT clones has been my testing ground for various tech stacks, but RustGPT stands out with its combination of performance and web simplicity. From authentication to database integration, not to mention streaming with SSE (server-sent events), RustGPT encapsulates a wide spectrum of web app development.

➡️ Check out the demo live at: rustgpt.bitswired.com and feel free to dive into the source code on GitHub.

🔧 Pulling Apart the Stack

• Axum: After considering both Actix and Axum, I found my alignment with Axum (The code samples and code kind of felt more intuitive to me).

• Tera: Chose over Askama for its Jinja-like features, which brought intuitive reuse and flexibility to the project.

• SQLite & SQLx: My go-to DB combo, delivering performance, reliability, and a compile-time query validator that’s just music to a developer's ears.

• HTMX: My opportunity to fully involve myself on the backend without sacrificing interactivity.

• TailwindCSS: Styling within your HTML and naming already solved with the beauty of TailwindCSS?

• Justfile: A recent addition to my toolkit, helping to streamline development processes like a charm.

🔗 A few words about my experience with Rust

Despite being a Rust newbie, I found great joy in coding with this language. Getting a chunk of code to compile in Rust can require some diligence , but once it does, it really does work. The journey had its challenges, from understanding borrowing to leveraging procedural macros, but it gets better quickly.

Here's a sneak peek into a Rust challenge I tackled: streaming text generation with SSE in Axum. I needed to accumulate and process a stream of responses from the OpenAI API and stream them back to the client. All with state management and async processing (call to database while processing). Quite a journey!

🚀 HTMX

HTMX has proven to be a game-changer, offering dynamic interactivity with minimal overhead. Features like real-time streaming with SSE, deleting chats with simple HTML attributes, creating new chats across different page sections, and appending messages—all handled declaratively, avoiding JavaScript bloat.

🔭 Looking Ahead

Would I recommend Rust + HTMX? Absolutely! It’s a match made in web development heaven. I'm keen to create a template repository to kickstart projects with this stack.

Your thoughts on this stack intrigue me—would you give it a shot for your future project? If you have Rust insights or improvements, I’m all ears.

🎉 Happy Rusty coding, and may your web development ride be as stimulating and fulfilling as mine!

I am a data scientist and I automate some models using Rust at work. I have developed such ability that whatever I write in Rust that it just works as per my written logic. It is an app with 1k+ lines of code and I have just provided it to my team mate. Fingers crossed, a bit dicey as I was short on time and didn't get to cross check my logical flow. But I know that what I have written will be how it performs.

Some days ago I had my team mate test my app with 500+ lines of code and it worked on the first try with 0 bugs.

I don't get why people find Rust so hard, once I am used to it, I can't for the love of God go back to any other language. Rust has made me hate languages like C/C++, their compilers didn't even know all the time I managed memory in a wrong manner. I had to depend on valgrind all the time.

EDIT: Just to let you all know, I test my apps. I share my app with my trusted colleague sometimes. You can say he is my alpha tester. I share python apps just like that, similar is with Rust apps. I can't do the same with C/C++ since it has higher chances of failing at runtime.

I would never float an app to an external client without proper testing.

Warp terminal is available on linux !

Their is a webinar right now.

https://www.warp.dev/blog/warp-for-linux

PS: not a warp dev or related.

Hey guys

We are programmers. This is a programming language. Why is the Rust crab carrying a pride flag in the Discord? Why are we experiencing this split between the Russians and Ukrainians? Obviously, I know the war. But governments decisions has nothing to do with programming

It doesn't have to be like this, and it only drives us apart. Its petty and toxic, and we should not let politics poison our community like this. Keep it to programming

Rust is finally moving up. After the tailwind of the US government, which recently announced to recommend moving from C/C++ to Rust for security reasons, things are going fast for Rust. The community is growing, including the number of third party libraries and tools. In short, Rust is preparing itself for a top 10 position in the TIOBE index.

https://www.tiobe.com/tiobe-index/

This is Ampy, a retro-styled system monitor. It has a mascot in the form a chip, sleeps when the machine is idle, gets busy under load, and when something pegs he walks across the dashboard to the offending gauge and knocks on it.

There are some upsides tho: written in rust (i mean where are we); you can plug in any old Android phone over USB and it becomes a small desk display running the dashboard. Few KB/s of JSON over an adb reverse tunnel, rendered natively on the phone. OLED care built in.

• tiny-skia software raster into one texture, wgpu blit applies the CRT shader. ~2 MB resident in the tray with android companion screen, 40mb open.

• GPU usage/VRAM on any vendor via PDH counters + DXGI; NVML adds temps/clocks on NVIDIA.

• The phone is the same renderer crate as a cdylib via cargo-apk.

repo

Trash talk at will, all suggestions are welcome 😉

In my opinion sudo is too big for what it should do. Most people just want to execute commands as root. doas is a better option but it has not been officially ported to linux (as far as I can tell). I made this small tool to replace sudo on my personal computer. It uses the suckless way of configuration (the source is the config) because as I said tools like this shouldn't be bloated with things like reading from external config files, parsing them, etc.

Please check it out on https://github.com/RHL120/rhun.

I rarely use the ffi and unsafe code so there maybe a lot of bugs. If you catch any please let me know.

EDIT: s/runas/rhun (runas already exists :/)

Thanks for checking out my project!

I'm having a really hard time hiring new people for my startup. I have been trying to hire 6 engineers for the past 5 month and so far I only got 2. The first person knows Rust well and the second is a java+node developer who is picking up Rust.

I'm trying to gauge if my hiring problem is a problem with not enough Rust developer in the market or sometime wrong with my hiring process.

The startup provides an enterprise saas service and we have quite a few paying enterprise customers. The startup is a series A in the SF bay area and is 3 years old. The stack is mostly Rust back-end, we use actix, postgres, docker, and aws. I don't think there is anything obviously wrong with the company that discourages people.

I have been offering 160K with 1% equity which is 400K over 4 years. I have been thinking of increasing the starting base to 175K. Usually after negotiations, new hires get about 180K anyway.

I just started looking to hire new grads and teach them Rust and starting very recently I'm way more willing to hire people with no Rust experience than I was 5 month ago.

At my current rate, I'm having a hard time getting enough people to deliver features on time.

For my test, I run 'date +\"%T.%N\"' twice on a SSH Server on my local network and calculate the time between the two executions.

Clients run on Windows10/11.

Python (paramiko): ~45ms
Nim (ssh2(libssh2)): ~44ms
Go (golang.org/x/crypto/ssh): ~4ms
Rust (ssh-rs, russh, ssh2(libssh2)): ~115-130ms

I don't know what Go's trick is, but 45ms seems like a goal Rust should easily achieve!?

Rust profile for "cargo build -r":
[profile.release]
lto = true
codegen-units = 1
strip = true
panic = 'abort'

Rust (ssh-rs): https://pastebin.com/3ucPpCzc
Rust (ssh2(libssh2)): https://pastebin.com/cQ7j6zd2
Nim (ssh2(libssh2)): https://pastebin.com/xRYFFLDN
Go (golang.org/x/crypto/ssh): https://pastebin.com/mFzvLLnk

Any idea why this happens and how I can at least get the same performance as the other implementations?

Update:

The previous tests were executed on Windows 10 (Threadripper 3990X with Mellanox card, highly optimized for latency) and Standard Windows 11 Enterprise (work notebook).

I copied the projects to a raspberry pi and retested the Rust ssh-rs, ssh2 implementations and the Go app against the same destination.

ssh-rs: ~45ms
ssh2: ~45ms
go: ~4ms

Edit: this is a sanity check for me after putting up with a lot of crap, to keep my mental health sane. It's not a hate post

I just want to say I write this without malice or ill will towards any community. However, I feel this must be address and I feel comfortable sharing in here. So without further ado, I'll get to the point.

Has anyone else noticed on the C++ Reddit there is a lot of negativity towards Rust. This negativity appears to be without merit by people who don't understand either language. It has also got to the point I left the Reddit a few months back because of the constant down voting when factually answering questions.

I don't understand why people are jumping on this hate wagon towards Rust. Calling us obnoxious because we accept it is a better language. Also when shown they deny how C++ works and only know Rust by name.

The joke isn't "rewrite it in Rust bruh". The joke is that the people in the C++ community don't even understand C++ and only know Rust by name, then proceed to spread misinformation and hate towards the Rust community.

Even, the creator and standards committee, governments, intelligence agencies, medical devices manufacturers and many many other educated individuals and organisations have acknowledged Rust's improvements over the C and C++ language.

Like I say, I don't hate them, but I do pitty them. I am wondering how others feel about this and what others experience's have been when interacting with the C++ community?

/r/rust is the primary news source many people, including myself, depend to follow the development of Rust; a programming language that many believe represents a genuine opportunity for the industry to improve the security and productivity of systems programming.

Lately, however, it seems that this subreddit is increasingly being treated in an informal manner where images not immediately relevant to the Rust programming language are being displayed in prominent locations on this site. Images that will often confuse new visitors, and confuse the majority of subscribers to whom the images will often make no sense. Some of these images will even either fall afoul of the one of the rules which disallow memes or come very close to doing so.

The previous top-left blue logo with shoes is a good example of such images, as is the image currently used as the primary home button of this subreddit.

To be clear, I don't believe these images are root of the problem. They are symptom of the broader issue of this subreddit being excessively relaxed. While this type of informality may have been acceptable when Rust was still in its infancy and this subreddit was small. I believe that this subreddit has become prominent enough in the industry that continuing to be informal is no longer appropriate and perhaps even damaging. I would like to argue for a more streamlined and formal subreddit similar to other programming subreddits [1].

I would like to stress that this post is in no way an attack on the current moderatorship of this subreddit. I serenely appreciate the amount of time and effort these people volunteer into keeping this subreddit operational. However, I do believe there is merit to what I present.

1: Other similar subreddits:

• /r/programming

• /r/cpp

• /r/golang

• /r/python

• /r/haskell

• /r/java

• /r/javascript

https://www.youtube.com/watch?v=SodXi2t1mtE

The 2019 goals for the Rust project were to finish some old language and library features that have had a lot of design but have not been pushed through the finish line, from the 2019 roadmap blog post:

async/await, specialization, const generics, and generic associated types, custom allocators

From this list, nothing has landed on stable yet. It's unlikely that anything beyond the minimal parts of async/await will land on stable before the end of the year (no async fn in traits).

The rationale that we had for pursuing these features in 2019 has not changed: these are important features that can have a very large impact in the Rust ecosystem, that have received a huge amount of design and implementation work, but haven't been pushed through the finish line yet and makes sense finishing before starting designing new features.

There are other items in the 2019 roadmap that still need work: support for new targets / WASM, embedded, improving compile-times, better IDE support, improving the reference, doing the unsafe code guidelines, etc. I don't think any of this was "shipped". Compile times are still slow, IDE support is still bad (its 2019 and emacs autocompletion for Rust brings my workstation to its knees), the reference and the unsafe code guidelines have made very little progress, debugging WASM isn't great, etc.

One big question for this year: will there be a Rust 2021 edition? If so, 2020 would be the year to do a lot of associated work and plan the details. What would the edition's theme be?

Editions allow introducing breaking syntax changes in the language, but if I recall correctly none of the features in the 2019 roadmap do.

Editions add churn, it takes time to update crates to a new edition, so unless a new edition adds value, I don't think we should have one. Right now, we are 2 years away, and I at least cannot tell. There doesn't appear to be a tracking issue of things we have decided that we want to do but require a new edition.

I also don't think that one should wait till the 2021 edition to update the book and other documentation to use async/await and other big features as they land.