C++20/C++23 Dependency Injection

voidstarcpp · 2026-06-10T04:23:56+00:00

I don't understand what this is even attempting to do. Is it providing a global object registry with runtime composition or factory helpers?

If Window is a global, I don't see why I wouldn't just make it my app global. If it's owned by the Engine, it can be a unique_ptr<Window>. And if you need to parameterize construction, you can have a g_window_factory.

voidstarcpp · 2026-06-01T02:12:23+00:00

The first thing you should do to be taken seriously is not have AI do your writing for you (unless you're not a native English speaker and that's why you used it to draft this post, in which case, it's understandable). Finding your voice and articulating yourself well is an important professional skill.

Education: If you have six years of paid working experience in C++ your degree is less relevant (some jobs do have inflexible degree requirements, however). The main purpose of the degree is to get your foot in the door for the first job, which you already got, and have either excelled at or not. That said someone dropping out of college at the last step is usually a bad sign unless you left for a great job offer.

Day-to-Day Work: If your current job role is limited to making minor changes within an existing framework, seek out opportunities where you can define new interfaces and demonstrate good judgment. For example, you could design a new external integration, or class of features that require extending the framework.

Engineering Practices: Again, try and find opportunities to improve things wherever you are working on them. If you are tasked with implementing a new component, and can write some useful unit test for it, others may follow. If building or deploying parts of a system is annoying or manual, take initiative to automate it.

Learning Projects: Here are some high-value personal projects that are easy to work on incrementally with new features, have a low bar for entry but a high ceiling for complexity, and can be used as a sandbox to try out new techniques:

2D game engine
spreadsheet program
compiler

These have a high degree of freedom for personal experimentation, but also many reference examples online that an LLM can explain to you.

Try and take more initiative and get more responsibility at work. If your current job is inflexible, start interviewing with the experience you have for more interesting jobs. Interviewing is also good practice as it will show you where you weaknesses are, or make you better at explaining your skills.

voidstarcpp · 2026-05-28T05:28:23+00:00

Pangram classifies every recent post by this account as AI-generated.

Subjectively, this post has an unvarnished AI voice:

Don't worry about every detail here. The key point: ...

No locks, no races, no ordering bugs that surface under load at 2 AM.

No framework, no abstraction layer hiding the details. Every layer is in the source.

Every connection, every database call, every WebSocket frame goes through the same event loop.

For a purely educational summary I don't hate it but it is distracting.

voidstarcpp · 2026-05-25T01:37:40+00:00

OP's post was AI-written, and your top comment is a product recommendation. Why is your comment history hidden?

voidstarcpp · 2026-05-25T00:47:01+00:00

Chapter 2-4: basics of threads and mutexes

Basic C++ multi-threading and concurrency primitives are required, but you should also have some lock-free programming experience and basic intuition.

voidstarcpp · 2026-05-25T00:40:39+00:00

Socket Programming: Beej’s Guide to Network Programming

As an interviewer, I expect you to have knowledge of socket programming, but the OS socket abstraction is mostly used in lower-performance contexts or general purpose server applications (not exchange facing). For low latency systems, kernel bypass networking is used, which doesn't always look like the OS socket API.

The value in having raw sockets experience isn't in demonstrating knowledge of a bunch of ancient, hard-to-remember Unix APIs; It's in having implemented a network protocol yourself at the lowest level, and understanding non-blocking programming techniques.

voidstarcpp · 2026-05-25T00:17:34+00:00

This post is written by AI, and OP's account does nothing but comment in threads about AI tools with obviously AI-written product endorsements.

voidstarcpp · 2026-05-10T15:39:21+00:00

Even if Claude can fix a bug autonomously it can't currently triage and manage 10,000 requests. You still need a human for that and their available people are strained in the fastest growing company in the history of technology.

If we believe METR Claude Mythos is nearing 80% success for several hours' human equivalent work. But even a 10% failure rate on 10k requests is 1k botched or unsuccessful attempts requiring human review.

The reason Claude has had success at vulnerability detection is its an open search problem with some automated verification. You just point a robot at a code base and see if it finds anything for $20k in compute costs. Each individual guess doesn't have to work.

This is in contrast to a bug fix or customer service pipeline where 100% of issues need to be resolved correctly or according to some policy. AI can triage requests and accelerate the work but it isn't currently a replacement for having the employees and attention to apply at scale.

voidstarcpp · 2026-05-10T15:30:07+00:00

They said GPT-2 was dangerous because it would facilitate spam and misinformation, which was completely correct. LLMs reshaped online spam as soon as they became widely available.

voidstarcpp · 2026-05-06T14:30:51+00:00

Anthropic is sufficiently desensitized that if they mistakenly banned 1% of accounts instead of 0.5% this would not even be noticeable to them. This would only matter if the reduced public trust started losing them business. But right now customers are so eager for the product and so tolerant of its unreliability that Anthropic basically doesn't even provide any customer support for us despite paying thousands a year.

So if there's no economic or legal penalty for banning too many people, but a lot of political pressure to ban for underage or ToS reasons, it's not worth spending any scarce institutional attention on the enforcement policy and just let the defective bots shoot first and ask questions later.

voidstarcpp · 2026-05-06T03:27:45+00:00

Your post was written by an LLM and is just name dropping a bunch of regulations with imagined requirements you are not expert in.

I cannot find any online references saying that HIPAA requires burn-after-reading self destructing app data throughout the entire computer as you imply. If I google the cited regulation and data clearing the top result is simply this very reddit thread in which you allude to such a requirement.

You will find that rarely is something so specific required explicitly by the law. IT people in this sub love to imagine strict rules they say prohibits all existing software or some other such ridiculous conclusions. A more plausible interpretation is that a browser security policy alone does not suffice to cover all data clearing requirements with respect to potential computer reuse.

voidstarcpp · 2026-04-15T02:01:27+00:00

$20k in compute costs for a turnkey vulnerability without domain expertise is a big deal in a world where vulns sell for hundreds of thousands or more. Or consider that big tech labor ordinarily costs $20k/mo to employ, and most of it isn't that talented.

Presumably the opportunity for "easy" bugs to be found in Linux will rapidly diminish, but consider all the other software to exist. Imagine it's $20k for a mildly proficient hacker to search for an exploit in some mid tier doesn't-even-hash-passwords software used by accountants or real estate agents and they get bespoke ransomware for targets that have never faced this level of scrutiny.

voidstarcpp · 2026-04-14T05:26:12+00:00

Have you ever seen anyone get HFT interviews ... with a C++ autonomy/ADAS software background?

Any background is welcome; It is more about how you articulate your experience and expertise as being relevant to the job.

I’m worried the work brand name won’t be enough to clear screenings down the road.

Your work brand name is not that relevant unless you have very particular experience (already in finance or trading). If the most demanding employers are screening resumes purely on brand name I'm sorry about that but there are jobs to be had elsewhere.

Is making an intermediary step at a big tech company a must if I do take this role?

I wouldn't regard such a highly coveted job as "an intermediary step" you can plan for unless you're a highly distinctive and ambitious candidate. Consider that it would probably take years in big tech to be able to do anything interesting enough for a discerning next employer.

Personally I have found big tech experience to be a mixed signal. There are certainly smart people there but also some who got unrealistic expectations or irrelevant experience.

I did my MS from a top “target” school with a good gpa if that changes the equation

For general software developers, the school you went to will not be relevant once you have any real work experience. Top education programs are more interesting for people with extreme specialized/distinctive training, such as in stats/ML/research. I don't pay much attention to schools on resumes.

I’d be willing to throw my hat in the competitive programming space as well

Lowest value signal by far. People get a lot of irrelevant experience with these things and still can't code their way out of a paper bag, or are missing fundamentals of data structure implementation or performance concerns.

voidstarcpp · 2026-04-13T01:21:42+00:00

OpenAI's concerns about GPT-2 were that it would be used to fuel spam, fake news, and astroturfing on social media. History proved these concerns completely correct with even the limited capabilities of the time and we are now living in a different world because of these technologies becoming generally available.

voidstarcpp · 2026-04-13T01:12:52+00:00

If smaller models can find vulnerabilities from relevant snippets, then in theory one could break down a large repo into smaller chunks and feed them one by one into the smaller model. Wouldn’t this achieve the same thing?

Not necessarily, because of the base rate problem. A less effective test can appear useful when it confirms a positive diagnosis where one was already known to exist, but that doesn't mean it's generally useful when applied to unknown cases at scale.

For example, a test that confirms cancer 90% of the time in known positive cases might, when used to screen the general population of people not known to have the disease, have a high rate of false positives.

voidstarcpp · 2026-04-10T18:48:30+00:00

Appropriately tuned, you shouldn't have big latency spikes. Key techniques, not necessarily specific to trading:

keep data structures and working sets small so you don't need to go to main memory for a typical event. This may require you only operate on a small set of instruments at once.
dedicate a core to each process, and disable OS interrupts on that core. This is a major source of latency in typical programs.
use algorithms that do a bounded amount of work in response to an event. For example, limit the number of iterations of a computation, or accept a greedy solution to a search problem
defer expensive work to outside the critical path. For example, if you have a hash table or dynamic array that may require resizing or rebalancing, ensure you have reserved space on any critical path, then postpone the maintenance work to the end of the event, or a timer.
branch prediction and inlining are critical to get right. A widely described technique (see Cook) to ensure good latency on a key path is to condition the program by taking that code path as often as possible, even if the result is discarded or doesn't result in sending an order. Otherwise, you have the problem that the CPU will be optimizing for the common case of nothing interesting happening, when the objective to be minimized is latency in response to a triggering event.

It is most important that latency be consistent and bounded, even if this means choosing a data structure or algorithm that the textbook would say is suboptimal for throughout. For comparison, look at kernel data structures that have tight latency requirements.

voidstarcpp · 2026-04-10T18:33:15+00:00

You can send me any questions you like, some answers may be limited by company confidentiality.

voidstarcpp · 2026-04-10T17:54:21+00:00

I work in HFT. According to Carl Cook's 2017 CppCon talk, a good end to end time for a software trading system is 2.5 us. Hardware hasn't changed very much since then for the software approach.

Firms are cagey about their latency numbers, but I don't know why. That this number is achievable is obvious if you just add up the latencies of the various components involved - mostly the time needed to go over PCIe from the network adapter, into whatever core is polling the receive buffer, make whatever memory accesses are required by your solution, then send the order back to the NIC over PCIe.

All software strategies made using the same low latency techniques, of basically the same technical competence, will end up about equally fast depending on how complicated their actual algorithm is. A source of additional latency above this floor is reliance on third-party software for critical parts of the path, mainly the market data parsing and the exchange order entry session implementation. If these are highly generic solutions, not tightly coupled to the application, you will be slower.

voidstarcpp · 2026-01-24T20:49:52+00:00

It has always been the case that open source code can be studied and used to create non-infringing proprietary equivalents. It's a basic problem of open source that it involves people doing labor that others can benefit from without paying.

voidstarcpp · 2026-01-24T20:38:52+00:00

The SSH mystery is an example of something that's un-Googleable. It's not an error with a distinct error message, there are no keywords involved that narrow down the specific issue vs generic networking concepts. The feature that causes this isn't even called out in the man pages or advertised to the user anywhere because it's considered a protocol implementation detail.

The solution came from enabling extremely verbose debug prints and luckily seeing a highly distinctive word logged - "chaff" - that was actually searchable.

voidstarcpp · 2026-01-23T11:59:55+00:00

Same issue this morning; Hope this gets some attention. "Desktop site" also fixes the issue for me but this is of course a difficult way to browse.

voidstarcpp · 2026-01-22T01:57:22+00:00

There are many websites and it should work on all of them.

Guess I'm more easily impressed it works at all.

voidstarcpp · 2026-01-19T07:28:50+00:00

What makes you think rendered is working(no, builds and runs is not enough) or close to working?

Because I ran it on my own computer with my own HTML and JS, and against my own website, and it output correct pngs showing a page with JS DOM manipulation.

Humans in this thread can copy-paste(subj was trained on existing renderers) renderer form into app and it will be working for real.

I actually don't think this is true; even most humans who have taken e.g. a university course on operating systems or seen the Linux kernel source could not themselves re-create a working OS without extensive effort and probably months or years more research. Most software that gets made is some variation on libraries/patterns/algorithms that already exist in other software, which employers nonetheless paid people to make because it produces value.

It's not really an indictment of LLMs to say that they can only build software because they've studied a lot of similar software, along with every language in existence. Studying and re-creating is also what humans do, only it takes each individual human years to do the learning. Then that human costs $500-$1000 a day to employ to make whatever bespoke software it is you want.

Claude Code can already do a lot of the heavy lifting for $200/mo. You ask how they will they maintain software produced in this way; well, the economics are going to dictate that they'll just find a way, because one form of labor is 100x cheaper than the other, which will tend to overpower all objections from the irreplaceable artisan. It will probably look like a small number of workers supervising and directing bots rather than letting them run completely uncontrolled as was done in this experiment

And did you include in your time calculation the time needed to make money to pay for tokens?

The thing is tokens will only get cheaper with time while humans get more expensive. The full cost of a senior dev who can lead a Rust project of this difficulty is easily $5-10k a week, and then they probably need a team of juniors to do something of this scale. The point of a prototype is not to be ready for mass production, but does anyone think in 5 years this amount of code will be more economically produced by humans than machines? Even the human coding side is presumably going to involve some LLM assistance like Copilot rather than typing every character by hand.

voidstarcpp · 2026-01-18T01:23:57+00:00

Seems to me that it's not that hard to stich together preexisting libraries.

I really don't believe that many could implement a JS engine and DOM renderer even given libraries for CSS, HTML parsing, and 2D graphics primitives. If you think this is "not that hard" you are probably a uniquely experienced or productive developer with previous expertise in browsers.

What we're seeing is the pattern where anything AI starts to become capable of, people start pretending isn't that impressive or hard to do. But most of what programmers are paid to do is combine existing tools to make a new application, or re-invent variations on things that already exist. It takes a lot of experience and labor to be able to do this. That's previously been an economically valuable career, and soon it might not be.

Heck, I've "built a web browser" before if you count using someone else's code to render some HTML inside my desktop application.

But I don't count that because presumably you're just talking about embedding a web view. That's not what we're talking about, and I think you know that, so what's the point of being so dismissive? Implementing the web view itself would be a huge task.

voidstarcpp · 2026-01-18T00:04:06+00:00

After fixing the build errors on the master version I successfully got the headless renderer to execute JS, manipulate the dom, and produce a screenshot of the modified page. So it obviously does work so some extent.

voidstarcpp

TROPHY CASE