From a user's perspective, if a device doesn't work with Linux, the OS is broken, but if a device doesn't work with Windows, then the device is broken. It's not fair, but that's the reality we operate in.

I suspect you are the one in need of education. https://www.youtube.com/watch?...

Linus isn't going anywhere. The code of conflict basically says "Your code will be criticized, deal with it. If you're subject to personal attacks, here's where you can complain." Note that Linus' infamous rants have always been direct criticisms of the code, so he won't be affected by this. The code doesn't promise anything more than "[resolution] of the issue to the best of their ability".

That only works if they're the only developer in the project. The moment you have more than one, there needs to be communication between them. This is compounded by the fact that nobody writes perfect code, so eventually that good code does need to be revised, and an arsehole who refuses to recognize the validity of other perspectives is an obstacle to that, especially if the reason it needs to be revised is that there is a core design fault.

I used it for a bit a while ago (0.9). It's a pretty nice alternative to C, but needing to explicitly deal with object lifetimes made it a bit too painful to be used as a high level language, which is a little ironic given the significant influence of Haskell in its design. There are ref counted pointers, but last I checked the syntax for them was pretty clunky. (An earlier version used a dedicated operator for them, but that got obsoleted. It's a shame, since that would have made it more usable as a high level language, similar to D.)

Python has enums as of 3.4, though namedtuple._make() seems to resemble Haskell records more than a C-style enum.

I agree entirely - functional approaches tend to result in much more elegant code, where suitable.

That looks very similar to Rust's match construct, which is basically the same thing but with C-style syntax. Another useful feature I've seen (that would be incompatible with Python's preference for duck typing) is D's final switch, which ensures that cases exist for all members of an enum.

Allowing others to use the same frequencies in a compatible manner would achieve the same benefits (improved coverage, since anyone can operate a tower) without the fragmentation. Not to mention that the cost of negotiating spectrum rights in each state/area would be significant, to say nothing of the fun issues that crop up along boundaries.

You have now added a second antenna to the device, increasing power consumption and complexity, not to mention the additional logic needed to decode the messages.

While I could be wrong, I'm pretty sure the norm is to have different antennas for most of those. Bluetooth and wifi can share one as they use the same frequency, but 2.4 GHz is so far from 900/1800/2100 MHz that it would definitely need a separate antenna. Even making an antenna with the desired characteristics at 3 discrete frequencies likely increases the cost significantly - covering a continuous range of frequencies like that without degrading reception would be even harder.

Your idea is interesting, but ultimately overcomplicated. The entire thing is basically a hack to deal with the fragmentation introduced, but it appears to me your real problem is that the current system grants a monopoly over the frequency. This would be addressed in my proposal by mandating that anyone can use the frequency, provided they were compliant with the protocol and associated regulations. (Or to put it differently, the spectrum would be allocated to protocols, rather than corporations.) It's not clear at all what advantages your approach brings over this.

The problem with this rule is that it means limiting your feature-set so that you have N features with clearly defined regions of use, instead of 2N features with overlapping use cases. Switch statements are one example of this - they've been around since C (or possibly earlier) because they're clearer than a massive if-elseif-etc. statement, but Python lacks them, and people sometimes try to hack something similar into existence using dictionaries of lambdas.

Another is Python supports both functional and imperative programming, which means there's inherently two different ways of performing many simple tasks. Obviously many other languages chose only one of these, and Python is clearly more powerful for having both, but it's a good example of how having more than one way to do things results in a more expressive language.

I disagree completely - I think the issue you're dealing with is that the kernel is not written in C++, and its style reflects that. The kernel is one of the best written pieces of C I've seen, easily better than an average C++ project. IMO, the only feature that the kernel would really benefit from is templates (for added type safety) - everything else works fine.

Furthermore, your argument about things being automatic in C++ is exactly the reason why most kernel developers use C instead! When you are writing a kernel, you absolutely do not want anything happening implicitly - it needs to be explicit, otherwise it's going to cause problems because it's not going to be obvious when it's interacting with something else. To give you an example, it's possible code in the block I/O subsystem to get stuck in an infinite loop upon allocating memory, since that request can result in paging, which results in disk operations via the block I/O subsystem, etc.

Context: I have experience doing both kernel programming (in C) and application development (in C++ with Qt). I think C++ is a powerful language which can lead to some rather beautiful code when used with Qt. I also think that C makes it far too easy to write bad code (buffer overflows, null terminated strings, needing to check return codes without defining a consistent scheme for whether 0 is success or failure, etc.). For any other project, I'd go with C++ in a heartbeat (or maybe D, depending on what libraries I needed). But in the context of kernel development, C++ is definitely the wrong tool for the job.

For two reasons. The first is that in the majority of cases, depression tends to be the result of environmental factors, as opposed to genetic ones. The second is that many people who struggle with depression often have a lot to contribute to society, particularly as it is known to correlate with creativity.

While I agree with your general point, I'm not convinced its possible to remove all quick and easy suicide methods. For example, electrocution seems like an easily accessible one, especially if you insert some paperclips into the socket and touch your chest to them. Admittedly, it would require some creativity, but it's not something that can be easily prevented. (RCDs help, unless the person has isolated themselves from the floor.)

The big problem I see with this is the fragmentation it would cause. Quite frankly, the US already has issues due to their major mobile phone networks using different frequencies. Having different frequencies for the same network, within the same country would just exacerbate that.

I would argue that where the frequency is used for a standardized protocol, they should be required to allow others to use it, providing they are compliant with the appropriate standard. Allowing other frequencies to be allocated for competing standards would only be permitted where there were clear benefits to doing so.

Why would he? Wine runs as an unprivileged user - the only reason he might have needed root access is to open one of the privileged ports.

I think this is only part of it. I grew up using Windows (and am consequently lost on Macs), but I found Linux easier to learn than Windows. This may be partly due to my technical inclinations, but I think that variations in usability and documentation can make a real difference to how easily you can learn to use a system.

Given that this is Debian we're talking about, the the right comparison is with an LTS kernel, not a stable one. 3.17 is already EOL, and it was only released in October. The most recent LTS kernel is 3.14.

That said, Jessie is currently running 3.16, so there's likely something I'm unaware of regarding Debian's kernel policy...