That's technically true, but not practically true. Most software gains very little (more entropy in ASLR) from moving to using 64-bit pointers. Most software gains a lot from moving from x86-32 to x86-64 as the ISA. In particular, it gains a lot more registers (and, importantly, loses the restrictions on which instructions it can use). It gains cheap PC-relative addressing (i.e. shared libraries are a lot faster). It gains SSE2 as a baseline, so floating point operations and calling conventions are cheaper.
There's a good argument to be made for using the x32 ABI, but generally speaking x86-64 code with the 64-bit ABI will still be faster than x86-32 code using any ABI.
You've inadvertently flagged the real problem with XMPP: It doesn't store messages server side, or it does store messages server side, depending on which protocol extensions a given implementation happens to have. For anything that you might want to do with XMPP, there are 2-10 different XEPs with varying levels of support, that describe how to do it.
XMPP badly needed a high-quality reference implementation of a server and a library for implementing clients. Instead it got two crappy reference implementations (that were so bad even the standards editor didn't recommend using them) and a load of partial implementations of the client part of the spec.
If Microsoft's purchase of Github results in export controls being applied to its users, then that is a major wakeup call to the rest of the world
Why would one US corporation being acquired by another US corporation make any difference to the laws that apply to it?
That's not true for most carriers. If you ask for a SIM-only deal, they will sell you something a lot cheaper. Someone did the analysis of these phone-and-plane deals in the USA 4-5 years ago and found that the best ones worked out to be the equivalent to a loan with an APR of around 40%, a lot were even higher. You can almost certainly get an unsecured personal loan from your bank with better rates than you can get a phone bundle from your network provider.
It's not surprising that a lot of people are unaware of this difference though - when providers are making so much money from selling overpriced loans to people wanting to buy expensive phones, they have a great incentive to hide their good-value plans.
If the 16 million people who voted to remain have been completely ignored what is delaying Brexit?
The fact that the people who wanted to leave had no plan and promised a large number of mutually incompatible things (e.g. access to the common market, freedom from EU regulation) and any time they are given some of the things they demand they complain that they don't have the others. Among the things that were promised in the referendum campaign:
If we lose regulatory alignment with the EU, then we can't have freedom of movement over the Irish border, so we're in violation of the Good Friday Agreement. Good luck conducting trade deals when you've just violated an international treaty. If we remain in the common market, we have to remain aligned with the EU for regulation and answerable to the ECJ.
The only Brexit that doesn't involve completely killing the economy (losing 44% of exports and 53% of imports) involves remaining closely aligned with the common market. This means losing our seats in the EU Parliament, Commission, and Council, but still having to follow their rules. That's practically the exact opposite of 'take back control'.
There is no set of compromises that will keep the 51% (closer to 46% now) happy because they voted for an impossible set of constraints.
If you're starting with -Os, then your baseline is optimising for size, so presumably that's what you care about. To beat it you need to either remove instructions entirely, replace multiple instructions with a shorter sequence, or pick instructions with shorter encodings. All of these are things that are really easy to automate. Most of the bloat comes from ABI constraints, and if you pass the right flags the compiler will ignore these (e.g. omitting the frame pointer).
If you're optimising for speed, then start with -O3. At this point the compiler has already done things like loop rotation, common subexpression elimination, and autovectorisation. You might be able to beat it, but even understanding what the code is doing for a nontrivial example is quite hard.
The craziness that is C++ locales, for example, need not concern you because you won't use it.
Are you sure? I have a version of libc++ that works in the FreeBSD kernel, but I needed to do some quite drastic surgery to remove all of the locale stuff (which I really don't want in the kernel - anything that needs localisation should be done in userspace). A lot of the standard library depends on it indirectly and so I needed a lot of stubs to even let the standard library build.
The C++ standard library could really benefit from some better modularity and layering. The core ADTs, the threading library, simple string handling, localised Unicode string handling, and so on should all be separated out and the dependencies between them made explicit. Unfortunately, the C++ standards committee is philosophically opposed to subsetting, which means that instead of a handful of standard subsets we have hundreds of per-project subsets.
Understanding is always the understanding of a smaller problem in relation to a bigger problem. -- P.D. Ouspensky