This has to be one of the most important moments in the history of mathematics. We now have a non-human intelligence capable of solving one of the most difficult problems in mathematics.
This is actually useful, but despite it is another extra thing you will have to remember when reading C++ code. I guess with LLMs things aren't so bad.
You need to remember _less_, rather than more, when you use this kind of vocabulary types. Think about std::optional. Before that (and if you didn't write something like it yourself), you had to, for each class, remember the bespoke semantics of when and how it represents the lack of some members, and you would have to have non-defaulted ctors, move assignments and dtors, and then whenever you used that class you would need to think about what those custom method do, which might be different than other classes which have optional members. Now you just tell yourself "oh, it just has an optional member, no biggie". Look at my comment above regarding how short the implementation of Widget becomes when you squeeze the juice from having the rule of 0.
No. This is not what I meant. I absolutely agree that std::indirect is an improvement. My point is that when dealing with C++ code, now there is yet another way of doing the same thing. I will have to remember both ways, because people will still keep using the old way.
Ok, well, you have a point, in that you might see the old way of doing things and you might see the new way. This is, however, one of the detriments of the language's commitment to backwards-compatibility: Old-C++ code is (almost without fail) valid new-C++ code.
When you write new code, this is (mostly) not an issue; when you have to maintain old code, it is. Especially if the existing codebase is somewhat of a patchwork of code introduced at different points in time - pre-C++98, C++98, C++03, C++11 and so on. For this reason it is a saintly virtue to manage to unify the C++ "vernacular" used in a project, for better readability by newcomers and for facilitating uniform changes to the entire codebase later on.
Why? It’s still the good (bad)
old pimpl pattern. It just got a bit shorter. When reading you dont even need to grok “std::indirect”, you see the word pimpl and you know what’s going on.
Because I will still encounter people who use the old of writing pimpl. So I now I'm forced to remember the old way + new way. People aren't magically switching to use std::indirect. I bet that even in 10 years, half of projects will still be using the old way.
I don't really get why people keep repeating the "C++ is too big" complaint together with the implication that you need to remember the entirety of the standard library. In comparison Java has networking, GUI framework and even MIDI in its standard libraries. Is it because C++ is more closely related to C which library is so small that it barely contains anything useful? I much prefer code that uses a library feature rather than yet another poorly implemented and not documented hand rolled version of it.
Networking, GUI frameworks, and MIDI are presumably all self-contained and you would not need to be familiar with them except when working on networking, GUIs, or MIDI files, respectively. This is a general-purpose thing that could show up in any c++ code.
> Novel mathematical methods precede their application by at least a decade and widespread use by about a century.
This isn't really a good argument. The assumption here is that the "applications" were possible because of the math itself, but it leaves out the possibility if the math didn't exist somehow it will be discovered/invented because the applications demand so.
> There is a lot of mathematics created but we don’t yet know how to use it.
The vast majority of mathematical work is complete useless. Only a small percentage finds use in the real world (even if you consider the maths from centuries back).
Webgpu is the worst of both worlds. Significantly more complicated than opengl yet not capable of many "essential" modern techniques like bindless resources.
If you must use a modern api to learn for whatever reason, go with vulkan and use dynamic rendering and buffer device addressing.
WebGPU has the issue that feature/capability-wise it is essentially 5 years behind OpenGL 4.6, which came out 8 years ago. And the other downside being that it adopted old Vulkan concepts that even Vulkan started to ditch, like render passes and static pipelines.
For beginners that's irrelevant. WebGPU has more than enough features for beginners to learn about graphics programming. Not just that, once you're used to WebGPU, going to Vulkan will be much easier than the transition from OpenGL.
I wouldnt recommend anyone going to Vulkan, though. It's pretty much the worst graphics API out there, and WebGPU is mimicking outdated Vulkan design decisions that even Vulkan is currently outphasing, like render passes and static pipelines.
Honestly, in 2026 I would not really bother with OpenGL. Just start with WebGPU, it's much nicer. You can use it easily on most modern browsers or better can even use native libraries like Dawn or WGPU.
In light of WebGPU, I respectfully disagree. Because it has us building shader modules, buffers, and pipelines up-front with descriptors, the task of figuring out why something isn't working is often front-loaded. Pair that with its eloquent warnings (in comparison to, like, gl.getProgramParameter(shader, gl. COMPILE_STATUS) ) and the ability to label all your stuff to see it referred to by name in aforementioned warnings text... I'm rambling, but, there's just a lot of helpful stuff in WebGPU that I don't think OpenGL has, that stands to really help newcomers along
> It might then seem reasonable to think that writing with a stylus on an iPad or similar would be best, since no force is needed and friction is minimized. I don’t think this is true. A small amount of friction is actually desirable.
I find digital handwriting quite pleasant and almost better than writing on paper. Friction is indeed an issue, but you can just buy a dedicated screen protector to address this problem.
Yeah especially for doing math, I've found it's really helpful that I can just select some equations I wrote and shift them down (or insert more space).
It helps with adding derivations or additional notes after the fact.
However I'm considering moving back to handwritten notebooks for some things, purely due to the simplicity (no worry about battery life, technical issues, or the difficulty in switching back and forth between my book reader and my notes app).
> Has anything really important been solved by AI yet
Alphafold essentially solved the protein folding problem and it's arguably one of the biggest (if not the biggest) scientific achievements of the 21st century.
reply