Ignore Rants

Getting sucked in to a good old rant, either trying to set the world to rights or simply letting off steam, can be useful. But off-putting. Possibly even derailing you from important tasks, like writing an editorial. (Yes, yet again, another excuse from Yours Truly). Some people start ranting because they don’t understand why certain processes or techniques exist. Why would you write code and put it in version control when you could simply use a strategic spreadsheet? If you’re not used to collaborating with people, version control and the like may seem over the top. Such ranting is a sign of frustration, often borne of ignorance, at having to adopt a new process.

Many people resist change, especially if the current process works for them. However, some change is worth embracing, for example some of the changes to C++ over the years. Simple things like range-based for loops or structured bindings make life easier. Some companies are stuck on slightly older versions of the standard because an upgrade often takes time. Even though C++ strives to be backwards compatible, new warnings often appear if you try a newer compiler. I’ve been involved in some upgrades to newer language versions and something surprising always seems to happen. Usually a nasty surprise, which makes everything take much longer than expected. But sometimes the change helped us find causes of bugs we had been pondering for a long while. Change can be difficult, but useful. And we got to use newer features. Worth it in the end.

‘Modern’ C++ is so much better than older versions, but some new and perhaps over-complicated things have been introduced in C++ too. Can you write a coroutine without needing to look up what’s needed? I can’t. But I can now look at my Learn C++ by Example book [Buontempo24], because I know there’s a chapter in there that will help. Thank you to everyone who helped me learn how to use coroutines, especially Phil Nash’s C++ On Sea workshop in 2023 [Nash23]. If you missed that, his ‘C++ Coroutines: Gods from the machine’ talk is a great resource too [Nash25]. Change usually means you need to learn a new way to do stuff. That can be a challenge, but if you can find the right resources, or better someone to show you how, you’re off to a good start. It’s OK to have a brief “Oh no, I’m back to knowing nothing” to begin with. We’ve all been there, and are aware of the Dunning-Kruger effect, I presume [Wikipedia-1]. If you have limited competence, you might think you know it all. And the reverse effect notes if you have more competence, you are more likely to be aware of your weak spots. When faced with change, ranting and refusing to move with the times might not be the best option.

Some rants are entirely justified, or manifest as a silent scream. Has your machine done an auto-update recently, which failed? Ask our esteemed CVu editor about his laptop. Fortunately, he managed to retrieve his product key from bit locker, and persuade the machine to boot up again. Nobody wants to see a BSD (blue screen of death). If you don’t let off steam when you are frustrated, you will likely implode at a later date, possibly over something tiny that doesn’t really matter. Some things are simply annoying, and maybe result from a careless update or lack of testing. It’s OK to get angry, as long as you can move on and find a workaround or Plan B.

So much software is rubbish. There I said it. And I include some code I have previously written. However, I’m thinking about various retail websites. How many times do you need to accept cookies if you go to a certain DIY website to buy some building materials? Clue: more than once. How many times do address finders fail, especially if like us, you don’t have a house number? It’s no surprise people tend to go, “Ugh!” when I tell them I’m writing a book about computers. (I just ‘finished’ my final chapter of my latest book [Buontempo26]). People like the idea of a book, but in the main recoil at the mention of computers. Many people claim they just can’t get the hang of technology. Trying to use a badly designed website doesn’t mean you are bad at computers. If you design UIs, just watching someone use your product for a few minutes often reveals problems you can easily fix. Some people are very good at UIs, but evidence might suggest they are few and far between. Thank you for listening. Now I’ve got that rant out, I can move on.

Talking of moving on, people are still hailing Rust as a successor language to C++. We’re moving with the times, so have an article in this edition to give you a glimpse of some basics if you’ve not tried Rust yet. People claim ‘Rust is safer than C++’. If I search that phrase, the first hit says “Rust eliminates many common bugs that plague C++ development.” Eliminates? Common? Plagues? Hyperbole?! Maybe. I suspect some of the anti-C++ diatribes are based on wishful thinking. You can, of course, write unsafe code in Rust (yes, unsafe is a Rust keyword) [Rust]. I have nothing against Rust, and have yet to try it properly. I don’t like it when people tell me C++ is terrible, though. I feel the need to defend C++. It’s flawed, like any language. It’s hard to learn and teach. But, it’s powerful and you can use it for almost anything. And yes, you might have buggy and potentially unsafe code. But I am certain that is true of any language. I guess I need to ignore rants and try to think straight, no matter how contentious people are being.

Ignorance means not knowing, so can be fixed with knowledge. I say ‘can be’. Some ignorance is willful, and even has a legal definition [Wikipedia-2]:

When a person seeks to avoid civil or criminal liability for a wrongful act by intentionally keeping themselves unaware of facts.

I could rant about people who stick their heads in the sand and choose to ignore evidence. Such deliberate selective hearing is down-right dangerous at times. Just consider anti-vaxxers and recent measles outbreaks. Nothing new: anti-vaxxers have existed since the first smallpox vaccine in 1796 [NIH]. You can’t reason with unreasonable people, so I’ll park that train of thought. You can spot your own ignorance and try to fix it. How do you find reliable sources for increasing your knowledge? Some might claim the internet has made the situation worse, but I am certain people complained from the moment we had a printing press that pamphlets and the like might contain untruths. Books are sometimes wrong too. That doesn’t invalidate all books. Likewise, the internet can be useful. In both cases, you need to develop some discernment, or ask others to guide you through the vast number of articles, courses, books and the like. You can see product reviews online, but sometimes these are fake! Shock, horror!! If you are considering buying a book, do look at the ACCU book reviews [ACCU]. And note, if you are an ACCU member you can request a copy of a book to review from our list. You get a free book, which might just cover the cost of ACCU membership. What’s not to like? Anyway, take a look at our book reviews.

Some rants are purely to let off steam. Have you ever caught yourself in a discussion about tabs versus spaces? Or the one true way to place braces? Or written a language that doesn’t use braces, and kinda forces one true way of indenting code? Maybe the latter is less common, but hey. Even Python, which use indentation rather than braces, can still cause ‘holy wars’. Have you ever found a Python script with a mix of tabs and spaces? Should you use type hints or embrace duck typing? People are always going to find something to have Opinions (with a capital O), and those opinions are frequently divided. Such disagreements can be a good way to explore different viewpoints and understandings. You should probably be deeply suspicious if everyone agrees. Conflict can enable discussion and discovery. My Dad was a mathematics teacher, and went on to teach trainee teachers. He always said arguments and conflicts facilitate learning. If you can come out with a good example of surprising behaviour, you have a good teaching example. I recall my mind being blown by non-transitive dice when I was very young. My Dad made some: you use three, with six faces, like usual dice, but the numbers differ. They have three pairs of values each:

• Die A has sides 2, 2, 4, 4, 9, 9.
• Die B has sides 1, 1, 6, 6, 8, 8.
• Die C has sides 3, 3, 5, 5, 7, 7.

Each can beat the other two. You could do some sums on the probabilities of each die winning against the others [Wikipedia-3]. Not everything has an ordering. The Pragmatic Programmers are running a series of ‘Brain teaser’ books [Pragmatic]. I’ve read the Numerical, C++ and C# books in this series. They are nice and short, and give you plenty to think about, including some very surprising behaviour, which will improve your understanding of the topics covered.

If you find yourself faced with people in conflict and can’t manage to bring everyone to agreement, consider Timur Doumler’s ‘Herding Cats’ talk [Doumler25]. He spoke about trying to get people to agree on contracts for C++. This has been a work in progress for a very long time, making the drawn out discussions over concepts look like a walk in the park. Though the focus of the talk is on contracts themselves, Timur’s overview says:

Within the C++ standardisation process, we face significant obstacles: the infamously slow and challenging ISO process, the absence of a holistic strategy, and the lack of a shared understanding of what “safety” even means.

He ends,

We also explore the human side of standardisation – the art of helping fiercely opinionated engineers find common ground – and what we can learn from it.

Trying to ensure everyone can make their point, but also listen to opposing views and find a way to agree is a challenge. Listen to his talk: he suggests some ways to make progress. C++’s design by committee can make the process slow, but it also means a variety of people can give input. Thank you committee for all the hard work.

So, ignorance can be fixed, but you need to become aware of your lack of knowledge. Perhaps you don’t need to know something. I can live with not knowing Rust, at the moment. If the time comes, I might give it a go. There are plenty of resources out there that can help you if you want to learn something new, but be picky. Eyeball the ACCU book reviews, or chat to someone before you invest time on badly written books or training. Another good way to learn is by explaining to someone else. Maybe write an article for us? You will find you need to fill in some details you hadn’t thought about, or get feedback nudging you to be more precise. If you do have something to rant about, that could make a good article too. Offer a proof of concept to get it off your chest or show an alternative.

Notice the Dunning-Kruger Wikipedia [Wikipedia-1] article points out towards the end:

Ignorance is sometimes bliss. In this sense, optimism can lead people to experience their situation more positively, and overconfidence may help them achieve even unrealistic goals

I suspect I would never have embarked on some of my personal projects if I had realized how difficult or time consuming they would be. Ignorance isn’t always bad, but learning and thinking is almost always good.

References

[ACCU] ACCU book reviews: https://accu.org/menu-overviews/reviews-overview/

[Buontempo24] Frances Buontempo (2024) Learn C++ by Example ISBN 9781633438330, available at https://www.manning.com/books/learn-c-plus-plus-by-example

[Buontempo26] Frances Buontempo Introducing C++ (due March 2026), see https://www.oreilly.com/library/view/introducing-c/9781098178130/

[Doumler25] Timur Doumler ‘Contracts, Safety, and the Art of Cat Herding’ given at C++ on Sea 2025, available at: https://www.youtube.com/watch?v=gtFFTjQ4eFU

[Nash23] Phil Nash ‘Introduction to C++ Coroutines’, abstract and relevant links at https://old.cpponsea.uk/2023/sessions/introduction-to-cpp-coroutines.html

[Nash25] Phil Nash (2025) ‘C++ Coroutines – Gods from the Machine’ presented at ACCU 2025, available at: https://www.youtube.com/watch?v=b6pYieNd_OY

[NIH] Miguel Gallegos, Viviane de Castro Pecanha and Tomás Caycho-Rodríguez, ‘Anti-vax: the history of a scientific problem’, published in Journal of Public Health on 16 April 2022 and available from National Library of Medicine at https://pmc.ncbi.nlm.nih.gov/articles/PMC9383768/

[Pragmatic] ‘Brain Teasers’ series of books: https://pragprog.com/categories/brain-teasers/

[Rust] Rust standard: unsafe keyword: https://doc.rust-lang.org/std/keyword.unsafe.html

[Wikipedia-1] Dunning-Kruger effect: http://en.wikipedia.org/wiki/Dunning%E2%80%93Kruger_effect

[Wikipedia-2] Willful ignorance: https://en.wikipedia.org/wiki/Willful_ignorance

[Wikipedia-3] Intransitive dice: https://en.wikipedia.org/wiki/Intransitive_dice

Frances Buontempo has a BA in Maths + Philosophy, an MSc in Pure Maths and a PhD using AI and data mining. She’s written a book about machine learning called Genetic Algorithms and Machine Learning for Programmers, and one to help you catch up with C++ called Learn C++ by Example. She has been a programmer since the 90s, and learnt to program by reading the manual for her Dad’s BBC model B machine.