Pinecone: Rust – A hard decision pays off

This page summarizes the projects mentioned and recommended in the original post on news.ycombinator.com

Our great sponsors
  • SonarLint - Clean code begins in your IDE with SonarLint
  • Scout APM - Truly a developer’s best friend
  • InfluxDB - Build time-series-based applications quickly and at scale.
  • Zigi - The context switching struggle is real
  • vscode-rust

    Rust extension for Visual Studio Code

    > it crashes process IDs more often than Justin Bieber crashes Maseratis: https://github.com/rust-lang/vscode-rust/issues/890

    So -- this guy used an extension (named Rust) with rust-analyzer, which was known to not work, and it didn't work(!), and the Rust extension author recommends he tries the extension made for rust-analyzer. That extension doesn't have the features he likes (it works for me and has loads of features, so I have no idea what this is about?), and so they close the issue?

    Hardly a case for the ages. Guy uses unsupported config and things don't work?

    > What clangd does is work.

    Don't doubt it. I'm just saying -- I haven't had any problems with the rust-analyzer extension since it became the Rust default. But, yes, I had a few hiccups and crashes beforehand, no doubt. I just have to imagine it's both younger, and doing more/different things than clangd.

  • RocksDB

    A library that provides an embeddable, persistent key-value store for fast storage.

    > Search your heart, do you think this story ends similarly if they decide to all do "modern C++" instead?

    https://github.com/facebook/rocksdb

  • SonarLint

    Clean code begins in your IDE with SonarLint. Up your coding game and discover issues early. SonarLint is a free plugin that helps you find & fix bugs and security issues from the moment you start writing code. Install from your favorite IDE marketplace today.

  • evcxr

    Funnily enough, a REPL environment is in the works for Rust: https://github.com/google/evcxr

  • awesome-rust

    A curated list of Rust code and resources.

    Agree, you can see this in https://github.com/rust-unofficial/awesome-rust vs. https://github.com/avelino/awesome-go

    I've noticed however that there has been an uptick in great libraries over the last 2 years, with examples like pola.rs, rust-bert, tokenizers etc. starting to build momentum in the ecosystem.

  • go-formatter

    A curated list of awesome Go frameworks, libraries and software

    Agree, you can see this in https://github.com/rust-unofficial/awesome-rust vs. https://github.com/avelino/awesome-go

    I've noticed however that there has been an uptick in great libraries over the last 2 years, with examples like pola.rs, rust-bert, tokenizers etc. starting to build momentum in the ecosystem.

  • Docker.DotNet

    :whale: .NET (C#) Client Library for Docker API

  • tokio

    A runtime for writing reliable asynchronous applications with Rust. Provides I/O, networking, scheduling, timers, ...

    Quick correction for anyone searching: it's `tokio`, not `tokyo`. [0]

    [0]: https://tokio.rs/

  • Scout APM

    Truly a developer’s best friend. Scout APM is great for developers who want to find and fix performance issues in their applications. With Scout, we'll take care of the bugs so you can focus on building great things 🚀.

  • PyO3

    Rust bindings for the Python interpreter

    I'd be interested in a bit more detail on the technical migration strategy. Did they just cut over to a version of the project built in Rust? (I.e. vN is Python+C/C++, vN+1 is Rust?) Or something more gradual?

    How did they verify that the new code was conformant with the old app's behavior/logic?

    > To make matters worse, we would discover issues only after deploying (or in production!) due to Python’s run time nature.

    I don't want to infer too much, but this makes it sound like perhaps they didn't have a very robust set of E2E/Acceptance tests, which would make a full-cutover migration scary to me. If you're finding Python bugs only after deploy, how can you find the inevitable rewritten-Rust-code incompatibilities before deploying/production?

    I've been digging into Rust/Python interop recently using https://github.com/PyO3/pyo3 and maturin, and this points to an interesting migration strategy; PyO3 makes it quite easy to write a Python module in Rust, or even call back and forth between them, so you could gradually move code from Python to Rust. A migration path to full-Rust might be:

    1. Incrementally replace all your fast-path C/C++ code with Rust, still having Python call these compiled modules. End-state: You now have a Python/Rust project instead of Python/C/C++.

  • FrameworkBenchmarks

    Source for the TechEmpower Framework Benchmarks project

    Source? I thought .NET GC was tuned for throughput.

    Their performance is, impressive, to say the least.

    https://www.techempower.com/benchmarks/#section=data-r21

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a more popular project.

Suggest a related project

Related posts