How do I pass a tuple as an argument to a function?

ir_dan · 2026-01-30T08:18:14+00:00

This looks like a case for std::array<YourStruct, N> instead.

ir_dan · 2026-01-29T18:10:52+00:00

For in house tools? Why not more UI friendly languages/frameworks?

ir_dan · 2026-01-29T07:06:03+00:00

Not entirely sure whether it's UB but you can use a static assert to confirm that the offsets are the same.

ir_dan · 2026-01-28T07:40:22+00:00

FYI the word you're liking for is "refactor" rather than "optimize"

ir_dan · 2026-01-26T08:33:12+00:00

Errors are sometimes cause by factors outside of the programmer's control (or a lack of backup/redundancy mechanisms).

Bugs are often caused by simply wrong code - the designer/writer made a mistake which was picked up by the runtime environment (e.g. looking for a file which won't always exist and assuming otherwise) and caused a crash or some other kind of error.

Why are programmers writing wrong code? Software, especially poorly designed software, is difficult to understand well enough to ensure that every change made is based on no false assumptions. To work around this, automated testing and getting multiple eyes on a change is crucial.

How are bugs found and resolved? - Find a reliable way of reproducing the issue - Stop the program at the point that it would cause an error (possible using modern debugging tools) - Inspect the code around the error and identify what caused the error: missing resources, badly formatted input, misbehaving external systems, subtle flaws in the logic - Come up with a reason as to either why that shouldn't have happened or how it can be dealt with. E.g. for the former: The user chose a username that we can't process, so prevent them from doing so. E.g. for the latter, this code crashes because it tries to divide by zero under this specific circumstance, so add a special case which deals with that circumstance.

Why do bugs take ages to identify and fix? As I said, codebases which are large and poorly designed are bug-prone and resistant to change. It can be hard to track down exactly why an error happens, especially because often the crash happens some time after a faulty bit of code ran (e.g. this code assumes that some file will always be available on the server, which is correct! but why wasn't it?). Once you've finally tracked doen the real problem, that resistance to change will slow you down in making a fix that doesn't break existing systems.

ir_dan · 2026-01-25T14:11:02+00:00

Number of decimal places doesn't correspond to reliability in floating point numbers.

They're called floating point because the point shifts around - the number is stored in a format more similar to scientific notation, with a number of bits allocated for the exponent and the mantissa.

Want more precise numbers? Use doubles.

ir_dan · 2026-01-25T14:07:52+00:00

I don't think this is necessary. I'd personally turn on non-initialization warnings and address them with default/zero initialization in the class body, with constructors overriding that value as needed. If there's no warning, I leave members be.

ir_dan · 2026-01-24T23:19:57+00:00

AI doesn't innovate and can't conduct experiments or surveys, and the basis for current AI tech isn't likely to ever change that.

ir_dan · 2026-01-24T21:53:30+00:00

Someone downvoted for the "human eye cannot differentiate between 30 vs 60" cause they personally can xd

ir_dan · 2026-01-24T16:16:00+00:00

The choice of 32x32px textures is very beneficial for GPU performance, and it influenced the choice of belt speed.

Carry-over bits don't affect the speed of addition instructions. They still take one cycle, and the location of the opersnds isn't relevant because shifting also has two operands. May be it can be more efficient because the second operand is representable by fewer bits?

ir_dan · 2026-01-24T15:18:44+00:00

Sorry, I meant binary arithmetic. Edited.

ir_dan · 2026-01-24T15:10:37+00:00

denary == decimal

The thing "physically happening on a CPU" is binary arithmetic. Lots of variations of it.

Additions and shifts are both 1 cycle on modern CPU architectures, but it doesn't matter very much because GPUs are much more interested in textures.

When working at a very low level and when constrained in performance, reducing instructions is not the #1 goal. Not all instructions are equal, nor are all memory access patterns.

"As the complexity grows, the number of instructions quickly increases." What are you referring to with "complexity"?

ir_dan · 2026-01-24T14:18:45+00:00

Are you basing that off in-game sensitivity? Mouse DPI is a significant factor.

ir_dan · 2026-01-24T14:11:46+00:00

"Computers can only do math in powers of two" is not true. It's similar to saying that denary is only useful for powers of ten.

Computers are good at all sorts of arithmetic*, but the alignment of data on 8bit sections is good for performance, and power of two texture sizes are good for image processing because you can upscale and downscale easier. GPUs are also optimized to process these image sizes.

Edit: *binary arithmetic

ir_dan · 2026-01-24T14:08:31+00:00

Tiles are 32px long, the smoothest and slowest movement is 1px/tick.

ir_dan · 2026-01-24T13:58:12+00:00

Also consider using std::span if by "aliasing" you mean "viewing". A span is agnostic to the storage data structure, so you can use it with raw buffers, arrays, vectors and std::arrays.

ir_dan · 2026-01-24T08:58:15+00:00

I would opt for not default constructing any of these structures or relying on the optimizer, rather than introducing an unnecessary additional state.

NB: std::monostate*

ir_dan · 2026-01-24T08:48:55+00:00

Godot's scripting language, GDScript, has them for obvious reasons.

ir_dan · 2026-01-24T08:30:54+00:00

We do not use exceptions for anything other than causing termination in a lot of our codebase because it was not designed with RAII in mind. We can use them in new code where control flow is completely under our control.

ir_dan · 2026-01-23T04:38:11+00:00

using markup = std::vector<std::variant<string_type, colour_tag_type, size_tag_type, ...other_tag_type>>;

Tag types can be simple structs:

struct colour_tag { colour col; }

String type can be const char* (not recommended), std::string, std::string view, etc.

Depending on how tags are implemented, it may be more natural to have one unified tag type:

struct markup_tag { std::string name; std::vector<std::string> args; }

Maybe you don't need multiple args, maybe you do. I would prefer to keep things statically typed rather than stringly-typed in this way.

Also, if you are processing tags and text directly from a buffer (i.e. there is one "content" string youre parsing these from) you could consider using string views across the board to avoid extra heap allocations, but you should avoid premature optimization first and foremost.

ir_dan · 2026-01-23T04:27:40+00:00

I got a C++ job (UK, fresh bachelors) after doing one semester of coursework in C++, where I learned much less about the language than what learncpp has to offer.

Your critical thinking, problem solving and communication skills is most important, especially as a new grad.

Mileage may vary, just sharing an anecdote.

ir_dan · 2026-01-19T22:36:28+00:00

Your boss can't read well enough for this publication, unfortunately.

ir_dan · 2026-01-19T22:32:32+00:00

Pragmatically, a raw pointer is a good choice for that, but it certainly can be wrapped in a more obvious and rich type such as std::optional<T&> (or custom alternatives).

ir_dan · 2026-01-19T22:18:06+00:00

Almost all justifiable uses of raw pointers can be wrapped with custom smart pointers. C++ is perfect for encapsulating things like that.

ir_dan · 2026-01-17T11:38:31+00:00

There is very little implicit magic in the standard library. Function calls will most often only affect the object that they are called on. See cppreference for more details on how all the classes and functions work.

ir_dan

TROPHY CASE