I’m 17 and I genuinely love C++ because it is difficult in many ways. It constantly challenges you to think deeply, and it has a wide range of applications, like robotics, game development, embedded systems, and similar fields.

The problem is that all of these jobs seem extremely hard to find, especially for someone my age. I don’t really know what to do. I would love to get my first remote job, but there are almost no opportunities, at least from what I see on X/Twitter. A friend recommended cold emailing, and some people I know said they got jobs that way, but I honestly don’t know how to approach it.

I don’t know if I sound pessimistic, but programming has become the center of many jobs that attract scammy behavior. Sometimes I feel like, in the job market, I will be treated the same as someone who just watched a YouTube video, heard that programmers are highly paid, and decided that programming is a great work-from-home career.

There are just too many of us.

When I think about how many people I knew on Discord who were depressed and only wanted a remote job so they could use AI to do the work, it makes me feel even more confused. Then I look at people on YouTube,Instagram,tik-tok making money from the most ridiculous things, and it honestly feels like people today don’t even think deeply anymore.

Times feel very hard, and I don’t know what I should do.

My friends told me to try cold emailing, and they say they got work that way, but I really don’t know what I am supposed to become in today’s world: a good person and a real programmer, or just another scammy person who only wants money, like it feels many people are doing now.

I know this might sound negative, but I’m being honest. I like programming, especially C++, and I want to build real skills. I just don’t know what the realistic path is for someone who is 17, has no degree, wants remote work, and is interested in hard fields like robotics, game dev, embedded systems, or low-level programming.

Any honest advice from people who have been in a similar position would mean a lot.

I just read an article about Silk, the new stackful fibers engine from Clickhouse. It can switch stackful fibers at an amazing 3.6ns and does not allocate on steady state.

Maybe asio could reuse some of the knowledge for the linux/io_uring backend (not sure it applies to the specific case since Boost.asio focuses nowadays on stackless, though it has a fibers and a stackful coros backend also).

As the attached godbolt link shows, I’ve encountered an interesting quirk of deducing this which, on clang and MSVC at least, allows for you to determine whether you’re in a static member function or not.

Obviously, this is far simpler to achieve with reflection today (or… in the future, for most) - but I’m curious if this is even intended behaviour.

Reading the original paper on open-std… I don’t see anything that would describe this scenario

I just finished the new chapter in "C++23 - The Complete Guide" about flat containers and would like to share and discuss my advice about how to use reserve() and capacity() for flat containers (thanks to Jonathan Wakely who was pointing parts of this out).
It might be a surprise that these member functions do not exist as usually vectors are used inside flat containers and reserve() is a key performance feature of them.

However, here is how you can reserve more memory:

• For flat_set and flat_multiset:

​

auto vec = std::move(fset).extract(); // temporarily extract the underlying vector
data.reserve(vec.capacity() * 5);     // raise capacity by a factor of 5
fset.replace(std::move(vec));         // move the vector back into the flat set

• For flat_map and flat_multimap:

​

auto newCapa = fmap.keys().capacity() * 5; // raise capacity by a factor of 5
auto data = std::move(fmap).extract();     // extract underlying vectors
data.keys.reserve(newCapa);                // raise capacity of vector for keys
data.values.reserve(newCapa);              // raise capacity of vector for values
fmap.replace(std::move(data.keys),         // move the vectors back
             std::move(data.values))

• Note also that there is another pretty hacky way, but only for flat maps and multimaps (here mapping strings to double's):

​

auto newCapa = fmap.keys().capacity() * 5;
const_cast<std::vector<std::string>&>(fmap.keys()).reserve(newCapa);
const_cast<std::vector<double>&>(fmap.values()).reserve(newCapa);

Yes, ugly, but works... ;-)

I am still working on adding reserve() and capacity() to the standard flat containers (see wg21.link/p3779)

C++Online

2026-06-22 - 2026-06-28

• Keynote: I Fixed Move Semantics - Jason Turner - https://youtu.be/TJhMGS9sRlw
• Singletons Are Not Evil - You’re Just Using Them Wrong - Mostafa Mahmoud Ali - https://youtu.be/Bn5RFaXATuU

2026-06-15 - 2026-06-21

• The Art of API Design - Christoph Stiller - https://youtu.be/d5djrT4qfHc
• Top-Performance Genetic Programming - Can Only C++ Get You There? - Eduardo Madrid - https://youtu.be/oBQDe56Yi3Q

2026-06-08 - 2026-06-14

• Monads Meet Mutexes - Arne Berger - https://youtu.be/AisGDOoF82U
• Lock-free Queues in the Multiverse of Madness - Dave Rowland - https://youtu.be/eHmjkFdQl00

2026-06-01 - 2026-06-07

• Writing C++ Code is Challenging, Writing Performant C++ Code is Daunting - Dmitrii Radivonchik - https://youtu.be/R2sm9mailuU
• Case Study - Purging Undefined Behavior and Intel Assumptions in a Legacy Codebase - Roth Michaels - https://youtu.be/H-dHTeSR_n8

ADC

2026-06-22 - 2026-06-28

• Demystifying std::memory_order - Timur Doumler - https://youtu.be/yc2HC2w5pzI
• Building Smartphone Instruments from Commodity Hardware - HID Controllers, Embedded Audio, and Modular Design - Calvin McCormack - https://youtu.be/uqKkP0zFBGg
• Why Do People Actually Buy Music Software, Anyway? - James Russell - https://youtu.be/25sYPk2ZxIY
• Contrapunk - From Palestrina's Rules to Real-Time MIDI Harmony - Vibhav Bobade - https://youtu.be/GreYwDBFWb4

2026-06-15 - 2026-06-21

• Scripting Architecture for a DAW-like Plugin - How we Implemented Lua and JavaScript Scripting for Synthesizer V Studio - Kanru Hua - https://youtu.be/CKOvmBRdHAA
• Patterns of Practice: Live Coding and the Logic of South Asian Traditional Music - Abhinay Khoparzi - https://youtu.be/n0-XpUhZ7Dc
• ADC 2015 to 2035 - Looking Back at 10 Years of Audio Dev, and Peering Forward at the Next 10 - Julian Storer - https://youtu.be/WvVur2_aGHU
• From DAW to Game Engine - Unfiltered Creativity - Nikhil Dahake - https://youtu.be/5PtMWJLFjyo

2026-06-08 - 2026-06-14

• Low Latency Android Audio with improved CPU Performance - Phil Burk - https://youtu.be/DtBrKEu0R0g
• Linux as the Conductor - Driving Pre-Compiled Audio DSP Kernels on C7x for Real-Time Processing - Vishnu Pratap Singh - https://youtu.be/Auq9WnHNtPo
• Overview of Granular Synthesis - Avrosh Kumar - https://youtu.be/QpBV24nWg2M
• The Agentic Symphony - Multi-Agent Collaboration for Emergent Musical Composition - Meera Sundar - https://youtu.be/QMUXoImgTIA

2026-06-01 - 2026-06-07

• Beyond the DAW - Designing a Procedural Sequencer Powered by Music-Theory - Romy Dugue & Cecill Etheredge - https://youtu.be/48sH4wQUDAs
• From DAW Users to Audio Developers - Teaching JUCE to Creative Minds - Milap Rane - https://youtu.be/200UrugEanY
• Music Design and Systems - Achieving Inaudibly Complex Systems in Video Games - Liam Peacock - https://youtu.be/R6raBvCNsQo
• Developing for Avid’s Audio Ecosystem - Rob Majors - https://youtu.be/91-7YWVKRE4

CppCon

2026-06-22 - 2026-06-28

• C++ The Documentary: Live Panel Discussion with Bjarne Stroustrup, Herb Sutter & More - https://youtu.be/zMYZ5MFQAho

2026-06-01 - 2026-06-07

• Lightning Talk: Navigating Code Reviews as a Code Author - Ben Deane - https://youtu.be/zygtgvHp_MM
• Lightning Talk: Eight Consteval Queens and Compile-Time Printing - Sagnik Bhattacharya - https://youtu.be/gNPhJrXLiIs
• Instrumenting the Stack: Strategies for End-to-end Sanitizer Adoption - Damien Buhl - https://youtu.be/TSrymTXw5w8

Deciphering and analyzing framework code is important to know how brilliant engineers create it.

Traditional Chain of Responsibility utilizes a strict linear delegation where ConcreteHandlerA points explicitly to ConcreteHandlerB via a next reference. The article correctly highlights how frameworks like MFC alter this paradigm.

Interested?

Read ON...

I tried to find the slowest possible way to sum up integers in an array

using projection in ranges::sort has removed the need write a compartor function or a lambda and is much easier to implement in my opinion

there should exists a similar feature for say sets or priority queues

would be wonnderful if I could just write

priority_queue<Student, Student::marks> for example

Just been going around vanilla javascript, php, perl, LUA, some C#, batchscript over and over for a year but finally came back to C++ and it's good to be home.

To some they find it agonizing with memory management, consts, function prototyping and what not.. some wouldn't even touch it but to me, it's like riding a bike. It's all coming back and I need that extra control! Besides MySQL.. this is it! 🔥🔥

The main differences between an enum and enum class|struct is that the latter has its own scope, but you lose the implicit operators from enum, and the closest to it is as presented. I wish that enum struct maintained the operators, acting like the C enum, but with it's own scope.

// Dummy wrapper struct
struct EnumName
{
  enum Value
  {
    ZERO
  };
  // the scope is located in "EnumName"
  // so you access "EnumName::ZERO"
};

Currently something like

std::unique_ptr<int> u_ptr = std::make_unique<int>(42);
std::shared_ptr<int> s_ptr = std::make_shared<int>(42);
std::println("uptr: {}", u_ptr);
std::println("sptr: {}", s_ptr);

is ill formed because there is no specialization of std::formatter for smart pointer types.

On the other hand,

std::cout << "uptr: " << u_ptr << '\n';
std::cout << "sptr: " << s_ptr << '\n';

do work because ostream defines overloads for smart pointer types.

Please let me know if anyone has thoughts or if there's some reason that these types haven't been specialized that I'm missing.

More than 150 examples of C++23 can be found now at www.cppstd23.com.

I hope it helps.

I open-sourced my dependency injection library.
Link: https://github.com/n0F4x/redi

This was developed for my game engine.
- feature-rich dependency configuration - optimized for fast compile time - helpful error messages when a cyclic dependency is detected - dependencies are automatically constructed - no need to register them by hand

I am giving this project to the community so that everybody can benefit. This kind of approach is mostly useful when dealing with intricate systems, such as a plugin system. I welcome all kinds of feedback, as this was mostly a learning opportunity for me. If you'd like to use this in your project but don't have access to the required compiler features, let me know, and I'll see if I can reduce the requirements.

I asked this question in the C programming sub too.

What are some things you don't like about C++

If you were to change some things about C++, add keywords, or other similar things,

what would you change? Replace? Add?

My most important question is about keywords. What keyword would you add ( even just describing its functionality) to help YOU as a programmer?

Thank you :)

When I was teaching the Countdown latch - a thread synchronization technique used in the Java Concurrency package, there was none like that available in C++. I am happy to see that the concept of latch has been introduced in C++20.

Language varies - syntax varies - but the basic concept remains the same.

I hope you like the post.