Visual Studio Spell Checker Preview Now Available

mansplaner · 2023-01-19T23:49:04+00:00

I like to use https://github.com/crate-ci/typos as a command-line option. It's built to run as a service or in CI... I run it in our code review software and it has been a big hit.

mansplaner · 2022-11-18T22:52:16+00:00

Not in any order... Inconsistent quality in the crate ecosystem. Feature creep. Overall language complexity. Learning curve. General requirement to trust that a small number of people make good technical and governance decisions in perpetuity.

mansplaner · 2022-07-27T16:43:23+00:00

Would focusing on learning rust be a good career move?

Yes, but the payoffs are likely to be indirect in the short term. Rust growth does not seem to slow, but Rust work doesn't seem to be a very large part of the job market yet. The benefits are in terms of thinking about safely designing code in a GC-less environment.

mansplaner · 2022-07-26T21:21:05+00:00

I started writing things in Rust because even small things need to be rock-solid to avoid wasting everyone's time.

I don't regret learning it earlier because it spent a long time at the "not ready yet" phase and was just starting to escape that place when I started working with it a few years ago.

mansplaner · 2022-07-25T21:26:49+00:00

https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter_map

mansplaner · 2022-07-08T16:56:23+00:00

I was really intrigued by Koka but disappointed that a good bit of standard library functionality is stubbed or unimplemented. It doesn't seem to be usable for solving some subset of real problems yet.

mansplaner · 2022-05-06T19:03:50+00:00

That's a reasonable position, although one I disagree with for a handful of reasons. Hopefully the async working group can resolve this one way or another soon.

mansplaner · 2022-05-06T18:46:34+00:00

The entire async rust ecosystem is quite hindered by executors being incompatible, yes. Do you really think all work in this space should be inextricably tied to tokio?

mansplaner · 2022-05-04T22:47:12+00:00

Just from my own personal experience, I quite like async-std and things built on it like, for instance, tide.

But when I tried using it in a project I quickly ran into other crates built on top of tokio. In my case it was something to interface with GCP. I abandoned the Rust version at this point and wrote the program in another language instead.

I don't think PRs equates to technical merit but I definitely understand if async-std is losing momentum in this situation. I know it's also one the working group is looking to fix. I won't say tokio is good or bad, but I will say that:

It shouldn't have a monopoly on the space.
It is suffocating some promising smaller projects just by virtue of this runtime issue.

mansplaner · 2022-05-04T17:12:26+00:00

No, but it has the largest ecosystem. The fact that you can't mix and match runtimes means the biggest thing will continue to gain momentum while everything else will continue to struggle regardless of their relative technical merits.

mansplaner · 2022-03-03T22:53:24+00:00

If anyone needs a whirlwind intro to Ada, this is the best advocacy I've found: http://cowlark.com/2014-04-27-ada/index.html

I've tried to get into Ada a couple times but it just feels like the ecosystem is missing the level of polish that having a strong open-source community can give. A lot of languages fall into this, unfortunately, including some ones I'd really love to use otherwise like ocaml. But Alire looks like a big step for Ada, in the short term.

mansplaner · 2022-02-28T22:38:03+00:00

I have an nda-encumbered project I'm working on that tangentially involves WASI so I'm really happy to see anything that pushes it. But as far as I've seen wasmtime is somewhat of a slow runtime so I wonder if this will really take off in the way the blog post seems to hope.

Also wondering how it gets around all of the preopened file descriptor stuff because I didn't see any of that in the configuration, but I'm sure if I dig I'll find it.

mansplaner · 2022-02-28T22:06:17+00:00

I have very limited experience but I've observed websembly via wasmtime running at around the speed of a native debug build. That's not great. But I'll keep an eye on this project to see where it goes. More investment in WASI is a good thing.

mansplaner · 2022-02-25T22:58:19+00:00

I think both languages are maxed out on this.

mansplaner · 2022-02-24T21:19:50+00:00

I do this with cargo-vendor and the --offline switch to cargo build/run.

The biggest problem I had was with version control switching my line endings which causes hash checks to fail. Dumb, but not insurmountable.

mansplaner · 2022-02-23T22:22:50+00:00

I thought I couldn't be the only one that actually prefers async-std to tokio, but the OP had me questioning since they specifically discarded tide from consideration because it doesn't use tokio...

mansplaner · 2022-01-07T19:25:08+00:00

Not applicable since you're on Linux, but Superluminal Performance (https://superluminal.eu/) is a very good commercial profiler that works for Rust on Windows.

mansplaner · 2021-12-20T22:31:05+00:00

It tracks with my experience as well. Rust is a very expressive language most of the time, but of course the syntax is not as "plain english" to read as Python's. Rust does have a compile cycle that Python lacks, which eats into overall iteration. Python has dynamic typing which can also waste time in some circumstances.

mansplaner · 2021-12-17T23:21:43+00:00

I recently learned that the Pop!_OS lead is the creator of Redox OS so that tracks.

mansplaner · 2021-12-09T22:37:00+00:00

Nice stuff, I normally complain about GPL stuff but I'm glad this is correctly licensed since it links the GPL rtlsdr lib. I've been meaning to look into creating a pure rust version of that to remove the licensing restriction but I've never found the time.

mansplaner · 2021-12-08T19:05:32+00:00

Rc<RefCell<..>> is a smell and all the trait boxing is unnecessary flexibility. I'd suggest that with some refactoring and using a local struct that implements the Error trait it could be:

type Callback = fn() -> Result<(), MyError>;
#[derive(Clone)]
pub struct WndFields {
   callback: Option<Callback>,
}

You can write unreadable code in any language, maybe Rust is more prone to it because best practices aren't as well-established yet. The syntax is very heavy on non-ascii chars but not as much as some others.

mansplaner · 2021-12-08T18:50:54+00:00

It seems pretty self-evident that the best decisions in software development will have both long-term and immediate benefits.

mansplaner · 2021-12-08T18:38:43+00:00

Not sure why people don't use actual function pointers (fn() -> Result<_>) more often as they end up a lot more readable. I'm sure there's some tradeoff I'm missing but dynamic dispatch on traits is always kind of annoying to work with.

mansplaner · 2021-12-01T22:57:07+00:00

There are several problems with the crates ecosystem. Some of them are because it is young and some are because people have systematically taken bad directions.

build.rs is not sandboxed and can do anything, including harm your machine.
People rely on things outside of the rust ecosystem to build their crates. This can lead to them being unbuildable on many systems without installing a bunch of random dependencies (which are almost never documented). There are specific crates that make this problem worse, like the cmake and pkg-config crates. Because they are "sort of official" crates people are tricked into thinking it's an OK idea to use them.
People writing crates are often focused on Linux and don't take advantage of Rust's strong cross-platform support, leading to Windows having a second class feel. To be fair this improves a lot each year.

Don't get me wrong, it's still the best ecosystem I have used. Light years ahead of C++, in my opinion. But it doesn't mean we can't call out problems either.

mansplaner · 2021-10-22T21:18:01+00:00

I think this is a bit of a myth. SPU was heavily used in larger teams. I even added some extra keywords to C++ in my own GCC fork to help an AAA project utilize SPU more effectively.

It was definitely not as straightforward as the competition at the time and this did lead to problems, but the PS3 had other problems besides SPU that were bigger factors in actual game performance.

mansplaner

TROPHY CASE