I said C/C++ because they both use same preprocessor. While I'm sure you could do some interesting things with C++ templates, I haven't seen any use of them that goes beyond generics while still being easy to comprehend. This could be due to my own inexperience though.

It was a long time ago, so I could be misremembering it or confusing it with another model, assuming they haven't changed it since then.

As for the keyboard, I ended up getting a Thinkpad T440p, so that should tell you what my standards are. :P

I think the idea behind Project Ara is the same as the idea behind their Nexus line - they're not interested in being manufacturers, they just want to raise the bar for devices running their software. They'll (hopefully) establish some critical mass, a few other manufacturers will start making parts, and eventually Google won't need to do anything for the system to be self-sustaining, except maybe push for better specs on Ara 2.0...

It's not like you can't add a third party repository with the latest stable (or development) version of Firefox.
Besides, even if you're going to download it somewhere else, would it be good if the OS could check that somewhere else for updates instead of each program have its own auto-update daemon run at startup?

While reflection is much easier to implement in interpreted languages, there are compiled languages that support it. e.g. D

Having worked with D a bit, the biggest difference between it and C++ is that D is garbage collected by default. You can disable the GC and use malloc, but this renders the standard library off limits. Apart from that, I would say that D not only has all the features of C++, it has features that C++ doesn't even have yet. e.g. concepts were proposed as an extension to templates for C++11, but still aren't part of the spec. In contrast, D has support for constraining templates similarly using syntax such as:

D also has excellent support for functional and meta-programming. e.g. the pure and immutable keywords. While C/C++ requires you to use macros for meta-programming, D lets you use existing D functions to generate the resulting code.

You don't need to directly make use of it though; the mere fact that that freedom exists can influence design choices. A good example of this would be how many (common) Linux drivers are based around the actual chip in the device, as opposed to the specific make and model (as is the norm in Windows). Not needing to install drivers for 99% of supported hardware is a pretty nice benefit, and it's the direct result of the kernel (and by extension, those drivers) being GPL.

Freedom, like everything else, exists because it has consequences that we can perceive.

The Series 9 is a POS (or at least it was when I was buying a new laptop a little over a year ago.) The case has a lot of flex and the keyboard terrible tactile response. Regardless of what the specs (and price) are, I don't think you can argue it's a serious contender for the high end.

'cat /proc/filesystems' lists 47 different file systems, which is a superset of those supported by both Windows and OS X.[1] In terms of what you can actually with just one of those, btrfs enables near-instant (~1 second) snapshots of live file systems, which can then be transferred across the network as incremental backups. It also checksums everything stored on the drive so as to eliminate silent corruption. (With the exception of ZFS, pretty much every other FS around is vulnerable to this.)

OS X may (arguably) have some advantages over Linux in terms of usability, but I don't think you can argue that it has a superior feature set. That's the fundamental difference between them - OS X has a few, highly polished features that serve the needs of the average person (who doesn't mind living in an all-Apple ecosystem), while Linux has almost every feature you could think of with a comparatively small amount of polish.[2]

[1] Note that isn't even exhaustive - it only lists those compiled in or with loaded modules.
[2] e.g. There are currently 3+ different ways to use a SSD as a cache for a mechanical drive. None of them have been integrated into the installer for a distro.

Which means you should have backups that are not writeable by your account, and the easiest way of doing so is having cron create a tarball of /home as root. Alternatively, if you're using btrfs snapshots work great for this.

And we already have the solution too - the one guy who was running it under SELinux got an error message instead of a wiped system.
(He also appears to be the one responsible for the bug in the first place...)

To play devil's advocate, the init-related complexity exists either way, so what it really comes down to is where it gets handled.
I think that systemd's approach to daemons (declarative config files about 5 lines long) is much simpler than the sysvinit approach of having a few pages of bash.
Journald is admittedly more complicated that traditional syslogs, but the ability to query a database with a simple command instead of several lines of perl is potentially worth it. (I say potentially because I haven't yet figured out which daemons actually log to journald, and which just use their own log files.)

Making systemd ignore all of fstab is painful because you're trying to disable an entire 'feature'. (The inability to do so contributes to the perception that it's monolithic, but I digress.) What would probably work better is adding 'noauto' to the entry for the file system in question, then add a .service file that calls 'mount /mnt/whatever || true' - that way you can ignore the return code or handle it however you want.

Correct me if I'm wrong, but doesn't that only mean that systemd needs to be the root of the tree of processes whose resources it manages, as opposed to the root of all processes on the system (which is implied by pid1)? Systemd-init expressly checks that it's running as pid1, but this seems to be an artificial constraint and more of a recommendation than a hard requirement.

Win10 doesn't look too bad, but the damage has already been done. I jumped ship for Linux when Win8 was in RC, and now it's almost comical how many different tools you have to install that come out of the box on pretty much every Linux distro (text editor, 7zip, compiler, a browser other than IE, codecs, etc.).

Microsoft's problem is that even if Win10 is on par with Win7 in terms of usability, they've still lost customers and marred their image. The Metro apps in the start menu (literally the first thing seen in pretty much any screenshot of the OS) are an immediate reminder of Win8 and everything disliked about it. Win10 needs to be significantly better than Win7, otherwise they're not going to be able to recover.