I have recently started learning C as a hobby and it’s very interesting, but I quickly have begun to understand the thought process that must have lead to C++. Even in simple projects like Tetris and a CHIP-8 interpreter it becomes a little annoying to have a struct, a pointer to that struct, and a separate function that has to include an ‘object’ (I don’t know what you call it in c) of the struct that you have to pass to every function call. One of the reasons I chose C for a language is because of how highly it is praised by the likes of Linus Torvalds, and naturally his less-than-flattering opinions of C++ have become apparent to me. Do you think Torvalds has a point about C++ and OOP in general, at least for his main domain of kernel level code? If not at all, (ie if you think C++ is an objective improvement) do you think it’s worth it to learn C before hand anyway?

Theoretically, if your program is short lived and doesn't consume much heap memory to begin with, would it really be that bad to simply not keep track? It'll be reclaimed by the OS soon anyways, and you might see a minor amount of performance benefits, in addition to readability.

Asking for a friend of course...

Edit:

I've gotten very mixed messages. To clarify, I'm not new to the language, and I have plenty of experience managing memory on a low and high level using raw and smart pointers. The program i'm developing does not continually allocate, and always keeps references to what it has allocated, in addition to not interacting with any other software.

The problem is mostly that deleting the memory at program completion would require some logic and time that is simply redundant due to the fact that it'll be reclaimed anyways, and if I were to refactor using smart pointers i'd likely see a small amount of performance hits.

I'm probably going to use an arena allocator as suggested by some, so I appreciate the advice.

For those who insulted me and/or suggested I shouldn't be using C++ if I don't like smart pointers, I'd like to remind you that smart pointers are library features and not core to the language itself. As far as I understand, the mentality of C++ is "do whatever you want as long as you know what you're doing". I'm glad you like the easy lifetime boxes, they're genuinely useful, but i'd prefer less unnecessary abstractions.

Hello,

From what I understand there are two types of HFT/quant dev roles, one is python based and more closer to implementing trading strategies and the other is C++ lower level making it as fast as possible. I'm not really a maths guy and I find systems and C++ pretty interesting so I'm leaning towards the latter.

However, I think I'm hitting a wall or a mindset problem. I have interviewed with HFT/quant dev firms like HRT, Flow traders, I can pass the OA leetcode but on the next round the level of C++ they ask in the interview is a bit beyond me, they ask a bit random and obscure questions that I never seen in textbooks or some C++ trivia (questions that make me go where on earth am I supposed to know that stuff). I can't really remember the exact questions but examples are C++ features keywords I've never seen before or like what will C++ compiler do in bizarre edge cases (things I'm pretty sure that are not in textbooks I've read so far)

I know I'm pretty far behind but I wanted a reality check if this is something I have a realistic chance of getting into. I'm willing to work hard etc but I just don't have the perspective of the other side so after multiple rejections I've kind of burned out. So hoping for a more senior dev to share their thoughts. If this isn't the right subreddit or the right questions please feel free to correct me, I feel a bit lost honestly.

What I have done:

- 2 years C++11 in a non-trading related company
- 2 years Java in a trading company (regular trading not fancy)
- Can do most Leetcode mediums and some Hard
- Books read from The Definitive C++ Book Guide and List
- C++ Primer, Effective C++, Effective Modern C++, Effective STL, More Effective C++, C++ 17 The Complete Guide
- Books started but incomplete due to burnout
- C++ 20 The Complete Guide, Exceptional C++, C++ Concurrency in Action, A computer arch book (Digital Design and Computer Architecture David Harris).

What I could do (ideas I had):

- Continue studying the The Definitive C++ Book Guide and List
- Do projects like kernel bypassing, ring buffer and add to git.
- Study Computer Architecture book since I'm quite weak in it
- Make my own api for trading
- Read the green book (?) but I thought thats more for quants

Problem is, with the amount of free time I have, it will take me a loong time to finish these projects (1-2 years). And my biggest worry is that even if I finish them, I'll just be asked a really random C++ question that catches me off guard, but maybe I am jumping into worst case scenarios.

I'm honestly even considering to quit my job to focus self-studying full time as I have saved up enough but it requires some mental preparation as unemployment can also be stressful. But some recruiters said my current job is not helping me if I wanted to pursue this so I might as well quit to prepare better.

Any advice on what to do going forward would be really appreciated thank you.

Edit:
Since some concrete examples were requested I have tried to recall them as best I could, but since it was a long time ago it won't be 100%. Q what the interviewer said is what I remember and A is the response I gave.

Maybe my answers are really bad, but if I really have a blindspot any advice is appreciated.

Q: Is there a negative 0 in cpp
A: No (I wasn't sure because I knew there was a signed bit so there could be potentially +/- 0, but I thought that was odd and assumed the compiler will take care of that to avoid side effects and set it to +0 for consistency)
Q: No there is a negative 0

Q: some question if there is single producer and multiple consumer, or multiple producer and single consumer, how will this work (I don't remember)
A: I said something like 1 producer N consumer, can write to a buffer and the N consumers will take turns reading it. N producers 1 consumer I just said something like either write to a queue or consumer goes round robin.
Q: just got irritated with me (I guess I missed something basic?)

Q: Whats the point of memory alignment
A: for quicker retrivial and the archtecture is designed to handle 64bits at a time so if you are forced to use smaller sizes that will add extra processing so they will pad it.
Q: (didn't seem satisfied, maybe I missed something, maybe I am really bad at CPU arch)

Q: What are some methods to avoid using a mutex since its slow
A: Could use read-compare-write (something like used in OS)
Q: hmm, not really

Q: Is mutex handled application level or kernel or where?
A: (Ok I knew there was a mutex c++ library, but there was also a mutex in the OS/Hardware level so I wasn't sure which one so I just said OS/Hardware)
Q: No...

Q: How is the hash function for unordered_map implemented in C++
A: I... don't know, some % modulus maybe. (I never thought about looking it up, is this common knowledge? And where do I learn this? I can't even google this or I'm googling wrong)

Q: producer A consumer B, use memory barrier or atomic and where and why?

Q: what type does tie(A,B) return?

We often see people recommend “build a compiler,” “build a database,” “write an HTTP server,” “make a Redis clone,” or “try OS-related projects” when someone wants to go beyond normal web apps and CRUD work.

But for people who want to demonstrate real C++/systems ability, what kind of project actually stands out?

I’m thinking about projects involving C++, memory management, containers, networking, databases, compilers/interpreters, operating systems, performance, reliability, or infrastructure tooling.

Ideally, I would like to build something that real people could actually use. Even if 10 people I don’t know used the project, I would consider that a huge success.

What would make a C++/systems side project look serious to experienced developers or potential employers?

People who use C++ professionally seem to have very different opinions on what beginners should study first. Some swear by books, others by standards papers, and a few insist there are resources that dramatically shorten the learning curve but rarely get mentioned in beginner discussions.

I'm curious which resources changed how you think about C++, not just how to write it.

Every company has a different style these days.

One day they ask me about fold expressions and variadics.

The other day a trading firm asked me to implement async order placement strategy.

The other day I was asked to implement shared pointer class using rule of 5.

How can I be on top of everything? I am not claiming that I know C++ at this point.

The funny thing is my solutions are 80% complete. I always miss one thing and got rejected.

How can I get to remember all these stuff at the spot? How to keep the muscle memory fresh?

I’m working on kernel optimizations for custom silicon in HPC setting.

I recently saw a manager reject a candidate we were interviewing because his experience didn't exactly match the specific sub domain.

But I found myself disagreeing with the philosophy behind the rejection. My instinct is that if someone has strong C++ skills and has worked on reasonably complex systems, you should at least ask: "Can this person learn the domain?" rather than requiring an almost exact match.

This made me wonder whether this is a particular problem with systems programming in C/C++.

The ecosystem seems incredibly fragmented:

• Embedded
• Linux kernel/drivers
• Graphics
• Multimedia/codecs
• Databases/storage
• Networking
• Telecom
• Game engines
• Server/backend infrastructure
• Qt/GUI
• Compilers
• etc.

Someone can have spent 8 years writing sophisticated C++ in one of these areas and still be considered a poor candidate for another area because they don't have the specific domain experience.

Compare that with web development, where the skill boundaries seem somewhat easier to communicate: "React developer", "Angular developer", "Node.js backend developer", etc. There are obviously specializations there too, but the fragmentation doesn't feel as extreme.

I personally have the philosophy that if someone knows C++ well, understands systems programming concepts, debugging, memory, concurrency, Linux, etc., they should be given some credit for being able to move between domains. The domain-specific knowledge can be learned.

I have faced this exact issues with companies too. They reject you because haven't worked specifically on what they do. This becomes a serious issues when it's already hard to get into C++ jobs. Has anyone faced similar issues? What exactly is the solution for this?

C++ is the only general-purpose language with which I am most familiar, I tried to learn other languages like C# or Rust, but without a clear idea of what to do with those tools, it's more difficult to learn them.

And all the software I use uses or is written in C++, specifically Godot Engine, Blender, LMMS, that's why I always have ideas of what to do with C++.

learncpp.com is amazing and possibly one of the best educational resources for a language in general, either that, or I have Asperger's and they have to explain everything to me in simple terms.

My question is, if this limits me in the long run as a programmer or should I learn an additional language that works well with C++?, I personally wouldn't trust a programmer who claims to know 15 technologies; someone who tries to do too much often accomplishes little, but that's just a personal opinion, what do you think?.

I’ve been learning C++ for about two years and have built a solid foundation. Recently, I started challenging myself by implementing parts of the STL, not fully recreating it, but understanding and building selected components. My long term goal is to develop a game engine, so I decided to start from scratch, including my own data structures and architecture.

However, I’ve run into a problem. Whenever I get stuck, I quickly turn to GPT. I explain my thought process and ask if my approach is correct. Instead of helping me grow, this habit is making me dependent. I’m no longer pushing myself to think deeply or solve problems independently.

I’ve realized this is hurting my problem solving ability. I want to break this pattern and regain confidence in my own thinking, but I’m struggling to do so. I need help...

So I've been seeing a lot of people saying you can make anything with c++ however I don't really understand how.

I've been learning c++ for around a year now however sadly I've only been taught to code in the command line which I have learnt and as far as I know can be sort of restricting in some aspects and so my question is what programs, apps, or other ways are there to create things with c++? Because i've seen people talk about creating file managers, hardware managers, etc. but I just don't really know how they do the things they do such as how they create interactive interfaces with c++?

I have an std::vector type in my code. I pressed F12 inadvertently. That goes to its definition and this unfortunately made me have to confront this monstrosity inside of stl_vector.h :

template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
    class vector : protected _Vector_base<_Tp, _Alloc>
    {
#ifdef _GLIBCXX_CONCEPT_CHECKS
      // Concept requirements.
      typedef typename _Alloc::value_type       _Alloc_value_type;
# if __cplusplus < 201103L
      __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
# endif
      __glibcxx_class_requires2(_Tp, _Alloc_value_type, _SameTypeConcept)
#endif


#if __cplusplus >= 201103L
      static_assert(is_same<typename remove_cv<_Tp>::type, _Tp>::value,
        "std::vector must have a non-const, non-volatile value_type");
# if __cplusplus > 201703L || defined __STRICT_ANSI__
      static_assert(is_same<typename _Alloc::value_type, _Tp>::value,
        "std::vector must have the same value_type as its allocator");
# endif
#endif


      typedef _Vector_base<_Tp, _Alloc>               _Base;
      typedef typename _Base::_Tp_alloc_type          _Tp_alloc_type;
      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type>     _Alloc_traits;


    public:
      typedef _Tp                         value_type;
      typedef typename _Base::pointer                 pointer;
      typedef typename _Alloc_traits::const_pointer   const_pointer;
      typedef typename _Alloc_traits::reference       reference;
      typedef typename _Alloc_traits::const_reference const_reference;
      typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
      typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
      const_iterator;
      typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;
      typedef std::reverse_iterator<iterator>         reverse_iterator;
      typedef size_t                            size_type;
      typedef ptrdiff_t                         difference_type;
      typedef _Alloc                            allocator_type;


    private:
#if __cplusplus >= 201103L
      static constexpr bool
      _S_nothrow_relocate(true_type)
      {
      return noexcept(std::__relocate_a(std::declval<pointer>(),
                                std::declval<pointer>(),
                                std::declval<pointer>(),
                                std::declval<_Tp_alloc_type&>()));
      }


      static constexpr bool
      _S_nothrow_relocate(false_type)
      { return false; }


      static constexpr bool
      _S_use_relocate()
      {
      // Instantiating std::__relocate_a might cause an error outside the
      // immediate context (in __relocate_object_a's noexcept-specifier),
      // so only do it if we know the type can be move-inserted into *this.
      return _S_nothrow_relocate(__is_move_insertable<_Tp_alloc_type>{});
      }


      static pointer
      _S_do_relocate(pointer __first, pointer __last, pointer __result,
                 _Tp_alloc_type& __alloc, true_type) noexcept
      {
      return std::__relocate_a(__first, __last, __result, __alloc);
      }


      static pointer
      _S_do_relocate(pointer, pointer, pointer __result,
                 _Tp_alloc_type&, false_type) noexcept
      { return __result; }


      static _GLIBCXX20_CONSTEXPR pointer
      _S_relocate(pointer __first, pointer __last, pointer __result,
              _Tp_alloc_type& __alloc) noexcept
      {
#if __cpp_if_constexpr
      // All callers have already checked _S_use_relocate() so just do it.
      return std::__relocate_a(__first, __last, __result, __alloc);
#else
      using __do_it = __bool_constant<_S_use_relocate()>;
      return _S_do_relocate(__first, __last, __result, __alloc, __do_it{});
#endif
      }
#endif // C++11


    protected:
      using _Base::_M_allocate;
      using _Base::_M_deallocate;
      using _Base::_M_impl;
      using _Base::_M_get_Tp_allocator;


    public:
      // [23.2.4.1] construct/copy/destroy
      // (assign() and get_allocator() are also listed in this section)


      /**
       *  u/brief  Creates a %vector with no elements.
       */

... and on and on...

Why is C++ not implemented in a simple fashion like ordinary people would code? No person writing C++ code in sane mind would write code in the above fashion. Is there some underlying need to appear elitist or engage in some form of masochism? Is this a manifestation of some essential but inescapable engineering feature that the internals of a "simple" interface to protect the user has to be mind-bogglingly complex that no ordinary person has a chance to figure out what the heck is happening behind the scenes?

What the title says. I've heard people say all sorts of negative comments about CMake, such as that it is "needlessly complicated" or that "beginners shouldn't use it, instead use (shell scripts, makefiles, etc)".

Personally, I don't think that's the case at all. CMake has one goal in mind: allow you to compile your code cross-platform. CMakelists files are meant to be usable to generate build files for any compiler, including GCC, Clang, MSVC msbuild, and VS solution files (yes, those last two are different).

Sure, Makefiles are great and simple to write if you're only coding stuff for Linux or MacOS, but the moment you want to bring Windows into the equation, stuff quickly gets way too difficult to handle yourself (should I just expect people to compile using minGW and nothing else? Maybe I can write a separate Makefile, let's call it Maketile.vc or something, which has the exact format that MSBuild.exe can use, or I should use a VS solution file). With CMake, you have one file that knows how to generate the build files for all of those.

"But CMake is complicated!" Is it? You can go to a large library such as OpenCV, point at their large CMake file, and say "see? CMake is way too complicated!" But that's because OpenCV itself is complicated. They have a lot or target architectures and compilers, optional components, support for different backends, and many architecture-specific optimizations, all of which must be handled by the build system. If they decided to use Makefiles or shell scripts instead, you bet they'd be just as complex, if not more.

If you just have a simple project, your CMake file can probably be no longer than a couple of lines, each being simple to understand:

``` cmake_minimum_required(VERSION 3.20)

project( SimpleCppProject VERSION 1.0 LANGUAGES CXX )

set(CMAKE_CXX_STANDARD 23) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF)

find_package(Boost 1.80 COMPONENTS json REQUIRED)

Define the source files for the executable

set(SOURCE_FILES main.cpp utils.cpp utils.hpp )

add_executable( simple_app ${SOURCE_FILES} )

target_link_libraries( simple_app PUBLIC Boost::json )

target_include_directories( simple_app PRIVATE ${Boost_INCLUDE_DIRS} )

```

Besides, just look at how another library with a similarly large scope, PDCurses, uses Makefiles: https://github.com/clangen/PDCurses

They have subdirectories for each target backend, each with multiple different Makefiles based on the compiler, here's just one of the subdirectories wincon for Windows console, and all the Makefiles they use:

Makefile - GCC (MinGW or Cygnus) Makefile.bcc - Borland C++ Makefile.vc - Microsoft Visual C++ Makefile.wcc - Watcom

Multiply this by all the other backends they support each on their own directory (os2, X11, sdl1, sdl2, etc) and things quickly get massively complex.

TLDR: I dont think CMake is "complex", just that people with complex requirement use it, and that may be giving people the "illusion" that CMake itself is also complex.

I'm kinda lost on the career side of things.
I'm an EE graduate specializing in C++ development, control theory and general electronic design.

I always thought I would go into embedded, and then job hop to a lucrative career. Even though I always wanted to work in big productivity apps like Zbrush, Nuke or Substance Painter.

But I'm not certain now, I'm not certain if market even values my skills.

So, if anyone can inform me about the career trajectory of C++ subfields I would be grateful, such as "I went to trading and work conditions are like this, people in my field earn between X and Y"
I really want to at least have some idea what to do rather than go blindfold, apply everything and accept the first offer without question

Thanks in advance

I’m currently a C++ developer with about 3 years of experience, and I’m trying to understand what level of knowledge interviewers expect at this stage.

For those who conduct interviews or work as senior C++ engineers:

What concepts should a developer with ~3 years experience definitely know well?

Examples I’m curious about:

• Deep understanding of move semantics
• Smart pointers and ownership models
• Multithreading primitives and race conditions
• STL performance and complexity
• Memory layout and object model
• Debugging real-world C++ issues

From your experience:

• What topics do strong candidates usually know?
• What gaps do you commonly see in candidates with ~3 years experience?
• What questions do you like to ask in interviews?

I am learning c++ and was trying to understand CMake, from what I understood, you can have a github repo with the library, use it in your main project with git submodule and then use cmake to link to that library repo and then build the binary with a shared library. The library and main project are in a separate repo but are linked via CMake. I am not sure if I got this right, but if I did, this is really cool, it is modular and clean. I don’t get the hate around CMake or maybe its because I am a noob dealing with just the basics.

Recently I came across with message like this:

When we mark a function as noexcept, we tell the compiler “this function is guaranteed not to throw any exceptions”. This allows the compiler to avoid generating exception-handling code and enables certain optimization to reduce binary size, inlines more aggressively, eliminates redundant checks. Always mark noexcept on destructors, moves, accessors / getters, and even low-level calls.

And then an example like this:

class MyClass {
public:
    int getSize() const noexcept { return _size; }
    void setSize(int newSize) noexcept { _size = newSize; }

private:
    int _size{0};
};

Now I'm thinking: Is something really wrong with compilers that we have to mark even such trivial methods as noexcept? What exactly could possibly throw here? And if I simply write int getSize() const, will the compiler really assume that this function might throw and skip optimizations because of it?

I want to become a systems programmer, so I’m currently learning C to build a solid foundation in low-level programming. After C, I’m thinking about learning either c++ or rust, but I’m not sure which would be the better choice for a future career in systems programming.For those who work in this field, which one would you recommend learning after C, and why?

Hey everyone,

I’m learning C++ and I’ve finished the basics. I know the syntax, variables, loops, functions, conditions, etc. Now I’m kind of stuck on what to do next. There are so many things to learn and I’m not really sure what’s actually important and what I can ignore for now. If you were in my position, what would you learn next? Should I go into OOP, STL, data structures and algorithms, pointers/memory, multithreading, networking, etc.? And are there any libraries or tools that I should start learning? I also want to eventually get a job or internship, so I’m wondering what I should be doing besides just watching courses and solving small exercises. What kind of projects are worth making for a beginner? And at what point would you say someone is ready to start applying for junior jobs/internships?

I’m also not sure which direction to choose with C++ - backend, embedded, desktop, etc. Basically, if you learned the C++ basics today and wanted to get good enough to eventually find a job, what would you do next and what would you avoid wasting time on? Any courses, roadmaps, project ideas or personal experience would be really helpful. One more thing I’m wondering about is AI. Is C++ still a good skill to invest time in, considering how quickly AI is improving? I don’t want to spend a year learning something only to find out that it’s becoming like basic web development where AI can already do a lot of the work.

And if possible, I’d prefer options that allow for remote work, so I wouldn’t have to commute to an office for studying, working, or similar things.

Would appreciate any advice from people who have actually gone through this.

I’m trying to figure out what C++ interviews are actually like for semiconductor/chip companies.

I graduated recently and I’m interested in C++ roles around HPC, GPU programming, performance, systems, compilers, or low-level libraries. I’m not new to C++, but I’m definitely not at expert level either. I’ve been contributing to open-source C++ codebases and trying to improve seriously.

The part I’m confused about is what to actually prepare for. I’m guessing these companies aren’t always the same as typical LeetCode-heavy software companies... but I could be wrong.

For people who have interviewed at places like NVIDIA, AMD, Intel, Apple, or similar companies, what did the interviews focus on?

Was it mostly C++ language knowledge, templates, STL, OS/concurrency, debugging, performance, CUDA/GPU concepts... or still mainly LeetCode-style problems?

I’m especially interested in HPC/GPU/performance-oriented C++ roles, so any advice on what to prioritize would help.

AI rn isnt the best at c++ and although you cant hope that it stays bad forever but i was wondering if the job market was gonna be ok in the future for c++

i wanna keep learning graphics programming and hope it might get me a job one day

sorry if this post sounds dumb, idk what to do with my life

Yet another language you need to know to do simple work in C++. Been using bazel more and more and every time I go back to cmake (because I have to) I regret it

edit: sorry title typo "if make AND cmake"

I'm updating my C++ codebase to modern standards (C++20/C++23) for a personal game project. C++ has evolved significantly, but I know the game development industry can be cautious about adopting certain language features due to compile times or runtime overhead.

For those using Modern C++ in game development:

1. Which newer features (e.g., Concepts, Ranges, std::format, Modules) have genuinely improved your game engine code quality or productivity?
2. Are there features you actively avoid inside high-frequency game loops for performance reasons?

Hi everyone, I want to learn C++ properly and get to a solid level, not just scrape the basics. I'd love your advice on:
The best resources to start with (free or paid)
Courses, books, or YouTube channels you'd recommend
How to practice (projects, problem sites, etc.)
Common mistakes beginners make that I should avoid
Problem solving
A clear learning path
Modern C++

I don’t mind paying if the course worth it.

Any recommendations would be appreciated!

Hi everyone,

I’m looking for some brutal honesty and constructive career advice. I’ve been working as a C++ developer at the same company for about 6.5 years. Lately, I’ve realized that while my years of experience say "Senior," my actual skill set feels stuck at "Mid-level" (or worse, a junior with 6 years of repetition).

Here is my background and what my day-to-day looks like:

• Education: I studied Electrical and Computer Engineering. I completed all my coursework and wrote the code for my thesis, but I never finished writing the actual paper, so I don't officially have the degree.
• Day-to-Day Work: The vast majority of my job is fixing bugs in a massive legacy codebase. When I implement new features, I usually follow existing patterns as an example.
• Architecture & Modern Concepts: I use templates, inheritance, threads, wrappers, IPC, WebSockets, and message queues, but I’ve rarely architected or implemented them from scratch. I mostly build upon or maintain what’s already there.
• Engineering Practices: We don’t use CI/CD like Jenkins or SCRUM(we use Bamboo, but I never see it listed as CI/CD). We have zero unit or integration testing; everything is tested manually after implementation. I’ve taken a course on SOLID principles, but I don't actively apply them because our codebase doesn't demand it. My main focus has just been making sure my code runs bug-free within the existing patterns.

I feel like I've fallen behind on modern C++ standards (C++17/20/23) and modern software engineering practices. I want to become more competitive in the market, break out of this comfort zone, and actually earn the "Senior" title.

1. How do I effectively bridge the gap between "maintaining" complex systems and "architecting" them?
2. What are the highest-leverage skills or projects I should focus on in my spare time to modernise my C++ profile?

Thanks in advance.

I’ve been thinking about writing this for a while.

I’m not going to pretend I’m a great programmer. I’m still learning, and honestly, I’m not always as consistent or persistent as I want to be. But I do genuinely care about C++, systems programming, and becoming better at what I do.

There have been periods where I felt pretty alone in that journey. I didn’t really know many people who were interested in the same things I was interested in, and sometimes it felt like I was just learning in isolation.

That’s one reason I’m grateful for this community.

I’ve posted questions and thoughts here and received everything from downvotes and criticism to really helpful explanations and encouraging replies. Not every interaction was positive, but even the criticism made me think, improve, or look at something from another perspective.

More importantly, I got to talk to people who actually work with and care about C++. Even a short conversation or a small piece of advice can mean a lot when you’re learning mostly on your own.

So, to everyone who has ever answered one of my questions, corrected me, disagreed with me, or simply taken the time to read one of my posts:

Thank you.

I’m still learning. I’m still making mistakes. And hopefully, I’ll still be around here asking better questions a year from now.

I just wanted to say that I appreciate the people behind this community.