Ancient Rome had libraries already, I'm pretty sure their "ethos" wasn't about inclusivity and safe spaces. Somewhere along the line from then to now, it got subverted.
Most follow the herd, but there are often noticeable exceptions. See e.g. how Toyota refused to jump on the electric vehicle bandwagon and stuck to hybrid engines. Or Mazda, which didn't even do hybrid.
Is that supposed to be an example of a good decision? Outside the US hybrids are quickly becoming irrelevant. The decision is looking like it will cost Toyota the crown
Worldwide outside the US BEVs are about 16% of new car sales (BEVs + PHEVs are about 25%). Hybrids are still going to be relevant worldwide for quite a while.
The peak of ICE car sales (which includes hybrids) was in 2017 and it’s been downhill since then, and it’s going to plummet from here as EV share keeps growing rapidly. Bev share is growing significantly faster than hybrid. I personally wouldn’t be betting my company on a rapidly shrinking market
> Military technology will produce innovation in wartime but in peacetime it is a backwater.
The Internet and GPS were directly invented as a military technology with civilian usage allowed only much later. Integrated circuits's invention and development was largely done on military's dime as well.
Machiabelli was a big Florence patriot and was writing his advice specifically to help a prince better govern Florence and hence increase the chance that Florence will not be annihilated in the constant wars that raged on the Italian Peninsula at the time.
Lack of support for type-safe containers (need to be hack toghether via macros) and overreliance on macros in general (which are not IDE and debugger friendly) are two aspects of C that are off-putting for majority of people in 2026. That's even assuming you're willing to forego pointer/memory safety.
> Lack of support for type-safe containers (need to be hack toghether via macros)
Are templates really so much better than macros that the latter deserve to be called a "hack"? The following two examples are both type-safe and have roughly the same semantics and #LoC:
Macros:
// pair.h
struct id(pair) { T a, b; };
static inline struct id(pair) id(make_pair)(T a, T b){
return (struct id(pair)){ .a = a, .b = b };
}
#undef id
#undef T
// main.c
#include <stdio.h>
#define T int
#define id(n) n ## _int
#include "pair.h"
int main(void){
struct pair_int p = make_pair_int(12, 13);
printf("%d %d\n", p.a, p.b);
}
Templates:
//pair.h
template<typename T>
struct pair { T a, b; };
template<typename T>
pair<T> make_pair(T a, T b){
return (pair<T>){ .a = a, .b = b };
}
//main.cpp
#include <stdio.h>
#include "pair.h"
int main(void){
pair<int> p = make_pair(12, 13);
printf("%d %d\n", p.a, p.b);
}
reply