And here’s our regular reminder that “Western Civilization” is a colonialist concept.

Whenever you hear that term used, ask yourself: who are people specifically wanting to exclude when they prefix “civilization” with “Western”?

For any non-racist definition of “civilized”, people are civilized in every country of the world; East and West, North and South. The idea that there’s some other chunk of the world “which doesn’t share our values” is us-and-them propaganda.

As you can guess from the title, this piece is about politics and language. Still, I need to preface it with a disclaimer. I was very deliberate about my title: I am not telling you how to use language, I am only telling you how I use it. I obviously understand the implications of the previous sentences, given that telling others how to use language has become a sticking point in political discourse. The very way I am approaching this paragraph is itself insinuating a certain position, one that is perhaps against the so-called language policing of the so-called identity politics. But don’t get me wrong: while I do have contentions with regard to identity politics, they come from a place of finding them not misguided but insufficient. I feel that the interests of liberalism have been well-served by the superficial treatment of oppression shaped instead as identity politics kept in a vacuum. In plain words, in case it’s not obvious, yes, we must continue and strengthen our defense of transgender rights; not just in a self-serving “if we tolerate this then who might be next”, true as that may be, but because this is another instance of treating people as people. In the recent past, those in power were happy to accomodate this into an “identity issue” and add pronoun boxes to their user interfaces to keep their well-paid transgender programmers content and productive, along with other watered-down displays of Corporate Pride. But even by the late 2010s that was already a contention strategy to delay the inevitable: the growing solidarity among the struggle of the oppressed. Once the conversation progressed from pronouns and rainbows to systemic discrimination, unionization, and ultimately the concentration of economic power, then there was no longer accomodation and they came crashing down. Power found the threat to be real and decided to act; this is where we are as of 2025.

But that doesn’t mean that language isn’t important. I am not saying that language, or even identity politics, are a distraction. The right tried, and to a big extent succeeded, in making identity politics into a distraction—and here, in the grand scheme of things, it helps to perceive the American liberal left as part of the right, heartbreaking as it may be to so many well-meaning Americans. The fact that they made it into a distraction does not take away that identities are part of politics: we must not throw the baby with the bathwater because our adversaries succeeded in shaping the discourse for so long. And as I proceed closer to the point I actually want to make, I feel the need to dispel in the reader the focus on the transgender topic. I used it as an example of the relationship between power and the oppressed because I knew it would come to people’s minds as soon as I started talking about politics and language. So I chose not to walk around it, even though it’s not really my theme to discuss. Identical points as the above could have been made instead replacing the example to racism in the US and the Black Lives Matter movement, or to the treatment of immigrants in Europe, or to women’s rights anywhere in the world, ultimately the largest oppressed group of all. All of these are stories of oppression which have had a period of liberal containment through language and accomodation.

This containment broke apart as soon as the oppressed groups themselves became able to bring their own narrative to the forefront, and now that the hypocritical appeasement is gone, I can finally arrive at the point I want to make, which is that the shaping of language as done by the right has been a lot more effective than we give it credit for. It happens in three fronts: they shape the language of the right (in both radical and mainstream varieties), they shape language of the mainstream left, and, most invisibly, they shape the language of the public in general.

At first it may seem odd to make that third distinction, especially in a time where everyone seems to have been fit into a “right” or “left” bucket. But first, this bucketing is in reality far from being the case, even though it doesn’t seem so within our politically-engaged bubbles. And second, what I mean by shaping of language for the public in general, I mean that which crosses the barriers and spreads into the vernacular of people both in the left and in the right. And no example of that is more amazing than that of “conservative”.

In recent years, I have observed a phenomenon, which, thanks to my own age, I am pretty certain that has not been the case since forever. All the time, I see people, from the left, from the right, and everything in between, using the word “conservative” with the meaning of “careful, cautious, well-measured”, especially in non-political contexts. And, by extension, “liberal” adopts the opposite meaning of “not careful, lavish, unmeasured”.

When I pointed this to people, they were quick to disagree, but then I gave them an example: if you’re baking a cake and the recipe says “apply cinnamon liberally on top”, what does that mean? If I told you I was making a soup and say “the recipe didn’t specify how much pepper to put, so I went conservative about it”, what does that mean?

You might now say that well, these are just the meanings of the words, but — really? What does a cinnamon topping on a cake has to with liberalism? Where is the liberty? Is it because you’re at liberty to put how much you want? Not really, because that liberty would mean you’re free to put a little, or a lot. But if I tell you “add sugar liberally”, does anyone ever understand it to “add just a little?”. No, any person will understand that as “add quite a bit”. People understand “being liberal” as meaning “don’t be sparing”.

Likewise, what does the spiciness of a soup has to do with conservatism? What are you conserving? When one says they were being conservative about adding pepper, everyone understand that it means that the person didn’t want to add too much pepper. But that wasn’t about conserving pepper, even though putting not too much pepper would save pepper in the end. It is clearly understood as being careful about not making the food to spicy to whoever will eat it. People treat “being conservative” in everyday language as “being careful about the end-result”.

To which I reply: what is the effect of introjecting that concept in people’s minds? Are conservatives, now in a political sense, really careful about the end-result? When the left pushes for environmental policies, deeply concerned about the immediate future of our planet in the face of climate effects, and the conservatives resist these initiatives, which side is being cautious and which side is being reckless?

In politics, what conservatism really fights for is conserving the status quo of their power relations. That’s where their name really comes from. They will adopt cautious positions when they serve that goal, and they will adopt reckless positions when that is the one that promotes the perpetuation of their power. That is why you hear today people talking about a “conservative left” when groups defend more egalitarian economics alongside social policies that throw minorities under the bus; it is a way to appeal to the majority’s vote by means of their own prejudices.

But the widespread use of “conservative” to mean a well-measured approach and “liberal” to mean a carefree aproach makes a strong subconscious argument that the conservative approach is that of the “adults in the room”.

A second-order effect is perpetuating this false dicothomy between “conservative” and “liberal”, on which so much of the American perception of mainstream politics is founded. By framing them as opposites, it sounds like the spectrum has been covered, when in reality, true leftist politics are left out of mainstream discourse.

This is so much the case that one can perceive the difference across languages. Due to the vast cultural influence of the US in the Western world, I do see the same phenomenon with the word “conservative” happen in the Portuguese language, here in Brazil. However, because here the political establishment of the left is different from that of the US, we do not have the same linguistic phenomenon happen with the word “liberal”. I could translate my conservative/soup example word-for-word into Portuguese and that would sound idiomatic, but I couldn’t do the same for my liberal/cake example. This is because here, “liberal” is an adjective that is not considered to be part of the left, but instead of the right: in Latin America, the people who label themselves liberals are those aligned with what the global left would call neo-liberals¹. In this context, it is common to find people labeling themselves as “conservative liberals”, which might at first blow minds in the US, but which makes perfect sense once one thinks of those Americans who label themselves “fiscally conservative, socially liberal” — a milquetoast position that comes from a position of comfort, defending a watered-down appeasement in social politics that fails to admit that truly dismantling the systems of social oppression will inevitably require fighting the forces of the economic status quo defended by conservatives. Consider now a mirror form of “conservative liberal”, which is how the term is most used in Brazil: those who are socially conservative, defending the maintenance of the existing systems of oppression, and economically liberal, defending unregulated laissez-faire markets that preserve the powerful in power. In the US, that is just what one calls a “conservative”.

One might argue that this commonplace meaning of “cautious” is that regular meaning of the word, and that the political conservatives are the ones who hijacked the word’s meaning for the sake of their ideology. I disagree, given that the word itself is somewhat recent, and their ideology is not so much about being careful as it is really about conserving (their power). Etymologically, the political meaning matches the word better. And if word frequency in book corpuses is anything to go by, the expression “conservative estimate” appeared a few decades after the word “conservatism” itself.

That is why I decided to stop using “conservative” in that non-political sense: it is essentially a very effective form of propaganda that has gotten ingrained the language. But the reason why I am not telling you stop using it is because that would be a very weak form of activism: changing reality is not changing the language. This is what the liberal establishment wants you to believe: change your language and that’s sufficient, you’ve made a change. This goes back to the “political correctness” movement of the 1990s, which was a form of institutionalized hypocrisy. Saying “you shouldn’t use racist language” is very different from “you shouldn’t be a racist”. The former is a way of preserving racism by hiding it from plain sight. The latter is about changing human relations, of which a change in the language is just one consequence. Changing the language is not a way to change reality. If the reality of oppression itself doesn’t change, the change in the language just accomodates the reality underneath, and over time the new term becomes loaded with the oppressive charge and people decide to change it again, in an inflationary chain of euphemisms or neologisms.

What needs to happen is not a change in the language, but a change in perception. Racism is shattered not by political correctness, but by perceiving other races as equally valid people. Changing perceptions changes reality, and that then changes language. My evolving perception of what it means to be conservative affects how I use the word.

But didn’t I say that the right is effective at shaping language? Isn’t that changing language to change reality? No, Language as propaganda is a way to change perception, and from there then change reality. And this is done is a much more subtle way than just saying “don’t call it X, call it Y”, which just leads to hypocritical euphemism. When they succeed at associating the idea of a “conservative approach” with that of the “adults in the room”, or when they use terms such as “private initiative” or “intellectual property”, they are using language as a means in their advocacy to affect the world, and not making their advocacy as a means to affect language. We need to understand the power of language. We need to change language. But most importantly we need to change the world, otherwise they will keep conserving their position of power in the world, while they keep us busy changing language.

---

¹ - It is interesting to note how much “neo-liberal” is a term strongly derided by the neo-liberals themselves, to the point that one of them once told me that “neo-liberalism doesn’t exist”. They know the power of language and they want to frame their position as being the true liberalism: they want to normalize their stance as a naturalized “love of freedom”, and not as the particular strand of reckless economics that it is.

The Linux program with most contrived argument handling logic ever has got to be gcc.

Everything in it has a reason, of course, but the end result is that you get a weird mix where the order matters for some args and not for others PLUS there are imperative arguments:

Say you want to link a static library into your program (I’m going to use […] to skip other flags)

gcc -o myprogram [...] myprogram.c libmylibrary.a [...]

This works, but now you want to add plugins to your program. So you add some runtime dynamic linking logic and add -ldl.

Oops, you realize your plugins can’t find some symbols from the static library, only those already used by the main program. The compiler threw away everything from libmylibrary.a that was “unused”.

-Wl,–whole-archive to the rescue!

Wait, what’s that? Two flags joined by a comma?

Turns out gcc is a main driver command which launches other programs, and passes arguments along to them. -Wl,–something means that it will pass the flag –something to the linker. You can add after -Wl, anything that is understood by ld, the GNU Linker.)

But you have other libraries you’re linking as well, and now you start getting duplicated symbol errors when compiling, because it is linking too much stuff! The solution? Wait for it…

gcc [...stuff...] -Wl,--whole-archive libfoo.a -Wl,--no-whole-archive [...other libs...]

The arguments in gcc when dealing with linker options are not only positional, they are imperative!

And I mean that in a quite literal sense. They interpreted like a sequence with side-effects: you set a flag, the next libraries is affected by it, you unset the flag, the following libraries aren’t affected anymore.

I thought find was a strong contender for Unix command with the weirdest argument handling, but I guess gcc takes the cake. 🍰

I’m not sure if this title is clickbaity, but it certainly summarizes some of the impressions I wanted to write about.

Yesterday I watched Andrew Kelley’s fun talk on Practical Data Oriented Design — do check it out! — and this post will contain some “spoilers” (as in, I will discuss his takeaways). I was drawn to the talk for two reasons: first, because I wanted to check if I was up-to-date on my programming TLAs, but also because he starts by talking about how he felt he had been stuck in a plateau as a programmer for the past decade — a feeling I’m sure many of us have felt at times! — and how this new knowledge got him out of it.

The bulk of the talk, and his takeways on refactoring his Zig compiler to use Data Oriented Design, is on how to get better runtime performance by making data structures smaller, so they are easier on the cache.

DOD techniques

Lots of the examples involved understanding struct alignment, to raise awareness of how much space gets wasted if you don’t take it into account. One way to deal with it includes replacing 64-bit pointers with 32-bit array indices (pointing out the assumption that we can only then have at most 4G items, which is often fair) and, most importantly, that type safety is lost once you no longer have a `MyStruct*` but just a `u32`. This comes along with moving from arrays of structures to structures of arrays, so you can pack data more tightly.

Another method is to apply “encodings” of data to avoid additional booleans in structs. Instead of an enum Creature { Elf, Orc } and a boolean isAlive, you do a enum Creature { AliveElf, DeadElf, AliveOrc, DeadOrc }, effectively moving that bit of data into the byte used by the enum. This is no different than packing structures using bitfields. Combining this with the switch to arrays, you can possibly even avoid using that bit altogether, by keeping two arrays dead_creatures and living_creatures.

As he went through the various examples of refactors to reach this goal, one by one I kept getting this sense of deja vu: “hey, this is how we used to program in the olden days!”

8-bit coding

If you look at how assembly for the 6502, the 8-bit processor used in the NES (my first game console) and the Apple II (my first computer!), you’ll see some of those tricks embedded in the processor design itself.

The 6502 is an 8-bit processor with a 16-bit address space: each instruction features a 1-byte opcode optionally followed by up to two bytes. Since the address space is 16-bits, addresses can go from 0 ($0000) to 65535 ($FFFF). So, to load a byte from memory position $1234 into the A register, you do a `LDA $1234`, which takes three bytes: `AD 34 12` (yes, the 6502 is little-endian!). However, to allow for more compact code, the first 256 bytes of memory have special processor support: addresses $0000 to $00FF, the “Zero Page”. So, just like in the enum trick for `AliveElf` and `DeadElf`, the “enum of opcodes” in the 6502 processor uses a separate number for loading from the Zero Page, so `LDA $0012` encodes into two bytes only: `A5 12`. This also reminds me of switching from pointers to integers, since that one-byte offset into the Zero Page is also a half-sized index that can be used given a set of assumptions.

Going from structs of arrays to arrays of structs is also a very old trick. In fact, I recall my earliest days of BASIC programming where we didn’t have structs and only had arrays, so storing each “attribute” in its own array was essentially the only way, so if I wanted to store x/y coordinates and a name for a bunch of characters, I’d have three arrays `XS`, `YS` and `NS$`. I also remember how, over time, using parallel arrays like this started to get frowned upon as “poor technique”, since arguably, code using arrays of structs is easier to read and maintain that that using structs of arrays, where you need to manually juggle more things in sync.

Refactoring for performance

And this is a common theme: all those old-school techniques being reframed in the talk as Data Oriented Design were in fact one day the norm, and they started to be phased out in the name of ease of development and maintenance. Yes, they do result in faster code — sometimes much faster code! — if you restructure your code to count each byte and optimize for cache usage. But a key word there is restructure. Writing code this way makes sense when you know how the data is be used, and how it will continue to be used. I was happy to see Andrew doing real-world measurements in his talk, and he correctly points out the assumptions involved, with comments such as “if we assume that most monsters are alive”, etc.

It’s very difficult to do this from the get-go, as you’re still iterating around your problem space. But once you know the typical behavior of the program, you can rework the data to match it. And yes, that will most likely give you a performance boost, but most often not without a cost in maintainability: how does that change in the structure changes the client code that uses it?

Further, how hard would it be to change it over again if the underlying assumptions change — for example, if the usage patterns change, if we port it over and the architecture changes, or if we need to add another bit of data into that structure. Sometimes those are important concerns, for example in a codebase of projects that change often and fast (think a startup evolving its product as market targets move), but sometimes projects reach a stage of maturity where you can step back, look at it and say: “Well, I think I have a good understanding of how this behaves now. What is the most memory-efficient representation for the data?”

Andrew’s case looks like a prime example for that. Once you get the tokenizer for a compiler done, you don’t really expect big seismical changes to its codebase (in fact, I think I could benefit from making some similar changes to my own Teal compiler!). In fact, a compiler is a perfect project for these kind of techniques: it’s fairly low-level and performance-critical code. If I recall correctly, Andrew used to work for a web company before Zig, so it makes sense that the style of code he gravitated towards before was higher-level than the one he’s excited about now.

What about maintenance

Optimizing code for performance always feels like a fun puzzle, but the maintenance cost is always in the back of my mind. Even in something like a compiler, making the code “as tight as possible” can backfire, if your implementation language does not allow for proper abstractions. The difficulties in adapting LuaJIT’s C codebase to the changes in newer versions of the Lua language come to mind. One such low-level trick in that codebase hinged on the fact that 32-bit address spaces were limited to 4GB, which allowed for some neat packing of data; that assumption, which was perfectly fair in the early 2000s, became central to the implementation. Of course, 64-bit systems arrived and assumptions changed. Getting rid of that limitation in a codebase full of smart data packing turned out to be a multi-year process.

Of course, if you can get a memory-efficient representation without hitting a maintenance cost, that’s the ideal situation. Some languages are better for this than others. I was impressed that Zig implements structs-of-arrays as MultiArrayList using apparently the same client interface as a regular ArrayList, such that changing from one to the other seems to be a “5-character change”. If you think of other languages that offer no such abstraction, that’s a much more impactful change throughout a codebase (think of all the places where you’d have to change a `monsters[i]->health` into `monster_healths[i]`, and how the memory management of those arrays and their contents change). I’ve also seen Edward Kmett pull some very cool tricks in Haskell combining super-efficient internal representations with very clean high-level abstractions.

In conclusion…

Still, I think it’s nice that some “old-school” techniques are getting a fresh coat of paint and are being revisited. We all benefit from being more performance conscious, and thinking about also means thinking about when to do it.

There’s something to be said about bringing back “old-school” techniques for programming, though, especially for those of us old enough to remember them: the trade-offs for modern architectures are definitely different. Andrew raises a good point about memoization vs. recomputation: the kinds of things you should choose to memoize when coding for the 6502 processor on an NES are very different than those for a modern x86-64. So it’s actually good that those things are being rethought over rather than just rehashed — there’s too much outdated advice out there, especially regarding performance.

The one piece of advice regarding performance that never goes old is: measure. And keep measuring, to see if the tricks you’re keen on using still make sense as the years go by! Another conclusion we get from this is that optimization and abstractions are not at odds with each other, but in fact, combining them, across language and application levels, is the right way to do it, so that we can keep the performance and the high-level code — but that’s probably a subject for another time!

Earlier today, statistician Kareem Carr posted this interesting tweet, about what people out there mean when they say “algorithm”, which I found to be a good summary:

When people say “algorithms”, they mean at least four different things:

1. the assumptions and description of the model

2. the process of fitting the model to the data

3. the software that implements fitting the model to the data

4. The output of running that software

Unsurprisingly, this elicited a lot of responses from computer scientists, raising the point that this is not what the word algorithm is supposed to mean (you know, a well-defined sequence of steps transforming inputs into outputs, the usual CS definition), including a response from Grady Booch, a key figure in the history of software engineering.

I could see where both of them were coming from. I responed that Carr’s original tweet not was about what programmers mean when we say “algorithms” but what the laypeople mean when they say it or read it in the media. And understanding this distinction is especially important because variations of “the algorithm did it!” is the new favorite excuse of policymakers in companies and governments alike.

Booch responded to me, clarifying that his point is that “even most laypeople don’t think any of those things”, which I agree with. People have a fuzzy definition of what an algorithm is, at best, and I think Carr’s list encompasses rather well the various things that are responsible for the effects that people credit on a vague notion of “algorithm” when people use that term.

Booch also added that “it’s appropriate to establish and socialize the correct meaning of words”, which simultaneously extends the discussion to a wider scope and also focuses it to the heart of the matter about the use of “algorithm” in our current society.

You see, it’s not about holding on to the original meaning of a word. I’m sure a few responses to Carr were of the pedantic variety, “that’s not what the dictionary says!” kind of thing. But that’s short-sighted, taking a prescriptivist rather than descriptivist view of language. Most of us who care about language are past that debate now, and those of us who adhere to the sociolinguistic view of language even celebrate the fact language shifts, adapts and evolves to suit the use of its speakers.

Shriram Krishnamurthi, CS professor at Brown, joined in on the conversation, observing that this shift in the language as a fait accompli:

I’ve been told by a public figure in France (who is herself a world-class computer scientist) — who is sometimes called upon by shows, government, etc. — that those people DO very much use the word this way. As an algorithms researcher it irks her, but that’s how it is.

Basically, we’ve lost control of the world “algorithm”. It has its narrow meaning but it also has a very broad meaning for which we might instead use “software”, “system”, “model”, etc.

Still, I agreed with Booch that this is still a fight worth fighting. But not to preserve our cherished technical meaning of the term, to the dismay of the pedants among our ranks, but because of the observation of the very circumstances that led to this linguistic shift.

The use of “algorithm” as a vague term to mean “computers deciding things” has a clear political intent: shifting blame. Social networks boosting hate speech? Sorry, the recommendation algorithm did it. Racist bias in criminal systems? Sorry, it was the algorithm.

When you think about it, from a linguistic point of view, it is as nonsensical as saying that “my hammer assembled the shelf in my living room”. No, I did, using the hammer. Yet, people are trained to use such constructs all the time: “the pedestrian was hit by a car”. Note the use of passive voice to shift the focus away from the active subject: “a car hit a pedestrian” has a different ring to it, and, while still giving agency to a lifeless object, is one step closer to making you realize that it was the driver who hit the pedestrian, using the car, just like it was I who built the shelf, using the hammer.

This of course leads to the “guns don’t kill people, people kill people” response. Yes, it does, and the exact same questions regarding guns also apply regarding “algorithms” — and here I use the term in the “broader” sense as put forward by Carr and observed by Krishnamurthi. Those “algorithms” — those models, systems, collections of data, programs manipulating this data — wield immense power in our society, even, like guns, resulting in violence, and like guns, deserving scrutiny. And when those in possession of those “algorithms” go under scrutiny, they really don’t like it. One only needs to look at the fallout resulting from the work by Bender, Gebru, McMillan-Major and Mitchell, about the dangers of extremely large language models in machine learning. Some people don’t like hearing the suggestion that maybe overpowered weapons are not a good idea.

By hiding all those issues behind the word “algorithm”, policymakers will always find a friendly computer scientist available to say that yes, an algorithm is a neutral thing, after all, it’s just a sequence of instructions, and they will no doubt profit from this confusion of meanings. And I must clarify that by policymakers I mean those both in public and private sphere, since policies put forward by the private tech giants on their platforms, where we spend so much of our lives, are as effecting on our society as public policies nowadays.

So what do we do? I don’t think it is productive to start well-actually-ing anyone who uses “algorithm” in the broader sense, with a pedantic “Let me interject for a moment — what you mean by algorithm is in reality a…”. But it is productive to spot when this broad term is being used to hide something else. “The algorithm is biased” — What do you mean, the outputs are biased? Why, is the input data biased? The people manipulating that data created a biased process? Who are they? Why did they choose this process and not another? These are better interjections to make.

These broad systems described by Carr above ultimately run on code. There are algorithms inside them, processing those inputs, generating those outputs. The use of “algorithm” to describe the whole may have started as a harmless metonymy (like when saying “White House” to refer to the entire US government), but it has since been proven very useful as a deflection tactic. By using a word that people don’t understand, the message is “computers doing something you don’t understand and shouldn’t worry about”, using “algorithm” handwavily to drift people’s minds away from the policy issues around computation, the same way “cloud” is used with data: “your data? don’t worry, it’s in the cloud”.

Carr is right, these are all things encompassing things that people refer to as “algorithms” nowadays. Krishnamurthi is right, this broad meaning is a reality in modern language. And Booch is right when he says that “words matter; facts matter”.

Holding words to their stricter meanings merely due to our love for the language-as-we-were-taught is a fool’s errand; language changes whether we want it or not. But our duty as technologists is to identify the interplay of the language, our field, and society, how and why they are being used (both the language and our field!). We need to clarify to people what the pieces at play really are when they say “algorithm”. We need to constantly emphasize to the public that there’s no magic behind the curtain, and, most importantly, that all policies are due to human choices.