There's a difference between elapsed time locally and globally. Locally (i.e. on a single processor), you can have some meaningful concept of absolute time (i.e. whenever the timer interrupt fires). The moment you introduce a second processor, you run into issues where they can be ticking at different rates, and the non-trivial delay in communications between them means that you can't ever hope to synchronize them to the extent you can assume they are the same.

For most applications, you can get away with fairly large tolerances. e.g. wifi is probably fine with 1% variations in your concept of how long a second is. But that only works because you're using local elapsed time. If you need to compare timestamps from multiple nodes (global absolute time), you need to use approaches like vector clocks, because otherwise there's no meaningful way to reason about whether two events happened before each other.

tldr; protocols like wifi just need elapsed time to be roughly correct. Comparing timestamps between systems is much, much more complicated, and you can't even infer an ordering for the general case without casuality. (In that sense, there are a lot of parallels with relativity.)

I think is simultaneously the best thing and the second biggest issue[1] about Kolab - it's a very powerful piece of software targeted at sysadmins. You can setup some very complex, enterprise grade configurations with it, but to do that you need to be willing to muck around with postfix, etc. By that same note, you need to have at least basic familiarity with postfix, apache, cyrus, etc. to actually set it up in the first place, which sets the bar fairly high. (I think it took me a week of practicing in a VM before I was ready to do a proper deployment on my home server.)

[1] The biggest issue would be its general bugginess. e.g. This bug affects anyone with an apostrophe in their name, but went untouched for over a year, despite a patch being included in the original submission.

I've been using it for little over a year (for the same reason as you - didn't want to put too much info into Google), and would describe it as half-decent. I use it as a diary, essentially - schedule, calender, todo list, etc. I still use Gmail for actual email though, because unless you own the domain outright (i.e. not a subdomain) you can trigger false positives for spam on other servers that results in you mail being dropped.

Pros:
-open source
-free (gratis)
-works

Cons:
-pain to setup - the target audience is sysadmins, so you really need to practice doing it in a VM first (especially since doing a complete uninstall is non-trivial)
-buggy - every time I've upgraded to a new version, I've run into a significant bug. (Inability to handle apostrophes in names, buggy apache module that keeps crashing the server, etc.) You can usually fix it if you know PHP/Python, but it's still a pain that makes for a poor user experience. (I've submitted bug reports with patches for these, but not all of them have been merged.)

Basically, it does take a lot of effort to get it working (I have 500 lines of notes on it), but once you've done that it will keep working pretty reliably. The official client is KDE Kontact, which works great for me since I use Linux anyway. I can see it working out poorly if your OS is Windows though (KDE for Windows isn't stable yet). It syncs well with Android too. I generally prefer to enter important events, etc. in through the webui though, since I don't quite trust the other clients to sync them properly.

tldr; it's probably the most broken piece of software I've used under Linux, but it works well enough that I continue to do so. I wouldn't recommend it for anything important (e.g. actual business use), but it's fine for non-critical personal use.

Actually, it's an email server, except it's not just email - there's also contacts, calendars, to do lists, etc. It's basically a direct competitor to Microsoft Exchange, but with a FOSS stack. I have it installed on my home server, and it works pretty well.

According to their website (or at least, the Australian version), you get the choice of Win7 or Win8.

As for Linux support, it seems that the mouse buttons don't work. Apparently there's a patch for the kernel which will be included in the next release.

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.