Or even better, just get a vibrating cock ring.

for the math homies, you could say that NaN is an absorbing element

Omae wa mou shindeiru

Yeah it’s not Linux. It’s forked off MenuetOS (https://menuetos.net/ ) which is a hobby OS written entirely in assembly (FASM flavor, https://flatassembler.net/ ).

Chrono Trigger is really a must if you like JRPGs.

Obligatory Frog theme 🐸

Good ol’ tag dispatch works fine too: https://godbolt.org/z/x8hsEK48K

deleted by creator

Since you already know Java, you could jump straight to C++ with Bjarne’s book “Programming - Principles and Practice Using C++”: https://www.stroustrup.com/programming.html

You can then move to more modern C++ with his other book “A Tour of C++”: https://www.stroustrup.com/tour3.html

And then if you’re curious to know how software design is done in modern C++, even if you already know classical design patterns from your Java experience, you should get Klaus Iglberger’s book: https://www.oreilly.com/library/view/c-software-design/9781098113155/

In parallel also watch the “Back to Basics” video series by CppCon (see their YouTube channel: https://www.youtube.com/@CppCon , just type “back to basics” in that channel’s search bar).

Learning proper C++ should give you a much better understanding of the hardware while the syntax still remains elegant, and you get to add a new skill that’s in very high demand.

Templates are definitely one of the main strengths of C++ that will make me stick with this language for many years to come. They’re the closest thing to C++ introspection that we have right now and they allow you to basically make your own personal development environment with your own rules.

If you’re interested in templates metaprogramming to do stuff at compile-time and not just using templates as a replacement for macros, these are a some must-watch talks:

• Walter E. Brown’s talk in two parts: https://www.youtube.com/watch?v=Am2is2QCvxY and https://www.youtube.com/watch?v=a0FliKwcwXE
• Jody Hagins’ talk (also in two parts): https://www.youtube.com/watch?v=tiAVWcjIF6o and https://www.youtube.com/watch?v=dLZcocFOb5Q
• Odin Holmes’ talk which provides a close-to-scientific framework to reason about template optimizations (yes you can optimize them) and compilation times: https://www.youtube.com/watch?v=EtU4RDCCsiU , because -ftime-trace will not help you if you’re working with very large expression templates resulting in a json dump weighing 30GB+ and you need to narrow down the problem by reasoning from first principles.

The guidelines for freezer storage are for quality only—frozen foods stored continuously at 0°F (-18°C) or below can be kept indefinitely.

• https://www.foodsafety.gov/food-safety-charts/cold-food-storage-charts

If you’re doing C++ then C++ Weekly by Jason Turner is an awesome must-watch.

I love these kinds of videos. People could get incredibly good in C++ without spending much if they just watched these (highly recommend the “Back to Basics” videos by CppCon for beginners btw).

deleted by creator

For the catching bugs part, I’m wondering whether some of those (like _GLIBCXX_ASSERTIONS and _LIBCPP_HARDENING_MODE_EXTENSIVE) would be redundant if one already runs e.g. Clang Static Analyzer or GCC’s -fanalyzer?

For instance, this one is caught without any issues when compiling with gcc -fanalyzer -O1:

#include <memory> // "less than" and "greater than" signs getting filtered by Lemmy 0.18.5...

int main() {
    auto p = std::make_shared(42);
    p.reset(p.get()); // Incorrect use of reset
}

I’ve never understood why GC is/was even a thing in C++, and I like this Bjarne quote in this context:

I don’t like garbage. I don’t like littering. My ideal is to eliminate the need for a garbage collector by not producting any garbage.

Something you’ll learn to live by once enter the workplace: your coworkers are not your friends. There might be a one in a thousand case that’s an exception to this rule, but most of the time you should not think of them as more than coworkers you have to work with to get your job done. I’ve witnessed too many cases of coworkers backstabbing each other for their own professional ambitions or where a coworker dies and everyone just completely forgets about him a few days later.

That doesn’t mean you should be overly pessimistic either. The idea is to be pragmatic. No one wants a toxic environment, so everyone will put in some effort to maintain a cozy facade, and you should too, as that minimizes tensions for everyone. The mistake would be forgetting that it’s all a facade and starting to think of them as something like a family, that’s a mistake most juniors make.

My motto is: smile at your coworkers but guard your damn ass when you turn your back to them.

reminds me of #ifndef instead of #if !defined(...)

My bad, I’ll move there then

Vcc leverages the Shady project

sentences like this one are the reason why capitalization is important 👀

I don’t think their “entire C++ language” wording also includes the standard library (except maybe for algos with std::execution semantics). I’ve never written Vulkan code but I do a lot of CUDA (and now HIP) GPGPU stuff and things like template meta-programming are immensely useful to have generic kernels with stuff like compile-time strategy pattern to avoid lots of mostly duplicate kernels, unrolling and classical loop patterns like tiling etc… can be easily refactored into nice looking metafunctions with zero runtime overhead. It’s a game changer when you have access to modern C++ features to do GPU programming.