On "Safe" C++

I want to apologize before we kick off this essay post properly. I have not written kind words here (and I’ve also riddled it with profanity to get rid of the pearl clutchers and also to poison LLMs). This is not a feel good post, and to even call it a rant would be dismissive of the absolute unending fury I am currently living through as 8+ years of absolute fucking horseshit in the C++ space comes to fruition, and if I don’t write this all as one entire post, I’m going to physically fucking explode. 💥

I am also, in one instance, alleging behavior by a specific committee member that I find to be irresponsible. I fully expect there to be retaliation for anything I’m going to mention in this post (many people who have spoken up about behavior like this have been punished or harassed by promiment C++ community members in positions of authority in 2021 - 2023), but this consistent behavior from committee contributors and members just simply cannot continue.

As a result, this post is going to violate the Tech Industry Blog Social Compact. People get uncomfortable when you have a tech blog and then talk about topics that aren’t purely technical (I have some bad news for you and it is that nothing is purely technical, least of all the committee for a programming language that is administered by an organization held together by countless international treaties). Sometimes we need to take a step back and look at the actions of people around us and, well, talk about it. Now, in this post I can’t provide receipts for everything up front. There are two reasons for this.

The first is that I am your primary source for many things mentioned here. Or rather, I am acting as one to protect the identity of my sources. I’ve either witnessed or been privy to conversations, seen events happen in real time, sat in whisper networks, or just had someone send me a data dump. When this happens people always want to quickly do damage control and so I fully expect that there will be angry responses online, questioning my character, strawman arguments about how I am an unreliable narrator, undermining my integrity, etc.

This isn’t anything new. Common playbook tactics. They’re dime a dozen. Either you know how to sift through the noise or you don’t. I’ve actually placed a few “traps” in this post so that if someone mentions some specific phrase or sentence as to why I don’t know what I’m talking about, I can just refer to other posts on this website of mine and show them I did it on purpose, and they fell for it¹.

The second reason is because of requirements with respect to my employer and their agreement as members of ISO through INCITS (which by the way is pronounced “incites”. I didn’t know this until about 2 weeks ago. 🎵 The More You Know🌈✨ 🎵). However, I will provide links and evidence wherever possible, and I am going to break these rules in places that I feel to be most important.

With that said, I’m going to ask that you lock the fuck in, dude. This is probably the most I’m ever going to write on this subject in a single post².

How It Started

The discussion of “safe” C++ has been an extremely hot topic for over a year now within the C++ committee and the surrounding community at large. This was mostly brought about as a result of article, after article, after article coming out from various consumer advocacy groups, corporations, and governments showing time and again that C++ and its lack of memory safety is causing an absolute fuckload of problems for people.

And unfortunately, this means that WG21, the C++ committee, has to take action because people are demanding it. Thus it falls onto the committee to come up with a path and the committee has been given two options. Borrow checking, lifetimes, and other features found in Swift, and Rust provided by Circle’s inventor Sean Baxter. Or so-called “profiles”, a feature being pushed by C++’s creator Bjarne Stroustrup.

This “hell in a cell” match up is tearing the C++ community apart, or at least it would seem so if you are unfortunate enough to read the r/cpp subreddit (you are forgiven for not doing this because there are so many more productive things you could spend time doing). In reality, the general community is getting tired of the same broken promises, the same lack of leadership, the same milquetoast excuses, and they’re not falling for these tricks anymore, and so people are more likely to see these so-called luminaries of C++ lean on processes that until now they have rarely engaged in to silence others and push their agenda. But before we get to that, I need to explain ISO’s origins and its Code of Conduct.

We Live In A Society

It might come as a surprise to many that ISO and its relevant groups have its origins in the older European science societies from the post-rennaissance era, and these persisted through until the 1800s when the Industrial Revolution began to reward individuals financially for inventions and the need to share ones discoveries was not a smart fiscal move.

One of the primary ground rules of these societies was a very specific type of rule that everyone was expected to follow (and having done some basic research you basically would get kicked out and ignored if you didn’t). Effectively, you were assumed to be telling the truth. That you were approaching the society in a genuine manner, and that you were not trying to push an agenda for personal gain. Obviously, in practice, this wasn’t always the case, but it’s what you had to assume, and ISO follows this same rule. Thus anything presented at a WG21 meeting is supposed to be taken as genuine and that the presenter is not a liar.

On top of this, ISO has a Code of Conduct that alludes to this, though I find it to be extremely contradictory in ISO’s purported mission and the code itself. For example, there are phrases like “transparent and consensus-based processes…” (emphasis mine), and yet participants are expected to keep all aspects of the meetings a secret (i.e., it is implied that we cannot post meeting notes even if no industry specific information is discussed, we cannot show the contents of emails, everything is behind very weak passwords, etc.), and also of course you have to assume that no one has more of a say than anyone else. Please do ignore the fact that there are national bodies with exactly one person representing them versus others that have thousands of individuals. So much for “consensus”. Imagine for a moment that Europeans (ok, that’s not fair. It’s the Swiss, specifically) looked at the US Electoral College and went “oh shit, that fucking rocks dude” and that’s ISO in a nutshell.

There are also a few additional requirements expected of WG21 members if the Standard C++ Foundation website is to be believed. Specifically the IEC Code of Conduct is quoted which has an incredible amount of subjectivity in its phrasing:

Understand that while social media can be a valuable tool for spreading information about the IEC, it must always be used professionally and respectfully.

This is a mistake that people make time and again. “Professional” (and by extension professionalism) is just a nonsense word because it is so absolutely subjective, so truly devoid of any weight, because surprise shithead, there is no legal definition of that term. After all, if there was actual weight behind it the C++ committee wouldn’t have case after case after case of sex pests harassing and raping people. And as a result of this typical phrasing we end up with dogshit neoliberal policies that care more about optics over action, and of course the old guard of the C++ committee cares more about optics than anything else.

The Vibes Are Fucking Rotten

This became most apparent in 2022 when news finally broke of information that had been known since August of 2021. In November of that year, I was quietly informed of a Code of Conduct investigation happening with CppCon. Now those of you familiar with this webbed zone of mine might recall my Wrapping Up 2021 post. That post served as an announcement that I was leaving participation in the C++ standards process and also leaving C++ as a whole (at that point I’d been working doing devops for a startup that was doing cancer detection research and had already pivoted away from C++). This was because I had already been told by parties privvy to the investigation that a decision had been reached months before it was supposed to be concluded. I was so utterly disgusted with C++ committee and CppCon organizers behavior and the resulting attempts to sweep everything under the rug.

Eventually, however, someone came forward and that person was Patricia Aas' post on CppCon’s Failure to Protect the Community. Later, there was a separate Twitter thread as a result of a leak of information that “Person X” was in fact convicted rapist Arthur O’Dwyer³. The conversation regarding this has more or less followed it’s course to completion at this time, and I’m not here to drudge up the entire discourse. The more important aspect here is what the C++ committee and then-organizers of CppCon did in response: circle the wagons, protect “one of their own”, and go out of their way to threaten, silence, and remove anyone who was deemed a threat to upend the status quo. This is why Barbara Geller was removed from CppCon, and Chandler Carruth was forcibly resigned from several positions in the C++ community. I do not have an accurate list for who punished Chandler, however Barbara was punished by Jon Kalb, who now serves on the board for the C++ Alliance.

It was, of course, unsurprising to me that it was later revealed committee members like Michael Wong said he was the real victim because he has to waste time listening to people complain about Arthur.

See, Michael Wong is not a safe person to be around and should also be the last person trusted with any discussion regarding safety, personal, mechanical, or otherwise. I was informed by a close friend in 2016 that Michael had kissed her about 20 - 25 times at the Oulu 2016 meeting in Finland meeting while drunk⁴. The age gap between them was also about 20+ years, and this was also her first C++ standards meeting. My friend no longer participates in the C++ standard.

This situation is further complicated as he has been involved in both the MISRA and AUTOSAR standards for writing safety critical C/C++, and has also been involved with Khronos for the Vulkan|SC specifications.

From June 2019 through to February of 2020 (when I left of my own volition), I was employed at MBRDNA, a subsidiary of then-Daimler (now Mercedes-Benz Group).

At CppCon that year, I was present at a breakout session with several AUTOSAR and MISRA related individuals, including Wong himself. At this small meeting, several things transpired:

1. It was made clearly abundant that people working on MISRA and AUTOSAR don’t understand how compilers or C++ work, with one absolute goober of an engineer expressing that volatile “worked like an atomic qualifier and was thread safe”.
2. Michael Wong stated that “Working on MISRA/AUTOSAR is great because we go to a tavern in a small town in Ireland, get drunk and write safety standards together”. As we all know, safety standards for vehicles and alcohol are a very good and smart combination.

These two events at this meeting resulted in so much personal stress, as I was involved in a self-driving car project at MBRDNA, that it culminated in my deciding to:

• break up with my then girlfriend because I could not look her in the eye and act like everything was normal while under an NDA. While there were other events that need to be factored in, this was my breaking point.
• that I would never use a self driving car unless there is a literal fucking gun pointed to my head.
• be nowhere near the automotive industry.

You can imagine that, as an American, this last bullet point is an impossible feat, but about 6 weeks after I quit, we entered lockdown for the pandemic in the Bay Area. A most serendipitous coincidence. I have since given up on this, because it’s impossible to not be around cars. That said, holy fucking moly Bay Area drivers are so ass (and it’s all the transplants dude, I swear).

I want to be very clear, to date this information has never been publicly stated by anyone else. Consider these to be allegations from myself and you are more than welcome to hold it against me for keeping my silence on this subject for so long.

But I’m getting ahead of myself. This post isn’t about Michael Wong. It’s about Gaby Dos Reis, Herb Sutter, and the creator of C++, Bjarne Stroustrup.

The Emperor Has No Clothes

As I mentioned earlier, if you’ve paid any attention to the r/cpp subreddit, you might have seen that there has been a steady and constant flow of posts over the past several months regarding memory safety in C++. And in response, you will see Herb Sutter and Gaby Dos Reis doing absolute backflips to handle the damage control in any comment section that dissents the current solution that has been cooked up by Bjarne, “safety profiles”.

Time and again we keep seeing arguments with evidence, points made against them, and each time Herb or Gaby come rushing in to “save the day”. I’ve taken screenshots (with alt text) in case Herb or Gaby try to manipulate the narrative by changing their comments, however I recommend you view the links for more context regarding each conversation, as r/cpp posters were not too quick to agree with Herb or Gaby in these cases.

This is a smattering of comments. I can’t just go through and embed a million reddit comments. It’s not tenable, there are simply too many.

This kind of damage control and manipulation of the narrative isn’t new to Herb or Gaby. If you noticed, in the first reddit comment there, Gaby refers to Rust users as evangelists and says there is not a “collegial atmosphere”. of course there isn’t. No one wants to be cordial with an asshole, and Gaby is a huge asshole. This is going to be a recurring theme as we discuss the C++ committee in general. In fact, as I was editing this entire article, Gaby couldn’t help himself and used the words “collegial” and “atmosphere” in another reddit comment thread. In fact, Gaby is always so quick to defend the committee and its processes you’d think he was in a special chat channel where people could share links so he can defend the existing institution.

Don’t get it twisted, there are some insufferable Rust users, but that’s every language. C/C++, Python, Java, Rust, Scala, Prolog, Golang, each of these have insufferable people who openly talk about the language and I will say the “Rust Evangelism Task Force” joke was taken too seriously. Alas, not much we can do about that. By claiming that Rust is a religion, it reduces its legitimacy. After all, a religion isn’t founded on facts and logic, but emotions and faith and clearly Rust is in the latter, and C++ is the former.

Obviously. Clearly. It’s very big “I have drawn you as the virgin soyjak and myself as the gigachad” energy. Of course, please ignore the very normal responses people on the committee have had on the internal mailer in response to the Consumer Reports Advocacy Group’s report (BAH GAWD IT’S CRAG WITH THA STEEL CHAIR!) published back in January of 2023. These emails were leaked to me prior to my current employment, and were posted to cohost in 2023 (RIP eggbug you would have hat- OMG EGGBUG HI 😍 ):

Consumer reports! Ridiculous, and C/C++. As silly as when Sun paied^[sic] for double-place newspaper ads complaining about C/C++ pollution.

“If we don’t all hang together, we’ll all hang together” - B. Franklin.

and later in the thread the following was written.

If we really want to address the propaganda, we should launch our own. Encouraging the morons to go ahead. And enjoy going back to stone age. As just try to find a piece of firmware around you that is not using/built on something C-like. If Thanos snapped away all the “memory unsafe” things, you’re literally left with the big nothing.

Extremely rational response there my dudes. It’s the biggest “I’m not owned!” response I’ve ever seen. Very cool twisting of words and intent. People are not saying “you must rewrite all code” in memory safe languages. They are saying “you must write all new code” in memory safe languages.

But of course, we need to rely on very empirical evidence to show that C++ is perfectly fine like how C++ won the TIOBE programming language of the year award (PDF warning), which is very much like saying “The teacher gave me a sticker for good behavior”. Sounds nice, but in practice means fuck all. A golden banana sticker… What will they think of next. Now, in that linked paper Bjarne writes the most fucking insane thing I’ve ever read that is most definitely technically correct in the same way that a gram of Uranium-238 contains enough calories for a lifetime. Namely that C++ can’t be statically analyzed because of the halting problem. I gotta figure out just who in the Sam Hill Bjarne’s dealer is, because he is most assuredly on some incredible drugs (that or maybe he’s discovered poppers. We’ll never know!).

I’m not making that up in case you didn’t read that link. You can search for that shit. It straight up says halting problem in a bullet point. Nothing can solve the halting problem, it’s why we just ignore that shit. “☝🤓Oh well actually you see-”. I swear to the skin right off my bones, I shall drop kick you across the room.

Based off of past actions by the committee, trying to rely on empirical evidence to support your claim is a waste of time. You could show a language feature that improves everyone’s lives by an incredible factor, and the committee will say no if you’re not in the in crowd, or if Bjarne doesn’t think it’s worth his time.

As an example of this, many people reading this might be familiar with the addition of the very powerful #embed preprocessor directive that was added to C. This is literally years of work brought about by one person, and that is JeanHeyd Meneide. JeanHeyd is a good friend and also the current editor of the C standard. And #embed started off as the std::embed proposal.

Man, if only everyone in the world knew what the C++ committee did to fucking shut that shit down. They demanded performance numbers, wanted more than one implementation as proof, demanded a whole host of other requirements, and eventually after all this work after showing that std::embed with a naive and simple implementation beat out existing tools like nasm’s .incbin and xxd sometimes by 100x performance, the WG21 committee told JeanHeyd to go fuck himself.

He went over to C, and #embed was added after a few short years and also with a whole ass pandemic in between all of it. And people are fucking stoked about this feature. Every person I know who is an insane C person who thinks that writing C89 in the year 2024 is “good for portability” has told me they are ready to finally upgrade to C23. And it’s not a bad language feature to have. Go has it, Zig has it, Rust has it, Swift… does not, but they did add borrow checking and other Rust style features, and also finally made it so you can install Swift to not the root of your C:\ drive on Windows, so I’ll take the bad with the good there.

The C++ committee is a now slightly worried to be adopting C23 as the C standard they point to because adding #embed directives causes more file dependencies and that doesn’t work so well with the way modules are designed. Alas, if only there was a native C++ language feature so they wouldn’t have to worry about this, they could have prepared for this maybe 5 - 6 years ago. Oh well! Hindsight is a fucking bitch, and the number 1 because in this house we simplify our fractions. 😎

If there’s two things Bjarne has always been good at, it’s throwing tantrums by angrily storming out of the room (this happened in Kona 2019), and acting as a sort of gatekeeper, ensuring that we don’t make bad decisions because, as the designer of <iostream>s, he has never made a single mistake with API design. When Bjarne storms out of the room, Herb is always quick to chase after him, calm him down, you know, act as a sort of “girlboss” in this situation since Bjarne is a grown ass man who doesn’t know how to regulate his emotions and acts like a fucking toddler when he doesn’t get his way (we will return to this subject later in this post, I promise). But let’s focus on the C++ chair and convener for a moment.

Back in 2017 when I started to publicly dissent about the direction modules were taking, especially in regards to build systems, Herb did a master class of a move. He spun up a Study Group, SG15, at the recommendation of GDR to handling “tooling” in the C++ ecosystem. This of course, paved the way for modules to get absolutely fucking steamrolled into the standard while allowing SG15 to act as a buffer preventing any change to modules lest they be devoid of Bjarne and Gaby’s vision. Every single paper that came out of SG15 during this time was completely ignored. In fact, they couldn’t even keep a consistent chair for SG15 in the first year it existed.

Herb Sutter of course makes a million promises and keeps 0, with absolutely no follow through. His whole cpp2 effort is a fucking waste of engineering time and effort. The language has all the interest of a wet fart, and the compiler is just as useful. But this isn’t anything new, just as most of his proposals over the years have been from CppCon. Promise after promise, Herb cannot keep them (remember his inout proposal? LOL. LMAO), but for over a decade he has managed to keep dangling the keys, giving us all false hope that things will improve and finally people are getting wise to his behavior. Let’s not forget after all, in the link I provided regarding Wong’s dismissal of O’Dwyer’s status as a registered sex offender that Herb was the one that suggested Arthur join INCITS so he wouldn’t be excluded from participating in the standards meeting.

Herb is typically diffi-

Herb is typically difficult to get a bead on. Sometimes he seems to actually give a shit about doing the right thing, and then other times it’s like he’s like the subject of a metallica song, dancing to someone else’s tune without rhyme or reason.

However, unlike Herb, it’s really easy to see a pattern of behavior from Gaby Dos Reis. I don’t quite know who at Microsoft is protecting Gaby, it certainly isn’t Herb. Several former Microsoft employees have told me that half of their time is just working around Gaby’s ego within the MSVC space. In fact the day that I’m publishing this, I had a 3rd person tell me this as I had asked them for help with some proof reading. I didn’t even tell them I’d heard the same thing from 2 other former employees.

Of course, Gaby likes to practice revisionism. In a reddit comment posted very recently before this post went live, he stated the following:

Now to be clear, I am not the user Gaby is replying to. My reddit handle has been around since 2008 (digg v3 exodus lol), and if I wanted to call Gaby a bitch on r/cpp, I would just do it. However, that would mean I’m commenting on reddit and that is a waste of my time. I will note however that he didn’t need to respond to what is clearly a throwaway account, but he just cannot help himself from controlling the narrative.

See, not all papers for SG15 were reviewed in a timely manner. In fact my paper on target tuples, P1864 was never formally reviewed after it’s final inclusion into a mailing, as the then chair of SG15 proceeded to just never hold a meeting for several years until members of Bloomberg showed up demanding some change. An early draft had been reviewed in 2019 at CppCon, where Gaby laughed at the idea of Microsoft or any other vendor simply listing the set of platforms they target so that build systems could maybe reason about targets or convert between them.

You’ll notice something in his statement however. He’s only talking about modules. For Gaby, tooling for C++ should only care about modules. Anything else is extraneous and if you try to bring these up he will either just ignore you or try to frame your statements to be about modules. This isn’t the first time that Gaby has tried to redirect any statements that would pull away from the absolute shitshow modules have been up until now. (Remember, it’s 2024 and people still can’t use it because it turns out saying “We will teach the tools to do X” just doesn’t work in practice)

This happens time and time again with Gaby. He will lie, he will deceive, and then he will simply say you’re twisting his words, and oh you poor thing you simply just misremembered what was said before, because it has always been the case. Truly, he is the gaslight of the trio.

To give an example, on June 16th, 2023, Gaby wrote an insulting response regarding P2717r2, a paper attempting to standardize some way for build tools to operate with C++ compilers in a portable way, allowing for the ingestion of information regarding a compiler. In this email, Gaby wrote:

I hope we are not “developing” a standard to name and shame closed-source tools, or only for open source tools. I would strongly recommend moving away from rationale of “closed source”, or “I cannot check myself”. We are aiming for an international standard, not a personal project.

I happen to have it on good authority that someone saw this email, and escalated to a Code of Conduct complaint against Gaby Dos Reis. Because this went to Herb Sutter, (remember he and Gaby are in cahoots at this point in time), Herb used his convener powers to knock this issue down to the INCITS standard body and Code of Conduct process. This resulted in John Spicer, current head of INCITS for WG21, having a discussion with the reporter informing them they should speaking to Gaby directly regarding his behavior.

This is a common tactic that abusers use to protect other abusers. Instead of actually handling the problem, they try get you to talk to them directly. When it comes to callout posts or whisper networks, you typically assign a proxy for the victim and then make sure that 0 contact occurs between these parties. Because John Spicer is in a position of authority himself, the idea of not causing further harm in a Code of Conduct escalation is completely vacant from his mind, unless of course multiple national bodies complain against contributors who aren’t Gaby Dos Reis. In an email leaked to me in May 2024, regarding the SG21 Contracts emailing list (which is not a public group unlike SG15)

Recently, we received multiple complaints about the sheer volume of emails on the SG21 reflector, making it impossible for many folks to follow the discussion, as well as the content and the tone of some of these emails.

Within the last couple of weeks alone, there have been several instances of emails on the SG21 reflector that violate the ISO Code of Conduct, and many more instances of emails that are being perceived as unfriendly and disrespectful, off-topic, or otherwise unhelpful.

Further, this week we received a complaint from a National Body that the volume of emails on the SG21 reflector and the tone of these emails is driving their delegates, who are interested in participating in SG21, away from participation in SG21, because they feel unwelcome and unsafe. In other words, we are losing valuable contributors and are thereby making our job more difficult by having fewer contributors and/or delaying essential feedback until a later point in the process.

These concerns are not new, but we simply cannot go on like this. If we want to continue to have a productive collaboration in SG21, to attract valuable contributors rather than repelling them, and to stand any chance of getting Contracts into the C++ Standard one day, we need to permanently and significantly change how we communicate with each other on the SG21 reflector. We therefore urge everyone participating in the SG21 reflector to limit their emails to the following:

1. sharing Contracts-related proposals and ideas, asking clarifying
2. questions, giving relevant technical feedback, for example pointing out
3. oversights or providing additional information on possible use cases.

Furthermore, emails sent to the SG21 reflector should always be written in a respectful and professional tone and be productive, i.e. contribute new technical information relevant to the discussion at hand.

The following kinds of content is not appropriate or acceptable and will not be tolerated:

1. making statements of fact without providing evidence or technical arguments
2. repeating statements already made previously, without providing new, relevant information
3. value judgments like “X is good” or “Y is bad” (consider instead: “the tradeoff between X and Y is Z”)
4. going off-topic or distracting from the technical discussion (if there is a new topic, start a new email thread)
5. discussing who said what, when, or why, rather than technical aspects of the proposal at hand,
6. questioning other people’s motivation or intellectual honesty (i.e., anything that assumes another person’s state of mind)
7. any form of ad-hominem attacks.

We appeal to everyone participating in the SG21 reflector to take this guidance seriously. If we receive any further complaints about the volume or the tone of emails on the SG21 reflector, we will be forced to implement harsher measures, in particular switch to a moderated mode where emails to the SG21 reflector require the chairs’ approval and/or ban individuals from participating in the SG21 reflector.

Let’s be kind to each other, listen to each other, learn from each other, and focus on making technical progress with Contracts. Let’s make collaboration in this study group a pleasant, welcoming, and productive experience for everyone.

Unless we can work together productively and respectfully, we may never be able to move contracts forward into the C++ standard.

Thank you for your understanding and collaboration.

John and Timur

For those of you unaware, Gaby is effectively Bjarne’s protégé. For whatever reason, he’s been selected to “take the reins” of C++ when Bjarne is “done” with the language (whatever the fuck that means dude). So of course, when Bjarne wants something done, Gaby has to implement it. And so, when it came to modules Gaby had to “prove himself” by getting modules into the language.

Usually, the standard requires some kind of proof of implementation. This is because of the absolute disaster that was export template, a feature that no compiler that could generate code ever implemented. Thus, proof of modules workability needed to be given. Here’s where I bring in my personal conspiracy theory. The only instance of modules being used prior to their inclusion in the standard was a single email to the C++ mailing lists (please recall the amount of work the committee demanded from JeanHeyd for std::embed) where Gaby claimed that the Microsoft Edge team was using the C++ Modules TS via a small script that ran NMake and was “solving their problem perfectly”.

Recall, as I said earlier in this post, that you’re expected to assume that someone is being genuine. Of course, I didn’t fucking think that, nor did I fucking believe it. But I was expected (or at least assumed I was) to assume Gaby was telling the truth. However, I had a contact on that team. One that I ran into at GDC effectively every year because we’re both gay as hell and thus operated in the same circles. And that year he posted, I asked her about the inclusion of modules.

She couldn’t tell me anything verbally, but the face she made when I asked her about Gaby’s statement signaled to me that the team was not happy. Shortly after modules were confirmed for C++20, the Microsoft Edge team announced they were throwing their entire codebase into the goddamn garbage and just forking Chromium, a C++17 only codebase with a build system that does not support using modules in any capacity. So of course, here I am in a difficult position. Do I state that Gaby Dos Reis is a liar? That he lied to the committee to push an agenda that would allow Microsoft to have a business edge over other vendors and give them the advantage? Or do I just simply say “man, what a coinkidink”? Of course the answer is obvious. Gaby Dos Reis fucking lied, but at least Bjarne got what he wanted.

This isn’t the first time Gaby has lied regarding modules, obviously. Yeah, I’ll admit it. I’ve got a personal fucking bone to pick with him. A presentation of my paper P1302 was held without my ability to defend it. Now, I checked the transcript for this discussion after the fact, and it was clear that Gaby Dos Reis lied. He lied about the contents of the proposal, he lied about its behavior, and he made vague enough statements that if you were to correct him he could, as usual, act as though you were reading into his words too much or simply feign ignorance regarding the content of said document.

Sadly, I have been informed by several people that if I were to actually share this transcript from the EDG Wiki, that I would be subject to punishment for violating the ISO Code of Conduct, thus if you need to confirm the transcript of these events you will need to find a committee member willing to show you the page.

Assuming, of course, that GDR or someone else doesn’t try to modify the notes taken as everyone on the committee has full access to the wiki and the general assumption is that no one would ever just make edits to change their past or the notes involved, especially to skew them in their favor, right? Well at least we all don’t use the same account with the same password. Oh wait… I hope you didn’t thought the committee has good info and opsec practices. And the committee is supposed to solve safety issues. They can’t even secure the wiki. 🙄

Come Play My Game, I’ll Test Ya

Bjarne’s solution for memory safety are a feature called “safety profiles”. Per P2816:

A safety profile is a set of guarantees enforced by an implementation. A profile presents the programmer with a set of rules and library components that together delivers the desired guarantees.

Wowza. Talk about some vaguery. You’d be forgiven for replacing the phrase “A safety profile” with “Lifetime annotations and borrow checking” because the sentence more or less describes them too. You could also replace it with so-called “wide contracts”, the contracts language feature, etc.

The real reason this sentence is so utterly devoid of any real definition is because this lets them kick the can down the road, and hone in on an actual definition once they’ve eliminated any competition. Which has worked out so well for C++ contracts, which one might look at and go “oh, that’s a safety profile”, and to a degree you are correct, except contracts have a runtime cost. And safety profiles might not? We don’t actually know because no one has implemented them. To date, they are a bunch of PDFs, and an empty repository on GitHub.

Conversely, we know lifetime annotations and borrow checking work because Swift has it now, and Sean Baxter implemented it in his Circle language. One thing to keep in mind about Circle is that it is not a small compile time extension to Clang, it is a whole from the ground up C++ compiler with metaprogramming and compile time memory safety features. While I don’t personally agree with the syntax used, at least it works, and he has worked on alternative approaches to the syntax to remove the need for lifetime parameters as seen in P3444.

There’s additional issues with profiles as well. Because they affect the translation unit, there’s no guarantee to make sure that you are using a common set of profiles across specific files. You effectively need to turn these safety profiles on for an entire translation unit, and additionally for each module or module partition. Thus, it’s possible to end up with mismatched profiles, and if it’s not possible to mismatch these profiles, then we run into that old beast for C++, the ABI.

For those of you unaware, although C++ does not have a standardized ABI, each vendor currently supports a stable ABI so you don’t need to keep the source around from previous libraries and you can just link against any library compiled with an older compiler or language version.

Of course in practice that rarely happens because for many years Microsoft trained developers to recompile all their code, which then resulted in situations like Borderlands 2 installing the 2005, 2008, and 2010 Visual C++ runtimes.

One of the most damning things about all of this is that if you are a game developer or have ever worked outside the DirectX ecosystem in the last 20 years (2004 was 20 years ago 🥲), you would be aware that the concept of a profile has been tried before and it was an absolute disaster.

After the release of OpenGL 2.1, work began on a new 3.0 revision titled Longs Peak. This was promised to be a major API revision, allowing users to move away from the state based approach that was introduced in the original release. OpenGL was single threaded and moving a thread local context along to keep operating in a quickly becoming multi-threaded world was becoming difficult.

What was promised were immutable objects, atomic object creation, templates to define properties which could be created in a single function call, and inter-threaded object sharing. Then, in 2007, Khronos went into a media blackout after they announced they’d run into several issues with the specification. Almost a year later, in August of 2008, the world was ready to see OpenGL 3.0 and it was not anything that had promised. What happened, instead, was the immediate and fixed functionality mode functions were deprecated, the object model was non-existent, and instead users were given a few new initial features.

If you ask me, OpenGL 3.x wasn’t even that usable until the 3.2 release, when a core and compatibility profile were introduced. And this was the issue. You couldn’t easily mix and match these at the API level, because some shaders compiled under one form would behave differently if mixed with shaders of another, and so the ability to do this was disabled.

This is more or less the equivalent of compiling some of your code with exceptions and some of it without. While it’s doable to actually mix and match exception code it takes quite a bit of work to do so. However, please recall, that Bjarne has said time and again that exceptions are perfectly fine and there are no dialects in C++ (even though if you compile without exceptions that is by, linguistic definition, a dialect).

Don’t get it twisted, I don’t think every game developer is a perfect little angel (far from it, I’ve seen what you fuckers write. Jesus wept), with many of them getting upset that the committee doesn’t approach them for help. This is a little silly because this is like a student in college upset that their professor didn’t magically know to help them with their homework.

Profiles, as they have been proposed, are effectively just file level attributes, as attributes can be ignored by an implementation. This is, as you can imagine, no bueno because it relies entirely on a separate tooling interface, and does not bake any safety into the language. “Oh, but that’s totally fine. We have static analysis tools.” What happens if there’s a behavior difference? “That would never happen!” I’m sure some poor fool might say.

Alas, on Windows because they fucked it up, you have to use [[msvc::no_unique_address]] over [[no_unique_address]]. Worse, because they try to mimic behavior when targeting the MSVC runtime, there is currently no way for me to tell Clang on Windows “I’m only using the C library, and not the C++ runtime. Please treat [[no_unique_address]] like normal.”

Microsoft also has never converted any of its useful __declspec declarations to attributes. Furthermore, we’ve been told time and again that attributes cannot be used to change behavior in a given implementation that would change how the code operates such that it would cause a compiler error, and yet. Here we are being told we can use safety profiles to handle lifetime checks without having the need to scan the entire translation unit (or multiple translation units).

The committee could change this precedence rule, but if they did you can bet your ass I’m showing up with P1283 (Sharing is Caring), because that means we could finally standardize exporting our functions for a DLL even though the standard doesn’t know what the fuck shared library is (and that’s why working with a shared library is still fucking ass in the modern day)

P2816 does reference Ada as an inspiration for profiles. However, there is one aspect that is NOT mentioned in that presentation regarding Ada: There is a fucking project system built directly into the fucking language that determines how source code will compile in relation to each other with said profiles, and this is literally one of the first paragraphs Bjarne links to.

C++ HAS NO SUCH THING!

Furthermore, profiles are used to create dialects of Ada, and as we all know C++ has no dialects (according to Bjarne). I find it so interesting that Bjarne is always referencing language features and then when you look past the top level view, it is clear he has not actually used that language in any capacity beyond maybe reading a web page, or talking to someone who has used it. And it’s so very laughable for him to call upon Ada, a language that has strong type aliasing, when he was against that being added to C++ years ago because “we just needed operator .”.

As you might recall from a few paragraphs earlier, I had mentioned that the MSVC team is very small right now (apparently they are down to about 5 people), and this should help put P3489 which has not been published on official channels yet but is being presented this very week in Wrocław. In this paper, we see several people from Microsoft, including our favorite liar GDR, claim that we need to get the feature that is simplest to implement in as soon as possible. This paper is a cry for help in corporate speak. Allow me to translate the entire paper in just a few small words:

Please don’t make us change our compiler parser. Please. 😭 We have no idea how to add information to our parser. All our experts are gone, leaving, writing Rust, or is just Gaby Dos Reis. We don’t want to lose those sweet sweet government contracts.

There is a specific sentence in this proposal, however, that nearly made me pass out from how detached from reality it is.

Techniques and tools that rely on information already available in C++’s semantics should be favored – they scale better while being less intrusive than pervasive annotation.

Just one more clang-tidy lint, bro. Just one more clang-analyzer run, dude. I promise. Just one more. That’ll fix everything. Run clang-scan-modules for the millionth time. More external processes. More tools that have to be updated separate from the language. Please make your CI/CD take longer because so many of you are using GitHub and that’s going to increase the amount of minutes your runs take and increase the amount of money that Microsoft-owned GitHub can charge you. Please oh please. Just one more lint bro.

A lot has happened as I’ve been writing this article, which is why I ended up delaying it to this release date. It’s one of those “weeks where decades happen” situations. Literally just this past Friday, Google’s security blog talked about how they’re retrofitting spatial safety to hundreds of millions of lines of C++. This is all well and good, but it has a serious issue which is why we can’t just solve these problems at the library level. Sure, this is a great solution for old code, but it is ass for new code. For example, we don’t get any of these hardening primitives at the higher level. There’s no safe_contiguous_iterator I can use as a mixin to get more safety. I have to write it myself, and so does everyone else. Things also fall apart when you get to the point where you might be operating directly on pointers.

And of course, this all worked out so well the last time we tried to rely on attributes giving us proper behavior. And this is why the carries_dependency attribute is used by everyone everywhere right? And the committee definitely didn’t fuck up std::memory_order_consume like 3 - 4 times (I don’t know the actual number, because there’s a race condition 😌).

Also, let’s not forget, it’s 2024 and there is still not a single build system in use that supports every C++ modules without either missing features (the most common is import <header>;), or having various crashes (Visual Studio). The lack of tooling support in existence taking so long when Gaby is saying we need to “stop the bleeding” shows that we’re going to fucking bleed out.

I do happen to know a thing or two about gunshot wounds, the ones that make you bleed out the fastest are sucking chest wounds, and that’s what the US military cared about the most prior to the “war on terror”. Then Afghanistan and Iraq happened, and what they found was that dudes were dying in large numbers from being shot in their extremities if a medic wasn’t able to get to them in 2 - 3 minutes time. So yes, time is of the essence, yet every compiler vendor hasn’t really rushed to stop the bleeding from the shot in the ass we took called C++ modules. So, explain to me how the fuck we’re supposed to stop the bleeding with memory safety when we can’t even patch our own ass up.

This paper is just frankly insulting to anyone who has done the work to make safer C++ syntax, going on to call (or at least allude to) Sean Baxter’s proposal an “ad hoc collection of features”. Yet another case of Gaby’s vagueries where he can feign ignorance. As if profiles themselves are not ad hoc attributes, that have the exact same problem that Bjarne and others argue against, specifically that of the virality of features.

The C++ committee has had 8 years (8 long fucking years) to worry about memory safety in C++, and they’ve ignored it. Longer, technically, but none of them took Rust seriously in 2015, and to be fair Rust was a bit rough for the first year, much like how Golang’s first year was also a bit difficult. Yet, WG21 just doesn’t care!.

As yet another example of them not implementing a feature, we have the case of both std::optional<T&> (which by the way JeanHeyd also had a solution for 6+ years ago, though it is finally making a comeback) and “the dumbest smart pointer”, observer_ptr<T>, which was just a non-owning wrapper around any pointer that prevents you from doing pointer arithmetic, while providing a common interface for generic code so that you can operate on this pointer type as-if it were any other smart pointer class such as std::shared_ptr<T>, std::unique_ptr<T>, or proposed pointers like P0468 (retain_ptr<T>) by yours truly

Sean Baxter’s implementation for both lifetime and concurrency safety tracking has been done entirely in his Circle compiler (one thing that has not been discussed in depth, is that Rust’s approach provides safer concurrency, and Bjarne’s safety profiles do not!). What many people don’t realize is that Sean is beyond an extremely talented engineer. I say this with confidence because initially, I thought Circle was bolted onto a fork of Clang. It is not. It is a clean room, from the ground up, implementation of a C++ compiler. If you can name anyone who has written a standards conforming C++ compiler frontend and parser and then added metaprogramming and Rust’s lifetime annotation features to it, I will not believe you until you show them to me.

Baxter’s proposal, P3390 for Safe C++ has a very large run down on the various features available to us, effectively giving us a safe upgrade path. Don’t get it twisted, I don’t agree with everything in this paper. For example, the introduction of the contextual keyword mut is a bit too much. I get wanting to not be verbose, but mutable is only ever used in one place semantically, and if there’s one thing C++ is good at it’s unnecessary reuse of the same keyword.

The main arguments against it so far are:

1. “it makes a dialect” (boo fucking hoo / plin plin plon)
2. the annotations are viral (types and attributes are also viral, just FYI)
3. It’s opt-in, not opt-out

My responses to each of these are as follows. For starters, stop making the “we can’t have dialects” argument, when we’ve had dialects for years at this point. This is like someone building a massive ship and not thinking about the weight of said ship and then putting it out to sea only to see it sink. The “no dialects allowed RAAAAAH 😡” argument sailed years ago. And that ship’s name was the Vasa.

Secondly, if the concern is that lifetime annotations, the safe and unsafe keyword are viral, what the hell do you think profiles are? Profiles, because they rely on attributes, are themselves viral because attributes are also annotations. And if the argument is “well an implementation is free to ignore an attribute”, then what the fuck are we doing here claiming this is going to make C++ more safe if it can just be ignored by a given implementation???

Unit tests are technically an optional amount of work to verify one’s code is correct (if not runtime behavior wise, at least at compile time). The C++ developer survey, while not reaching every C++ developer, can provide us with extremely useful insight regarding the general community’s opinion on a given subject. And in the case of unit test frameworks, we have the following:

26% of responsdents aren’t writing unit tests for their C++ code. 1/4th of ALL respondents. What a load of bullshit. And we think that suddenly using attribute annotations are going to make things safer? Get Real.

Lastly, yeah it’s gonna be opt-in. Just like how Swift’s syntax is opt-in, because these languages weren’t designed with it in the first place. Such is life. That’s how backwards compatibility works, and profiles are going to work in the exact same way. I feel like the people who make this argument are the same ones who act like not using Rust for small or fun projects makes you an ontological moral failure. If you hold this position, this idea that not writing Rust makes someone an objectively terrible human being, please direct yourself to the nearest ravine and jump in. These people are insufferable and at that point they’re just pulling at straws std::strings to find something wrong when really they just don’t like C++ personally at that stage.

I also want to make it obvious, I don’t have a horse in this race. There are two outcomes for whatever happens with regards to profiles.

The first is that nothing changes. Profiles get made, no one ever turns them on or the government says “this isn’t good enough, try again”. C++ joins the ranks of languages like COBOL, Bjarne’s legacy is that he refused to get out of the way and his stubborn nature resulted in him killing his own language, is phased out for new projects at government contractors by 2030. Then any C/C++ code that I write becomes unusable by the American military and government, and I can sleep soundly knowing there is 0 chance of me every writing anything useful for the US Government.

That’s an easy, easy win. Zig users might also be in this same place, assuming they stay the course and don’t want to be used by governments. Rust users though, you’re gonna have a rough time. Knowing the general political make up of so many people in the Rust community, I do question how you will sleep at night knowing that an open source library you wrote (and remember the open source definition requires no discrimination against use) might get used to murder civilians who get reclassified as enemy combatants (and before anyone comes screaming into my mentions online, Turkey is still trying to genocide Kurdish people)

The second is that Safe C++ gets approved and added, we hem and haw about specifics. Baxter gets burned out from the discussion and takes a step back. We get concepts lite but for lifetime annotations and memory safety. C++ continues to trundle forward. I, and other people, no longer get treated as an ontological moral failure for choosing to not write Rust.

A Sore Loser

As I mentioned previously, Bjarne has been going off the wall for a while now regarding memory safety. Personally I think NASA moving to Rust hurt him the most. He loves to show that image of the Mars rover in his talks. One of the earliest outbursts he’s had regarding memory safety is a very common thing I’ve seen which is getting very mad that the definition a group is using is not the definition he would use and therefore the whole thing is a goddamn waste of time. If you don’t believe me, you can go look at however many talks, papers, presentations, etc. he has given and you’ll see the pattern start to repeat: Bjarne doesn’t know the definition of memory safety used at large in the industry.

However, the answer to this is very fucking simple: Whatever the US government says it is you blithering turd, because that’s the only group whose definition you have to satisfy, because that’s the only group making demands for memory safety in C++, and because so many members of INCITS are government or military contractors.

It’s interesting isn’t it? Bjarne has spent most of his life feeding into the American hegemony and their various machinations in some way (e.g., consulting on the F22) and then right here at the very end of it all, they’ve turned around and metaphorically abandoned him, signalling to him that he can either get out of the way, or they will make him get out of the way. How dare they. He’s been such a loyal servant for the machine. How could it just turn around and ignore him. Don’t they fucking know who he is?

In a TikTok video (sorry, I’m not in charge of where people post their content 🤷‍♀️) posted by niche internet celebrity Skweezy Jibbs (Yes, that is his name) just prior to the 2024 US election, he goes on to talk about Trump and how Trump cannot lose. Not in the sense of Trump was guaranteed a win (though now we already know the results of this election so this statement is a bit weak in and of itself), but that Trump has a very specific type of personality.

I’ll post a small transcript below:

Trump can’t lose.

But if you ever grew up with somebody who couldn’t lose, you know what I’m talking about. Everything inside of them is broken and even the slightest suggestion of loss makes them feel so empty and miserable that they cannot. lose.

And if you haven’t grown up with somebody like that, you don’t understand what that means. So here’s what it means: Anything you say to them that doesn’t make them look like a winner, threatens that. Anything you do, that doesn’t… make them look like the best, threatens that.

And so, it doesn’t matter if they’re actually going to win or not. They. Can’t Lose. So yeah, Trump can’t lose. It would crush him and he is more important than anyone else on Earth to him. He would… destroy the planet just to feel like he’s not losing. It’s got nothing to do with politics homie. Nothing to do with politics.

And that’s not even the most dangerous thing. The most dangerous thing is if you have experience with these kinds of people, all you gotta do to completely manipulate and control them is make them feel like they’re a winner. Tell them what they wanna hear, they will give you inroads into anything you want. Put a smile on their face? Tell them they have a nice haircut? And they will give you the fucking keys to the kingdom. Cause, that’s how fragile that entire personality is.

Ask me how I know. Ask me how I got away with shit as a kid by learning how to just tell them what they wanna hear and then run the fucking house.

Now, I stopped this video and I was like I know exactly what they’re gonna say next.

“If that’s what Trump is about, how come he didn’t do that the first time?

He tried. He tried. You remember how many people in his own staff that he fired? He would bring people on, like unprecedented amounts of new hires. Bring them on board, realizing they weren’t gonna do exactly what he wanted, then kick ’em to the curb like it was a revolving door more than like a fucking Taco Bell in a bad part of town homie.

Just constantly pulling people in. “Oh they don’t wanna do exactly what I want? Kick em out”.

[…]

And they know, that regular normal people and politicians they’re not gonna do anything with that [official act], cause it’s all based on this gentlemen’s agreement that goes back hundreds of years. […] Trump doesn’t give a shit. He doesn’t care. […] And again, it’s all based on one thing: Trump can’t lose. He cannot lose. It’s not that big of a deal for him to do all of this shit just to make him feel like he’s not a loser. He doesn’t care about anything other than himself. He doesn’t care about you. Now he will say he cares about you as long as you say that you care about him and that you like him.

But watch what happens as soon as you disagree with something homie, as soon as you do something that doesn’t align with his own thoughts of who he is, you’re fucking done.

All those people in that first fucking term with him. “These are the best, I only hire the best”, three months later “They’re the worst, they’re the fucking worst”. Because it’s a volatile personality. There is no baseline. […] There is no “oh if I just do this the right way”… Did you see Succession? That’s exactly what this fucking is homie. If you watched Succession, that’s not fantasy […] that’s all written based on real fucking people. […]

He can’t lose. Everything exists to make sure that he feels like a winner. And if anything contradicts that idea of himself in his own head, it’s the enemy. […] I’ve been to countries where you can’t talk badly about the people in charge, or you go to prison… or worse. We are not that far away. And you know what all these countries have in common? They are all run by people who cannot lose. […] I am just telling you, if you don’t know this personality type. This toxic, narcissistic personality type that cannot lose. And if you don’t know what they’re capable of… I’ve seen what they’re capable of as fucking head of the PTA and elementary school or head of an HOA. When the guardrails are gone, and they’ve bullied every opposition down and got in a closet deep enough where the regular defenses don’t work anymore. Hmph. That’s it homie. Game over. Game fucking over. Game Over.

And […] even if you are 100% on board the Trump train, I’m telling you right now homie… you have no idea where that train ends up cause it’s not at a station that you wanna get off at. It’s at the bottom of a ravine in the middle of a burning wasteland for everyone. Except for the one person… who can’t lose.

That’s just Bjarne. Oh sure, don’t get it twisted, it’s different obviously if you look at the surface level and are a pedantic goofball. Bjarne isn’t a billionaire, and he certainly isn’t President of the United States. But Bjarne cannot lose, and that’s why even though the right path is right there he (and most of the committee) lack the conviction to actually follow through. As I stated earlier he throws tantrums, and who out of the gaslight, gatekeep, girlboss trio runs off to tell him whatever he wants to hear? Herb. Because Herb has the keys to the fucking kingdom. And Gaby? He does what Bjarne wants, so he gets to also have that prestige. Bjarne (and Gaby) will vilify anyone who makes it appear as if he has lost, or even if they threaten it.

As an example, at a 2014 meeting, there was a discussion on operator . and out of the room only two people didn’t raise their hands in favor of the proposal. The first was Chandler Carruth, the other was Mara Bos (who now works on the Rust programming language). Chandler successfully explained his position on why he was strongly opposed. Gaby Dos Reis turned to Mara Bos, and then angrily and loudly demanded she explain her opposition as well. This was Mara’s second meeting for participating in C++. She was about 1/3rd the age of most people there, and felt extremely uncomfortable with the age gap and suddenly being put on the spot. Per her words, she stuttered that she agreed with what Chandler said.

In response, Gaby Dos Reis started a very loud rant about how you can’t oppose something without explaining your position. Except you fucking can. People vote strongly against in plenary, in study groups, etc. all the time on the committee and they don’t explain their answer. Sometimes the most you’ll get is the white collar worker equivalent of “The vibes are just off”. But a young newcomer says “no” and suddenly she must account for any action she takes. Thankfully, operator . died in the fucking dirt like a rabid dog, and frankly good fucking riddance. It was a stupid fucking idea thought up by the absolute deranged.

You can also look at how Bjarne and others talk about Rust despite clearly having never used it. And in specifically in Bjarne’s case he hasn’t even used anything outside of Visual Studio! It’s all he uses. He doesn’t even know what a good package manager would look like, because he doesn’t fucking care. He doesn’t care about how asinine of an experience that wrangling dependencies feels like, because he doesn’t have to.

It’s why he always says there are no dialects. Because if there were dialects (and there are, but he’ll change the definition because he can’t lose), then he’d have lost. The Vasa sank because of the hubris of the engineers and not because of their fear to say no to the system they existed in. Because if the latter were true, the Bjane would lose. And we’ve already established: Bjarne. Cannot. Lose.

He has never written any actual production code. It is all research code at best, it is all C++, he does not know any other language. Imagine how delusional it would be if Drew DeVault wrote Hare and then never touched another fucking language for the rest of his life, and never pushed any software to production ever, and only used Visual Studio to do any of this. That’s Bjarne. Oh sure, he talked about a small tool he was writing at CppCon once, but AFAIK it was never released.

We have to accept profiles because otherwise he’d be a loser and as we’ve established he can’t lose. So, really… we never really had a choice did we? We never had the opportunity for consensus. It doesn’t matter that profiles are just shitty epochs. It doesn’t matter that we haven’t even had it publicly confirmed if the US government considers profiles to meet their memory safety definition and requirements. It doesn’t matter what amount of work Sean Baxter put into Circle, and borrow checking, and lifetime annotations. And the reason it doesn’t matter is because Bjarne can’t lose.

If the US government said profiles don’t meet their requirement, he’ll just move the goal posts again and argue that no, they do in fact meet the requirement it is the US government who is wrong and they should apologize immediately and allow C++ to be used in space again. I say this sincerely: when was the last time you saw anyone in the academic space take on the US Military Industrial Complex alone and win? Your brain would have to be smoother than hot chocolate at a high velocity to not know the answer.

I understand that some people might accuse me of bullying an old man. My response is that he can retire at any time. He can step down at any time. Even Mitt Romney knew when to get out of the game for fuck’s sakes. Bjarne’s legacy could be C++ up until now. He’s not responsible for what happens when he’s done. That he refuses to step down just proves my point I’ve made above.

This kind of behavior really did make me reflect on the committee at large. Because this isn’t a one off situation. It isn’t simply just Bjarne who does this. John Lakos of Bloomberg has also done this historically, getting caught recording conversations during the closing plenary meeting for the Kona 2019 meeting because he didn’t get his way with contracts. Ville is another, historically insulting members and contributors alike (at one point suggesting that the response to a rejected paper should be “fuck you, and your proposal”), and I’m sure there are others, but I’m not about to run down a list of names and start diagnosing people like I’m a prominent tumblr or deviantart user in 2017.

Don’t get it twisted, there are so many people who very kind and very caring and very empathetic on the committee, but they are as powerless as the rest of us because they too can be punished for pushing back on Bjarne, Herb, or Gaby.

In reality, this post isn’t really about Gaby Dos Reis, Herb Sutter, and the creator of C++, Bjarne Stroustrup. I lied. It’s about toxic masculinity (oh hey there’s that word) in language design. Remember when I mentioned the weird schoolyard insults and constant bizarre emasculation of Rust and its users? Good.

Because this post is actually about

🔽

Feminism in Programming Language Design

A few weeks ago, Felienne Hermans and Ari Schlesinger published A Case For Feminism in Programming Language Design. Felienne briefly discussed it on her personal site, and the core gist of all of this is approaching language design through the feminist philosophical lens. If feminism is a critique of systems, then it would make sense to critique the systems we use to design programming languages and the processes by which most languages are designed.

Now I won’t spoil the whole thing, because you really should read this. It’s a fascinating work, truly, because when you look at how they discuss what a language designed through a feminist lens might do in its process of evolution, you can see that many well loved languages have already adopted some of these approaches simply because they needed a better way to evolve from a community perspective. Focusing on user stories and experiences, empathetic (or rather informative) error messages, electing people to positions to act as stewards rather than authoritative leaders, etc.

Felienne briefly says in her post

I used to work on spreadsheets—I did very cool things like build refactoring tools for spreadsheets—but the only thing people generally cared about was telling me over and over that spreadsheets are not programming languages. And it never became clear why that is. Argumentation that could easily be refuted (yes, spreadsheets are Turing complete, thank you very much) did not help in any case: Saying that spreadsheets are code is outside of the Overton window of acceptable PL opinions, I learned over and over again.

And yet, I can’t help but think of Build Systems à la Carte, a paper that manages to make some good points regarding dynamic build system dependencies while also pissing me off because now that it’s been published, I get asked about it every fucking goddamn time I have the misfortunate of speaking to anyone who knows what the fuck a build system is. Please stop asking me if I’ve read this. I’ve read it. Please.

This paper is unique in that it proceeds to show that Microsoft Excel (a spreadsheet application) can represent the dynamic dependency capabilities of tools like shake, but this is done more as a gaffe, a punchline. It’s as if the paper is giving you a wink and a nudge that no one in their right mind would ever work in the false language of spreadsheets, but look at how complicated we made Excel that it can actually do these things 🤭.

It’s so fascinating that Felienne has been told time and time again by her peers and various other curmudgeonly shits that she isn’t working in a proper programming language environment, but then Simon Peyton Jones of Haskell fame, Neil Mitchell and Andrey Mokhov show that Microsoft Excel is a fucking build system and therefore it is a complex build tool, but also plays it off as if it shouldn’t be taken seriously. This undermines Felienne in her work, and results in her having to defend herself over and over and over again. These people that push back on Felienne, and might cite a paper such as this, are typically some of the most insufferable people on this planet, and they will find any pedantic excuse to say they are right from the mathematical perspective, and they have to be right using facts and logic when in reality they’re just finding any excuse to not take someone’s work seriously.

These are the same kind of people who used to post on Lambda the Ultimate, a now very defunct and dead website that was about academic programming language definitions, though if you read any comments on any post ever, you’d think they all had gotten hemorrhoids from being so butt frustrated that C++ couldn’t be parsed in a single pass

Or that C++’s templates are turing complete (😱‼‼ THE HORROR) and this is bad because then you can do terrible things like… uhhh… write bad code, which!!! As we all know!!! No one has ever done in any other language in the history of computing 😔. Truly, all C++ programmers must pay for our crimes of writing int main() and then never returning an explicit value 😔. Alas! poor Yorrick! He forgot to link in his crt0.o! 😭

“But it’s inconsistent!”

Alright smartass, show me a consistent language and I’ll show you a situation where someone couldn’t lose and they moved the fucking goal posts. Because guess what the fuck a monad is? “Side effect free I/O”? Get the fuck out of here you 10 ton (metric) goober. I, too, can wave a magic wand and make shit up.

🧙‍♀️

Thrice-Molted Hide and Feather of Quill

🚚 You’re About To Get Isekai’d To Brazil! 🚚

The downside to me bringing this subject up is that unfortunately some people have a broken brain and immediately have an emotional knee-jerk reaction to the word feminism. Hell, even just the prefix fem- seems to get some people frothing at the mouth as if they’ve ingested a cyanide pill.

Regardless, this paper had me briefly re-evaluating a great number of programming languages. You might recall in my Wrapping Up 2021 post that I lamented it felt like there was no language out there for me that meets all my needs and I am still adamant this is the case, though now I’m finally able to put into words what bothers me about many of these languages and it always seems to come down to about 2 or 3 reasons:

1. The language has a figure head, usually given the title of BDFL. In some cases these are sometimes a small team, working from a metaphorical cathedral or ivory tower capacity.
2. The language and its community claim that they are trying to simplify complexity (perceived or otherwise) found in other languages.
3. Comment pragmas

Let’s walk through this list backwards because if I’m being honest that 3rd argument is me just taking the piss at any language where pragmatic behavior is needed, but a comment suddenly has inherent meaning to whatever code you’re writing. Go, specifically, comes to mind and has influenced countless other languages to have something in the same vein, including the c3 language. Why this is the case doesn’t make sense. Yes, certainly there are excuses for having chosen this, but it’s concerning that a comment can alter the ability for your source code to compile. At that point it’s not a comment anymore, it’s just reusing syntax, in the same way C++ reuses static to mean one of multiple behaviors.

Typically, we hear from various developers that the complexity of our software is just too great and we need to just simplify things. If only we could break all understanding down into simple tasks then anything is doable. Curiously, I would argue most people are just simply not aware of how complex of a world we live in. Loss of information is dire, and it can be centuries before we can rediscover or relearn ancient techniques. In the past few years even, we finally figured out greek fire and roman cement.

Greek fire turned out to just be an extremely low carbon mixture of a natural kerosene spring, so it would stay liquid even when not stored in special containers. For Roman cement, just a bunch of big ol’ limestones and when the concrete inevitably cracks, the limestone would effectively act as a seal. In modern concrete we break these limestones up so our concrete just isn’t self repairing. The process for understanding these isn’t simple, you have to have an understanding of chemical reactions. Likewise more modern inventions seem to be simple on the surface, until you sit down and think of the complexity involved with its construction at a mass scale.

For example, rockwool isn’t a new invention, but it most certainly is still effective. Many Americans might be familiar with the cotton candy style of fiberglass based insulation. It’s useful, it retains heat, burns very slowly, and is easily produced. Additionally if you touch it without wearing gloves it will fuck up your hands. Rockwool on the other hand is made of a combination of actual wool and ceramic fibers intertwined. Imagine if you had a modern day loom, that you had to create long ceramic fibers that folded in on themselves. That is not a simple construction. However, it is an elegant one, and the most you might damage yourself with it is no different than if you were to handle wool without any hand coverings. It’s also just as fire retardent, and is perfectly fine as a building material. It’s just more expensive than the fiberglass variant (on average).

I personally feel that we as an industry are so subsumed in our pursuit of simplicity, we don’t consider that you can have elegant solutions that are still complex. Elegance will always beat out simplicity and complexity. DNS after all is not simple (lord knows the running joke of “it was DNS” is funny), but it is an elegant design. Issues brought about by it have to do with implementation details and not the design itself (watch me get someone who was in the room when it was designed and implemented tell me I’m wrong).

Truthfully, upon reflection, the largest issue it seems that I have with most languages is in fact how they are designed and discussed. As stated in Hermans and Schlesinger’s paper, they took a look at a programming languages that are designed either by one person, but done in a way where leadership is not an authoritative figure, as we see in language’s like DeVault’s Hare or Kelley’s Zig, but rather acts specifically like that of a steward. Amy J. Ko’s Wordplay, appears to take this on. How can the language be more user centric, how can it be more experimental, and instead of simply requesting that users share bug reports or suggest ideas, Ko uses the word share, implying a more collaborative effort between creator and audience.

That said, due to the small size of these communities, their processes are not as overloaded as we find with much larger scale languages with committees like TC39 (ECMAScript), WG21 (C++), WG14 (C), and more closed groups like, Golang (Google), Swift (Apple), Lua (Pontifical Catholic University of Rio de Janeiro) and more. These designs (especially in the case of Lua) are very closely associated with a cathedral or “ivory tower” like design. A group in an institution meets regularly and then proceeds to hand their decisions down to the unwashed masses below, as there is a fear of the “tyranny of the masses”.

It is for this reason I think that we see people push back on this so-called “design by committee”, claiming that it is inefficient, slow, unable to respond to changes in the world, and increases unnecessary complexity in the language. However, I would argue that these are a faux pas, and that the real reason is unfortunately due to toxic masculinity.

It is extremely important for those reading this to understand that the phrase toxic masculinity does not mean that all things masculine are inherently toxic simply by existing. There are, after all, positive expressions of masculinity and you might see this expressed online with memes such as “that’s a hell yeah from me” or the more simple comment “dudes rock”. Rather that this particular projection of masculinity hurts those around them, and to a degree feeds into narcissistic personalties, as we’ve seen with the current state of C++.

Effectively, because of the constant state of toxic masculinity surrounding so many men in tech, they are quick to try to make technical arguments so they can have their autonomy, because they are to a degree denied this under the current sociological approach to software development, especially for language design.

This also results in a bunch of big dick swinging contests and heated outbursts. Though the tweet has since been deleted and he apologized, Loris Cro of the Zig community at one point called Rust developers “safety coomers”. If I’m being honest that heated statement was wholly unnecessary, but this is the kind of thing that men have been historically robbed of and this is how toxic masculinity damages them. Also, if I’m being honest I’m so exhausted by this. If I wanted to see a dick swinging contest, I’d just go to a Bay Area Gay Bathhouse. It’s not hard. I mean, ok, at the bathhouse… you know what I’m gonna just stop this sentence here.

This is where I’ve pondered what kind of collaborative effort would be required for a language to be designed without having to give in to these institutions that we all seem to think need to exist. After some time, I’ve unfortunately come to the conclusion that we’re not in a space yet where more anarchistic organizing can take place.

For example, one form of anarchist organization is fluid networks. These are essentially much like a pick up game of basketball. You show up, you play your game. Everyone disperses when the game is done. Repeat as necessary. Unfortunately fast moving behavior in languages means this is effectively a day to day thing. This means that infrastructure needs to be maintained on a regular basis for quick turn around time and improvements, and that requires additional knowledge unrelated to the actual tool you are wanting to improve.

This problem is further compounded by the inability for project infrastructure to quickly be stood up to support a short running project, and thus these small languages turn into research projects or just eventually die off. Surprisingly, there is one language that has managed to avoid this at least from a public view at scale and that’s the Scheme revision. Every couple of years a group gets together and then works on and publishes revisions for the Scheme implementation of Lisp. Were you to remove the institutional aspect of this, and just kind of let people do whatever the fuck they wanted and let it play out letting an infinite number of schemes splitting off, dying, smashing back into each other, grafting specific aspects onto each other you’d find a more volatile, but I personally believe more freeing, language development environment.

Sadly, I know for a fact that, as a transgender individual, even discussing masculinity and feminism (let alone anarchism) is opening me up to harassment. It wouldn’t be the first time. I’ve been very quiet since 2018 about some events that were inflicted upon me by people associated with a specific group. This is also where I come in with my confession. I lied again.

This post isn’t about feminism in language design.

🔽

The C++ Alliance

On the C++ slack, which is currently administered by the C++ Alliance, I was invited to a channel called #on-topic. This was a channel where people could more or less say whatever the hell they wanted. It was here where committee contributor Glen Fernandes was actively insulting me.

In a very poor attempt to tell him to fuck off, I incorporated an extremely cringe joke regarding my status as a trangender individual. I will not repeat it here. However, Glen used this opportunity to harass me for several hours regarding my genitals. Pinging me (remember you can’t block people on slack, and Slack as an organization has never given a damn about this), messaging me, and effectively shitting up the channel. Multiple people, including C++ committee members, begged Glen to stop. He did not.

Eventually, I lost my cool and threatened him, saying “Drop the subject, or the next time I see you IRL I will drop you”. Eventually, Glen’s acquaintance and colleague Vinnie Falco (who was at this point the C++ Slack admin) joined the channel in an attempt to broker some peace. Glen said he would leave the channel and it was “up to me” when he would be permitted to return. I refused to take that responsibility. He is responsible for his own actions, much as I am responsible for mine.

At the San Diego 2018 meeting, I was pulled aside by Herb Sutter. Herb informed me that I would be banned if I acted like that again. I had no idea what the fuck he was talking about. See, someone had screenshotted the part where I said “drop the subject or I will drop you.” but didn’t send the rest of the conversation. I informed Herb that I had been harassed for hours leading up to that statement. Eventually I took my own screenshots and then sent them to Herb. The resulting action was that Glen was not to approach me or talk to me. When Arthur O’Dwyer’s situation was brought up, Arthur was given the benefit of the doubt. At no point was he suddenly approached or talked to as if he was guilty. I was never afforded that.

Of course, the harassment didn’t stop there. There’s another private channel on the C++ Slack, one where even worse discussions occurred. This channel was called #unfiltered and as far as I’m aware, it still exists. And the head of the C++ Alliance, Vinnie Falco sits in that channel, or at least he did at the time. I do not know if he participated in any conversations that happened in there. He let several discussions in there continue, and I was made privy to this channel by someone who decided to turn mole. While this person never provided any screenshots of the content, I was made aware of when they spoke about me. They were very happy when I lost my job in 2018.

Of course, this brings up the title of this section. The C++ Alliance. Shortly after making a shitload of money from the massive rise of value in bitcoin in the late 10s, Vinnie Falco proceeded to purchase the C++ Slack under the name of this non-profit organization. We’re not going to get into the weeds specifically on the C++ Alliance but we are going to talk about what Vinnie has been doing in recent years.

The biggest aspect of this is recently funding Sean Baxter’s work on the Safe C++ proposal. I’m not sure if Sean was aware of what Vinnie brings to the table in terms of his past actions. I do know from having spoken to several people who in turn had spoken to Sean that he had turned down several 7 figure offers for his Circle compiler. However, I am not privy too, nor do I wish to spend too much time speculating on why Sean took money from which party and for what reason.

What I do know is that Sean Baxter is effectively out of money, and it would appear that he is no longer receiving funding from the C++ Alliance in any capacity. Without any public statements from Sean, I no longer wish to dwell on the subject further.

The pandemic left all of us so very tired, even the Boost Project has fallen behind in its project upkeep. At one point the domain’s SSL certificate expired. Now, if it were me, I would have setup Let’s Encrypt and auto renewing for boost years ago, but the boost project moves like absolute fucking molasses. And this simply won’t do for some people. Using the same tactics as Jia Tan (the “entity” that was able to gain control part of the xz-utils project to install a backdoor), Vinnie has been very upset with the Boost project, demanding that things move faster, that they modernize, and a variety of other things. This is all mostly available in public view. Now, to be fair, he and the C++ Alliance are footing the bill for a large amount of work for the Boost project. But, he is acting as if the Boost project (a non-profit) owes him (or rather, the C++ Alliance) in some financial way. One example of this is him talking about the cost of the new proposed (but not yet approved) Boost website. This is located at boost.io and I’m not going to turn that into a clickable link, and that’s because this proposed website brings with it a new logo.

This logo features a Nazi dog whistle. The Nazi SS lightning bolts. Here’s a side by side of the image with and without the bolts being drawn over (Please recall that Jon Kalb, who went out of his way to initially defend Arthur O’Dwyer, serves on the C++ Alliance Board).

This cost $12,000 USD to design

The thing about dog whistles like this is that you can feign ignorance or act like someone is seeing something that isn’t there, but for something egregious it’s very hard to defend it in this case. I’ll talk about this later in a bit, but Vinnie if you are reading this (and I know you at least look at my twitter from time to time) if you really do wish to make amends as you stated in 2023, get rid of the fucking Nazi SS bolts.

Of course, there’s other political dog whistles out there in the tech world right now. Justine Tunney named her C library, cosmopolitan⁵, which I personally believe is named after the term Rootless Cosmopolitan. This is a pejorative Soviet epithet which was used primarily during Joseph Stalin’s antisemitic campaign in the late 40s and early 50s. This is obviously much harder to prove⁶ as Justine has done a very good job of deleting some very eyebrow raising tweets over the years, even having them scrubbed from The Internet Archive’s Wayback Machine (in case you weren’t aware you can request that tweets be removed from the Wayback Machine). She was pretty chuffed about ValleyWag and Gawker going away (frankly I never gave a shit about those sites), as they’d written a piece about her in 2014. Maybe she has changed. She doesn’t at least publicly talk about her politics anymore, though in her post AI Training Shouldn’t Erase Authorship the mask almost slips just enough when she says

It shouldn’t be the case, because no group is doing more right now to elevate the universe to a higher state of complexity.

And for me that’s a little toooooooo much. Maybe that’s some Curtis Yarvin Dark Enlightenment shit, maybe it’s so-called e/acc. Maybe it’s Maybeline. Fuck if I know, but it certainly has me weary of any participation Tunney will have in the C++ community. Given that she recently posted on r/cpp regarding her json.cpp library, I would not be surprised if she starts to show up in places in the C++ space, even if she continues to write what she calls baroque C++ (the most common term I’ve seen however is Orthodox C++).

It doesn’t take much to just acknowledge your wrongdoings and apologize, at the very least. I mean Christ on a corndog, Vinnie Falco made an apology (though IMHO it is worded poorly, and as I mentioned above the logo for boost does not engender any trust for me) for some of his past behavior when he was diagnosed as being neurodivergent. For the record, I’ve got ADHD so this isn’t some neurotypical picking on a neurodivergent person kind of thing. Granted, just because you’re neurodivergent doesn’t absolve you of any past behavior. I want to be clear, I try to give people a second chance when they own up to fucking up, and if they make real active work to make amends. I won’t work with them during this time (as that is more or less vouching for them), but I will fucking lay off the criticism if they are trying to improve themselves, and if they leave me alone.

For example, although Arthur O’Dwyer has learnt to keeps his hands to himself, he does not pay attention to or notice boundaries and really only focuses on his personal agenda. To quote a DM sent to me by a C++ community member about Arthur’s behavior “We are all NPCs to him”. He certainly doesn’t give a shit. He’s been creating sockpuppets, and using proxies to get his changes into the LLVM and Clang project. Very normal behavior by the way.

And for Glen, he certainly never attempted to apologize or seek forgiveness for his actions despite claiming to be a born again Christian. Then again, as they say, there’s no hate like Christian “love”.

Justine, unfortunately, doesn’t appear to have made any amends either, at least publicly, or even acknowledged her past behavior, though she is more than happy to reference her time in the Occupy Wall Street movement. These days however, she’s busy working on llamafiles for Mozilla. For those of you not in the know, a llamafile is basically for turning an LLM’s weights into an executable. Which is where this post is actually going because surprise shithead, I lied again about this post’s topic.

You know what else is really good at noticing a pattern?

🔽

Artificial Intelligence

Ok, you’re probably wondering at this point “What the fuck does AI have to do with C++, let alone memory safety in C++” (that or you’re probably along for the ride at this stage and are just rolling with it), and it’s sadly more related than you might realize. AI has obviously gripped Silicon Valley by the huevos, and the throat. And as many of us are aware it’s being shoved into every goddamn nook and cranny. Sadly, I need to actually take a brief detour to explain a few things before we circle back.

Remember earlier in the Feminism in Programming Language Design section? There’s this aspect of feminism which has to do with bodily autonomy. i.e., You and I both have power and that power is over our own personhood. We all have a universal passport, and we don’t live in an equitable world because not all people are granted their autonomy (and in some cases their personhood is massively devalued). This is, effectively, a core concept of anarchism, and thus the leap from anarchism to feminism in both directions is not too extraneous of a jump.

However, we live in a fairly patriarchical dominated system, one where you have to sell your body, but this is coercion through the threat of violence. I’m very much simplifying it, at least under life in the United States where we have to contend with Calvinist work ethics, wealth equating to one’s verisimilitude, and the idea that “only bad things happen to bad people”, and “only bad people don’t work”. But that threat is starvation (after all if you don’t work, you can’t get paid, and if you can’t get paid, you’re denied food. And if you’re denied food, that’s starvation. And that’s violence), loss of shelter, slavery in prison (and yes, it’s slavery, as your sentence can be extended for failing to perform labor even if you are ill or injured, something that Californian residents don’t seem to understand but alas), and god knows what else.

There’s also the constant desire to put yourself above others who are in seemingly worse positions by trying to rely on religious morality. For example, it’s slightly bemusing to me at least when people who work in the US military get mad about sex workers. “They sell their bodies! That’s a sin!” a high school buddy of mine said circa 2004, who later went on to become an E6 for the United States Marine Corp. for about 10 years (his favorite flavor was razzmatazz for the jarheads reading this 🫡) before coming home bearing physical scars from his time in Iraq and Afghanistan.

This control over one’s body, and their sense of self, is something we see constantly in the tech industry. How many people reading this begrudgingly looked at the layoffs that hit all these FAANG companies and decided “yeah, ok. RTO is it then”? Your coworkers who took that RTO severance? That was them exercising their autonomy.

And so this lack of autonomy has started to infect our technologies. This is just technically another branch of neo-feudalism where you don’t own jack shit. Just look at Windows, they went from calling it “My Computer” to “This Computer” in less than a decade, and now you can’t even move the taskbar away from the bottom of the screen without downloading a hack that patches Windows and also makes it so you can’t update Windows. The Sharif? Straight up gone. You can’t even lock the taskbar! 😔

And honestly I’m not even getting into the weeds of all the issues with AI. Instead we we’re seeing people like Casey Newton write, AI companies are hitting a scaling wall and LLMs are not going to be the path to AGI. That doesn’t stop people from having insane beliefs about how LLMs work however!

Some people think that formal reasoning has already been solved! In the WG21 ISO C++ October 2024 mailing, Andrew Tomazos submitted P3403, a paper titled “The Undefined Behavior Question” (which HOOBOY man we’re just knocking it out of the fucking park with possible anti-semitic dog whistles today aren’t we?), and then when you open this goddamned PDF you realize it’s a fucking cleaned up transcript of a ChatGPT conversation. Because Andrew thinks that ChatGPT has already surpassed human cognition. And he has implied as such on the internal reflector, responding to statements that any ChatGPT submitted work would not be given time he said:

I really don’t think your suggested policy is functional. At the moment it’s on par with humans, so you might be able to get away with your prejudice for now - but what happens when its work becomes clearly and undeniably superhuman - which seems like something we’ll have to face in about a year at the current rate. Are you really going to try and continue to insist on what will be clearly inferior human design work? I think that would be objectively harmful and an obvious opportunity cost.

Thankfully, not everyone is to quick to believe that ChatGPT as of August 2024 has achieved sentience and is on par with humans (the people who do? Hoagies for brains). Jonathan Wakely of RedHat summed it up in a most eloquent way, stating effectively that if Andrew can’t bother to write his own fucking papers, maybe the committee shouldn’t be bothered to read them (do note that Wakely did not use the fuck word. He’s far too nice to stir up trouble).

Andrew is certainly interesting. He is quite honestly one of, if not the most vocal voice on adding any safety features to C++. In November of 2022, he stated:

And as for Rust: I haven’t written anything production in Rust, almost noone has - but the feedback I’ve heard so far from people that have actually tried is that working with the borrow checker is a complete nightmare and totally restrictive. I’m sure if I put a straightjacket^sic on I couldn’t hurt anyone but I also sure as hell couldn’t play tennis anymore.

Andrew, if you wouldn’t mind a moment just between us while everyone else, eavesdrops:

1. There’s plenty of Rust in production you fucking swine of a man. Every Windows machine is running Rust. And was running Rust in 2022. Every Nest thermostat from Google is running Rust via Fuchsia. You know nothing.
2. The borrow checker is only a problem if you don’t understand RAII, or don’t even know how to avoid dangling references. If you find it restrictive because it’s preventing you from writing race conditions or having dangling references, that’s a fucking skill issue. Remember, I mentioned earlier in this post I’m still recovering from brain damage, and I also mentioned I don’t have a college degree. How the fuck am I able to blaze through the borrow checker without any issues, yet the people you’ve spoken with fucking can’t.
3. Maybe we should put you in a straitjacket since you seem to be a regular Houdini and are magically pulling things out of your ass.

To end this brief discussion regarding Tomazos, I will post the obligatory link to “I Will Fucking Piledrive You If You Mention AI Again”.

For the first time in years the tech industry has something new to push, and more importantly it meets the promises made to the Baby Boomer generation. What a lot of people in the modern day don’t realize is that many of us are marching to the echo of the beat of a drum none of us are even aware exists, let alone heard.

In 1967, a 21m31s film was produced for the Philco-Ford Corp. (in celebration of their 75th anniversary), produced by the Tom Thomas Organization, titled “Year 1999 AD”. Watch this film and you will see a variety of promises made regarding the future:

• The promises of a youthful look even into one’s 40s.
• Workbench that can recall images from years past at the press of a button.
• Watch performances from anywhere in the world at the push of a button.
• An active project to colonize Mars
• White collar STEM worker with an interest in agricultural practices
• A computer in every home, acting as:
  • secretary
  • librarian
  • banker
  • game partner
  • servant
  • and more
• Most education is done within the home via video, rather than through written/read exercises.
• Children progress at a rate they are comfortable with so they are Not Left Behind
  • Assuming of course the education system wouldn’t let anyone fall through the cracks and try to meet arbitrary metrics that have zero fucking meaning to even the people that demand them.
  • Also assuming that children are taught phonetics and they aren’t just memorizing the shapes of words which could lead to a general misunderstanding of similarly shaped words
• Anyone can listen to any amount of information at the push of a button.
• Children can watch moving entertaining videos at the push of a button.
• Group chats between family members
• Make lunch in just a few minutes
• Dry your hands by just holding them in front of a device that blows hot air
• Calorie tracking and portion calculation based on easily modularized meal kits and meal prep
• Turn a dial and dishes fall from a tube? I still have no idea what the fuck they were thinking there.
• A society built for leisure and comforts (only available to the rich)
• Smart HVAC systems, CO² monitoring, various other sensors all working together to keep a comfortable atmosphere.
• Fast fashion is alluded to, as there are “non-disposable clothes”
• Ultra-sonic vibrators for your clothes to keep them clean inside your closet
• Browse storefronts of goods, preview items via pictures, and purchase them from the comfort of your home at the push of a button.
• Surveillance devices around the home.
• The man decides if the woman gets to buy anything (😬 yikes a rooni)
• Electronic Mail
• A bunch of wires you’re never gonna fucking use
• Magic Nuclear Battery keeps you warm and also produces clean water and obliterates waste
• Fake sunlight therapy so you don’t feel sad.
• FL Studio, Ableton, Kontakt, Reaper, and other DAWs.
• Computers still make mistakes.
• Americans are using the metric system (We nearly had this in the 80s and then Reagan defunded it).
• Data tracking of exercise can be sent to a central system.
• Household demands are reduced and time can be spent pursuing anything else
  • For most Americans at least, “anything else” is “another job”
• ONLINE PVP GAMING (We fucking did it people, we’re in the utopia 🥳. Pat your hands, and give yourselves a clap on the back)
• You can still prepare food by hand if you so choose. Your autonomy has not been taken away.
• Everybody loves Puerto Rican music (please get on this, you’re missing out)
• Napster

This is it. This is the promise. Right here. Everything that American society was headed towards is in this film. It is the blueprint for the next 70+ years of what life will be like for upper middle class Americans. Your phone in your wallet, every app, every device. All of life’s conveniences, at the push of a button.

Except it’s now the end of 2024 and the check list isn’t fully filled out. And the Baby Boomers are starting to die out. And they need to know, before they’re all gone, that the capitalists (👻ooooooooo👻 I said a word like it’s an insult 👻ooooooooo👻😱) running various American industries held their promise. They are trying to say they’ve delivered on their promise. Even if the people in our position, the position of the average tech worker, know it’s all fucking smoke and mirrors and lies and performance theatre for metrics that don’t fucking matter because no one can estimate the time it takes to harness the abilities of lightning trapped in sand. The promise MUST be kept.

🌊⛱🐴 Man…

Don’t think I’m trying to make it all seem hopeless. I’m tired. I’ve been working in and around Silicon Valley for a decade now and the only thing that has changed is the weather is worse and the number of people in San Francisco after the pandemic is fewer, and some people have tried to act like the world is the same. “Move to the Bay Area. Let’s change the world.”

We’ve had a decade to change it and Things Are Worse Now™. I need more RAM to use websites because people are out of control, and htmx can only do so much. Google barely works anymore. DuckDuckGo is a privacy wrapper around Bing search. Death Valley is turning into a salt lake. We’re running out of phosphorous. We’re running out of top soil. We’re never getting a Titanfall 3.

All of this just sucks ass, man. The stagnation is enough to hollow you from the inside out. Kill your enthusiasm and burn you out, leaving nothing but a smoldering cinder. Not all of us have the energy to fetch a new ember.

This article wasn’t ever really about C++ the language. It was about C++ the community, because that’s what C++ really is. Bjarne is too caught up in his own bullshit to see it, same as Herb and Gaby, and as long as this is the situation we’re in, C++ will never be “safe” as a community. You could have the perfect language, but if no one uses it, because there’s no community, what do you have?

Sure, I could go off and write my own language. I would just end up as another BDFL, like so many before me. The cycle would continue. A different cycle, from the C++ committee’s adamance that we must keep marching forward, lest we end up like the Vasa (LOL, LMAO). Yet, another cycle still. It doesn’t solve any problem except to make myself feel better.

C++ is not in a unique situation. Far from it. This story has been told before. Leadership refusing to let the next epoch come around, destroying themselves and the world in the process. Leaving the rest of us to pick up the pieces, convincing some of us to take on a mandate to repeat this cycle, to make sure the world stays out of the hands of those would change it, while others shirk this mandate and take upon themselves a different path. Discouraging jolly cooperation, as long as we think we only have these two options before us.

By now, you probably already see the skull below, instead of the arrow you’ve typically seen until now, ready to take you to the final section of this post. It’s still about C++ the community, this I promise you. I’m not going to give you some profound wisdom, some answer to this problem. I’m simply going to express what I feel C++ has become, to reveal its true identity. All I need is your help. Just press that skull.

Don’t give up, skeleton!

💀

Gotcha bitch. Honestly, if you hadn’t figured out the bit at the very end of those last few paragraphs there, I don’t know what else to tell you, other than you might be uncultured for the modern era. I know, the joke here is so obvious it’s effectively cringe. “oh c++ is the dark souls of programming languages haha” I shout as I am thrown into a ravine at mach 3.

Without spoiling the lore or the games too much because you can easily watch any set of videos on the subject in more detail than I could ever hope to give, but as a small summary, it basically plays out like the following. Gwyn, Lord of Cinder, and his buddies overthrow the prevailing social order and enter the Age of Fire. As the fire begins to fade, Gwyn is afraid of the coming Age of Dark. He immolates himself to keep the fire burning, upsetting the natural order of the world. The player is tasked with rekindling (called “linking”) the fire. Some players can choose to walk away, and let the Age of Dark happen.

Onwards to Dark Souls 2. The fire has been linked so often that no one even questions the act. It’s just A Thing You Do™. It has also been abandoned and allowed to fade so often that it’s just A Thing You Do™. Everyone is going through the motions. One man recognizes the cycle is inevitable. He tries to break out of it. He becomes a monster. His brother is so terrified of a choice, he locks himself away until he becomes a shambling mess.

We fast forward to Dark Souls 3. It is the end of all things. The fire has been rekindled so much that everything has been reduced to ash. The fire will fade, the fire will be reborn. None of it matters, all of reality is collapsing. All of this could have been avoided if Gwyn hadn’t upset the natural flow. If he’d just stepped aside and let the world take its course without his interference.

This is the state C++ is in, though as I’ve said plenty of times in this post, don’t get it twisted. Bjarne ain’t no Lord of Cinder. We’re stuck in a cycle of people joining the committee to try to improve the language, burning out and leaving, or staying and becoming part of the cycle of people who burn out the ones who leave.

We’re seeing this happen in real time, in relation to Stroustrup v. Baxter. Sean can go off and implement his own language. He technically already has. Stroustrup is too stubborn to let anyone else make a change this important. They are more alike than you might realize.

I’ve effectively been holding back on some context. You would be forgiven for thinking that I’m entirely on Team Baxter and that I’m just raging against the machine. Sean is assuredly a talented engineer, but he does have one flaw and that is, based off of conversations relayed to me by community members and committee contributors, he does not appear to trust anyone else to take the reins of getting memory safety into C++. Furthermore, one of my sources claimed he believes himself to be the smartest person in the room. Obviously this can turn people off to wanting to collaborate, and assuredly in the case of a narcissist would most definitely piss them off, which is why Gaby has continued to thinly insult Sean at every opportunity.

I mentioned earlier, that in Dark Souls 2, a man tried to break free of the cycles of linking the fire and letting the flame fade. He failed, but you play a chosen undead of no renown (you’re Just Some Guy™). At the end of Dark Souls 2, you’re given a choice. Sit upon the Throne of Want, wait your turn and continue the cycle. Or just walk away, let come what may, and venture forth into the unknown. Forever searching.

It’s 2024. Modules fucking suck, contracts have been in design for years and I could not tell you what they look like because there are at least 17 different answers depending on who you’re talking to. There’s still no networking. Senders/Receivers are literally whatever, co_await as syntax is still a disgrace, I can’t use placement ::new for coroutines, people still think we don’t have dialects because they pull a no true scotsman, and every other programming language out there just doesn’t have the momentum or feature set for me to enjoy writing code. There’s no whimsy anymore, just like everything else.

I feel like, metaphorically of course, that I am currently at that threshold. Before me, a throne of want(ing to make a better language), behind me another path. Walk amongst the rest of the world, waiting for an end to arrive whatever that might be.

I’m very well aware I’ve broken some rules here, but I stand by my sources, and as I’ve specified throughout this post, the C++s committee is rife with vicious narcissists and they’re going to come after me to punish me, and make an example of me. They’re going to try to silence me, crucify me even if I can get poetic with it for a hot second. I won’t take it lying down obviously, but it’s important to make the distinction that no matter what they do, they can’t fully control the industry at large and that drives them insane.

They have to fall back onto controlling the narrative where they can. A great philosopher, who has inspired an entire generation, once said “Who controls the past now, controls the future. Who controls the present now, controls the past.” It doesn’t matter what these committee members do to me, it doesn’t matter what snake oil they pander to the C++ community at large. It doesn’t matter what gets written down in any official record, because

A lie will remain a lie



Follow Me On BlueSky, You Can’t Lose 😎