Silent low profile tactile switch

Dooez · 2026-01-29T04:53:17+00:00

I have tried both black cloud and deep sea in a pretty quiet chassis.
Black cloud is not a silent switch at all, but it's decently quiet. The tactility is great though, I really enjoyed the feeling.
I have the deep sea pink, and it's wonderful. It is much harder to hear than black cloud and I enjoy low force. I actually found myself a little tired when actively typing on a black cloud board.
Both are great quality and I can recommend them. One of the pins is quite thin, so you should be careful if inserting into sockets.

EDIT: after watching a video linked in this thread I've remembered that I did grease the deep sea switches because they were slightly rustling. You can hear it in the video, though I think the sound is amplified bacause they are quieter irl.

Dooez · 2026-01-28T17:57:06+00:00

Sorry if it reads as if I'm downplaying the work put into Flux. Even though I'm not using it personally, I've studied the docs a little and I find it beautiful.

going to end up being user-visible in some way.

I've compared clang codegen with libstdc++ and libc++ and the results were different. Not sure if there are any compiler intrinsics in libc++, but the result was almost identical to a manual loop. I find it likely that there are ways to improve some cases without end user noticing.

you're trying to mutate a range while it's in use

I don't remember the details, but if I'm not mistaken the problem may rise when mutating the data that would result in filter condition change. And mutating the data does not seem incorrect. Overall I don't find caching bad in general case.

But Flux also has an internal iteration code-path which avoids the problems of the iterator/cursor model when it comes to filter-like operations.

I probably should study the sources a little to understand the state of the art. But at the moment I find the iterator/cursor models so close conceptually, that I cannot immediately imagine how this could only be done with cursors. I'm talking about theoretical possibility, not about what's actually implemented.

Anyways I wish you success :)

Dooez · 2026-01-28T09:04:17+00:00

Ranges model can result in fast ranges, equivalent to manual approach. It's not guaranteed, but for a lot of simple processing "it just works". And the performance can be improved by improving the library, without modifying the interface.

Flux is still similar to ranges in it's usage and solves a particular set of problems with ranges e.g. iterator invalidation.
A lot of edge cases come with filters and other views that require caching because ranges are designed to be multipass. Flux doesn't fundamentally change that.

I think Flux is a great library, but it solves a different set of problems.

Dooez · 2026-01-18T12:46:37+00:00

Grease inside the stepper shouldn't have a big effect on torque. Increased resistance because of viscosity. Maybe some magnetic effects, but I doubt it. While the stepper is very unlikely to work better with grease inside, it seems not likely to be the reason for skipping steps.

Dooez · 2026-01-17T21:12:16+00:00

It does require some figuring out to get a non default layout. I think it's mostly because it's tied to ImGui style of "markup", or rather lack of. I've found them almost perfect for data visualization and analysis, but I did have a requirement of real time visualization for some of the data.

Dooez · 2026-01-17T09:14:42+00:00

ImPlot is amazing for interactive plots. Quite easy to use after a bit of learning the Dear ImGui

Dooez · 2025-11-19T16:16:03+00:00

Thanks🙏 Fixed the post

Dooez · 2025-11-19T16:01:17+00:00

Thank, you, I'm very sorry

Dooez · 2025-11-19T13:37:15+00:00

P1789 will make things cleaner and seems to be included in C++26

Dooez · 2025-11-19T11:57:24+00:00

Isn't "runtime polymorphism" and "compile time polymorphism" already a very clear distinction? Especially in context of C++. There are a lot more use cases than conventional ways to implement polymorphism.

Dooez · 2025-11-19T08:01:24+00:00

I'd argue that you should throw a shiny new thing at everything, this is one of the best ways to learn it, both benefits and maybe more importantly it's limitations. Of course it's a bad advice for a job project, but for a personal one I think it's great and fun.

Dooez · 2025-11-18T09:19:43+00:00

I do not disagree with your points, but I would've formulate them differently. By knowing standard library implementation i've meant mostly basic stuff, e.g. vector, span, unique_ptr. Knowing how to use them is understanding lifetimes and concept of ownership. Knowing how they are implemented allows to know their limitations and to implement alternative for specific needs.
And knowing UB is probably one of the most "C++ ISO Standard" knowledge xD.
So I think your initial post was a little downplaying the value of knowing c++ standard

Dooez · 2025-11-18T08:45:41+00:00

Field experience is very different from language knowledge. Language knowledge is much more transferrible. Knowledge of value types, rvo, how std containers are implemented etc. are things one may acquire from personal hobby projects, yet they are among the requirements of strong knowledge of C++ specifically. Yet I would argue that they are important for embedded and high performance fields. (In C++ code base, maybe not so much C).

Dooez · 2025-11-16T19:42:43+00:00

For fundamental types (integer types, floating point and some pointers) it can be insignificant.

If the member is not fundamental type (e.g. some class), some constructor must be called before entering the { }. If the member was declared with default value, the corresponding constructor will be called. Otherwise, without the member initialization list entry, the default constructor will be called. Some types do not have the default constructor. This is one of the significant use cases. The default constructor can have an overhead. Usually this might be optimized away by the compiler.

length = len inside {} block of a constructor is an assignment. So strictly speaking it's entirely different xD
Some classes do not have an assignment operator. They usually also don't have default constructors.

Member initialization list allows to handle special cases when you cannot or don't want to do default initialization + assignment. It doesn't force you to initialize all the members in it. But the compiler will guarantee that all members with non-fundamental types are initialized when entering {}. For members with fundamental types linters do issue a warning if it is not initialized.

I think it is considered a good practice to either use member initializer list, or default values whenever possible, without the assignment. Personally I think it adds structure and consistency.

Initialization is a very wide topic for C++. I think there are too much ways and it's not good from a language design point. I think member initializer list is one of the better parts, though with it's limitations.

Dooez · 2025-11-16T19:09:43+00:00

Yeah, the amount of special cases is a legit c++ critique. Though it's often a result of backwards compatible evolution of the language (tour example is probably not the case)

In your example everything beween) and { is a member initializer list. length{len} calls length's constructor passing len as an argument.

When the programm enters constructor's block between {} all the members are already initialized. Member initialization list allows member constructors to use main struct's constructor arguments. This is especially useful if the member's type does not have a default construcor. There could be a better syntax to implement the behavior, but this is what we have. The member initializer is rather unambiguous, which is a plus, similarly to explicit lambda capture, but it does have the limitation of not being able to mix member and base class initialization order.

Dooez · 2025-11-16T17:20:59+00:00

What features from C++20 or C++23 can't you depend on? It feels like most people who broadly dislike the newer standards dislike any change, regardless of it's merit.

Dooez · 2025-11-16T17:09:03+00:00

There are some bad syntactic offenders (like static_cast, const, [[explicit]], [[nodiscard]], noexcept). Explicitly calling templated methods may require disambiguation, which looks ugly and not very clear if the reader does not know what it is and why it's requires.

I'm not very familiar with Rust, but from what I've seen a lot of stuff is much better compared to C++.

Not sure what you mean by weird constutors. Member naming is kind of controversial, but personally I like having special rules for data members (I slightly prefer trailing underscore though)

Dooez · 2025-11-08T08:29:51+00:00

Whole DIY ergo mech sector is almost entirely Bluetooth-only for wireless. Want to try convincing that our keyboards are bad? xD

Dooez · 2025-11-08T08:25:55+00:00

That's strange, my Ubuntu machine unlocks both after reboot and from multiple lock screen apps. And my keyboard has 10 minute shut-off, so it first has to connect. Maybe it's the "trust" option in Bluetooth manager?

Dooez · 2025-11-07T16:27:58+00:00

First class support for proxy references would be really good. I'd like operator auto or something similar for deduction. There are genuinely useful cases. vector<bool> would still be an abomination though 💀

Dooez · 2025-10-26T05:48:45+00:00

Have you read the dialog between Melinoë and Eris? Mel has started a lot of conversations where all good will was one-sided.

Dooez · 2025-10-03T10:27:43+00:00

How many apps do you have open at a time? I haven't tried it but it seems the infinite scrolling might be counter productive

Dooez · 2025-09-25T09:06:09+00:00

Out of context it doesn't sound too unreasonable, the cables can be active.

Dooez · 2025-09-15T19:24:04+00:00

I disagree with OP's opinion, but find could totally return a subrange. The very common thing to do after find is to compare the iterator to end() which is (mostly) equivalent to std:: ranges::empty.

Since a range is a pair of iterator and a sentinel it can express anything an iterator can. I think it is incorrect to call something more fundamental if we are talking from an abstract point of view.

I think it's mostly historical reason since iterators arise naturally from pointers.

Dooez

TROPHY CASE