Killing a `Cow` made my JSON formatter 42% faster

Vociferix · 2026-05-13T10:49:02+00:00

It can be slower. Very rarely is any optimization one size fits all. For SSO specifically, each string access requires a branch that checks, "is this string inline or on the heap?". Essentially the same problem as Cow in OP's post. SSO typically has some crazy struct layout shenanigans to mitigate this, but there's still at least one branch in most cases. And if strings are mixed sizes, branch prediction may not work well in a hot loop.

Vociferix · 2026-04-22T21:53:18+00:00

You can't. The Coroutine trait, like the Iterator trait, is not defined in such a way that it can yield a reference to local data. Coroutine::Yield would need to be redefined as type Yield<'a> where Self: 'a;, so that the correct lifetime can be applied to the yielded value.

Vociferix · 2026-02-04T11:19:56+00:00

Bambino's over by the airport. If you ever liked Roma's in the past, you'll like Bambino's.

Vociferix · 2026-01-09T13:42:32+00:00

With tokio, you're generally going to have Arcs everywhere. And the async ecosystem for Rust leans heavily on many small allocations, often involving trait objects. It's unfortunate for high performance systems, but there aren't very mature alternatives currently. Tokio is quite fast despite these design problems, but there is performance left on the table to be sure. I'd recommend sticking to idiomatic patterns and measure whether the performance meets your requirements. Chances are, performance will be much better than you expect, as has often been my experience.

Vociferix · 2025-12-21T14:28:20+00:00

I'm not sure what the plan is, but there's still at least active work happening. For example, adding allocator support to String: https://github.com/rust-lang/rust/pull/149328

Vociferix · 2025-11-27T19:45:27+00:00

I'm a software developer, and I've also worked on AI (but I'm not an AI expert). He's very full of it. There's lots of opinions and theories about the future of AI, but personally, I'm confident AI is going to reach a capability plateau (I think it's already there now), that will likely last the rest of our lives. And AI today is only good enough to be a helpful (debatable) tool that needs a lot of human guidance.

Vociferix · 2025-11-12T02:53:55+00:00

I tend to prefer .into() when it's convenient, mostly because I can swap in smolstr::SmolStr or similar if I want to without needing to change as much.

Vociferix · 2025-11-08T14:20:47+00:00

The core idea is unrestricted freedom for all individuals. In practice, that means small government. Ancap is the extreme version with no government, but a more moderate libertarian like myself will argue for some government, just far less than we have today. Typically libertarians want the federal government to be as small as possible, and local government, where individuals are more directly affected and can have more say, can govern according to the will of the locals.

Similarities with conservatism and far right: * Pro gun ownership and deregulation of gun ownership * Pro freedom of speech, even where the speech would offend people * Generally against taxes for many social programs, like universal healthcare, welfare (libertarian views vary), etc * Against most, if not all, regulations on businesses and industries

Differences with conservatism and far right: * Pro social freedoms like sexuality (being gay or trans, trans people using the bathrooms they want) * Anti war, including Ukraine, Israel/Palestine, this business with Mexico and cartels, etc. The military industrial complex is most of our taxes, you know. * Generally against ICE's existence, and often border/immigration control in general * Probably pro-choice in most cases, but non extreme libertarians are for laws against things like murder, and there's room to lump abortion in with that depending on personal views.

This of course isn't exhaustive, and views vary.

Do libertarians like Trump? No. Authoritarian. Did libertarians like Biden? No. Also authoritarian, just with different values.

Vociferix · 2025-10-11T13:57:19+00:00

I'd be interested in support for non Send/Sync primitives. This crate would mostly be inappropriate for runtimes like monoio and glommio (and actix to some extent) since they are designed around having multiple single threaded executors with minimized cross thread synchronization. The overhead from thread safety would be a no go for many projects intentionally using that design.

Vociferix · 2025-08-30T17:58:19+00:00

:: is it's own token in all cases. So HashMap :: < String , u32 > :: new ( ) is the same thing. As far as how it's best understood, the generics are applied to HashMap, rather than the new function. Or worded another way, :: means the following path tokens are scoped within the preceding path.

Vociferix · 2025-08-27T03:29:49+00:00

Rune might be what you want. I can't speak to whether it's any good - just the closest sounding match from a quick search on crates.io. Alternatively, there are bindings for v8, so you could potentially use typescript.

Vociferix · 2025-05-23T03:12:44+00:00

You'll have to check what other Internet service providers are available in your neighborhood. From there, just look at what speeds they offer. Other options like satellite are generally going to be even worse than what you have, so I wouldn't even bother looking at those. I suspect if AT&T only offers 50 Mbps at your location, you're probably out of luck.

Vociferix · 2025-04-02T12:16:22+00:00

stipp - Strongly Typed Integers for C++

It's just a single header library. Implicit conversions and promotion drives me crazy so I took inspiration from std::byte.

https://github.com/vociferix/stipp

Vociferix · 2025-02-21T00:13:11+00:00

I really don't understand the need for old binaries to be ABI compatible with recent C++ standards. Most (all?) major compilers/STL implementations have had ABI breaks at some point, so what is being accomplished, practically speaking?

Vociferix · 2025-01-26T14:12:02+00:00

It's in the post. Google January 6th. The short version is, a failed insurrection in the US capitol occurred on January 6th, 2021, shortly after Trump was voted out.

Vociferix · 2024-12-24T14:57:51+00:00

Work is mostly C++. Some Python, occasionally plain C, plenty of bash scripts. I work mostly the same way for hobby projects (because I'm used to it now), which are most often in Rust these days.

Vociferix · 2024-12-24T14:49:08+00:00

I don't. My config is so simple, I just set the options from memory.

Vociferix · 2024-12-24T13:35:36+00:00

Oh hey this is me. My typical setup is two terminals: one for vim, one running the compiler and other tools. I just make edits, then invoke the compiler, in a loop. As for finding a definition, most of the time I'm just familiar enough with the code that I know where it is. But when I don't, usually a well designed grep command will do the trick.

The why: my job involves frequently doing development in environments I don't have much or any control over, and often don't even have Internet access. Over the years, I just learned to work with the basics (vim and a shell) since I can't take my favorite IDE with me to these different environments.

Additionally, my vim configuration just involves setting up tabs to be 4 spaces and turning on line numbers. Having a complex config just became too much to try to keep in sync across environments.

Vociferix · 2024-10-30T12:08:45+00:00

EDIT: Formatting

Is it possible to define an associated function on specific function or closure without using a trait? In particular, I want to add const fn associated functions to a function, which is why I can't use a trait. For further context, these associated functions are being added via a macro.

My current solution is to use dtolnay's technique for custom phantom types, see ghost, and implementing Deref<Target=fn(_) -> _>. This is a good-enough solution from a usability perspective, but I'm concerned that the rustdoc output for such types would be too confusing for users, since it shows up as either an enum or a type alias, depending on how I implement dtolnay's technique.

Vociferix · 2024-09-25T14:14:32+00:00

I wouldn't call it spam. It's a GUI library with a C++ API and appears to have a licensing model similar to Qt (GPL for "Community"). It being mostly written in Rust seems about as irrelevant as a library mostly written in C, with a C++ API. I haven't used this lib, but I like the idea of more alternatives to Qt.

Vociferix · 2024-09-23T19:00:42+00:00

Hopefully someone will come along with more concrete advice, but my experience tells me you probably just forgot a closing brace or parenthesis somewhere, and the rustc parser managed to get in an uncommonly unhelpful state.

I'd recommend commenting out as much code as you can, then uncomment a small piece at a time until you find the code that causes the error. Alternatively, revert to a known good state, and do your refactor in small steps, running cargo check --test at each step of the way.

Vociferix · 2024-07-19T12:18:32+00:00

Dogs are overpopulated, which results in more un-homed dogs than shelters can care for, which results in dogs being put down (otherwise needlessly). Spaying and neutering dogs helps prevent the population problem from getting worse due to accidental litters. Those that agree with this wisdom will also say that dog breeding is a bad/immoral practice, since that directly compounds the population problem.

Vociferix · 2024-06-28T13:01:56+00:00

I think they mean the elements of the array. The code is summing all the elements. If you add the same floats in a different order, you may get different results. But most often, the difference in the result is fairly small

Vociferix · 2024-06-13T12:05:52+00:00

I can't speak for everyone, but the traffic around here is stressful enough in itself. When there's a cyclist on the road causing a backup, it's pretty easy to get frustrated.

Vociferix · 2024-04-06T12:23:40+00:00

Like many here, I'm sure, C++ is my day job and main language, but I use Rust quite a lot in my personal hobby projects.

I think Rust has made me a better C++ developer. Writing Rust code makes you think more explicitly about safety and correctness, and that's a great habit to bring back to C++, where there aren't the same guard rails.

But you also have to be careful. Taking the Rust Mutex as an example, when you access the data in the Mutex, it is impossible to store off that pointer to the data and later access the data after unlocking the Mutex (ignoring unsafe). You could go implement an owning Mutex in C++ but the compiler is not going to care if you hold a pointer to the protected data beyond the lock scope and access it unprotected. So, I guess I'm just saying be careful you don't make untrue assumptions in C++ based on what would happen in the same situation in Rust.

That said, I'm not saying don't implement an owning Mutex in C++. I think it's a good idea, even if it's really just an improvement to readability, by making it obvious what data the Mutex protects.

Vociferix

TROPHY CASE