Ubuntu was already using their own init (upstart) since 2009 and they were not, understandably, motivated to drop it in favor of systemd.
They only decided to move to systemd as Debian decided on systemd as the new default, instead of upstart.

Just upgraded my hobby server from Wheezy to Jessie. sysvinit was upgraded and remained as the init.
The only bits of systemd in the system are the libsystemd* libraries.

Maybe you have a service which has some systemd dependency?

Primary radar (what you call search radar) is not very used for air traffic control.
Primary radar stations are very expensive to build and to operate; their range and accuracy is rather limited too. That is because primary radar stations need to transmit very powerful pulses and listen back for the very faint echoes generated by the aircraft, while discerning them from all the other sources of noise and clutter.
In general, only the military operate primary radar stations and coverage is rather limited. Eg, a large country like the USA will not have much coverage of primary radar deep inside it's borders. For poorer countries, even at the borders you may have nothing.
Some countries (eg, USA, Russia, Australia) have long wave radar stations which can detect the launch of a missile or a bomber squadron half world away, but those provide very very rough information.

The current primary tool for air traffic control, being superseded by ADS-B, is secondary radar.
In this type, the radar stations emit pulses which are detected by the transponders of (cooperative) aircraft. The transponders then transmit (sqwak) a reply to the radar pulse, which is detected by the radar station.
This requires much less power to be transmitted by the radar station and the transponder reply is a much stronger signal than an echo. The transponder signal can also include information such as aircraft ID, altitude and etc.

You've got your math wrong somehow.
1509 meter * 1260 kg * 9.8 m/s = 18 MJ = 5.2 kWh.

Sorry, I forgot to add a point 1.5.

1.5 Even among applications who heavily use server-side rendering, they tend to be more sensitive to network latency and bandwidth than midle-man solutions like NX and Xpra.
When working remotely from home to work, no application I use behaves as well when using X forwarding as it does under Xpra. A few are completely useless with X forwaring.
No application I can think of allows itself to be detached from a Xserver and attached to another one.

The usefulness of X11 network capabilities only works so far, dependind on the application, network latency and bandwidth and whether you need or not detach/reattach.
For a lot of users of remote display, it's necessary use midle-man solutions like NX and Xpra, ignoring X11's network capabilities.

Ultimately, I cannot explain to you it's not possible; absence of a solution is not proof of it's non-existence.
I can enumerate the known difficulties.

1. Fastest rendering method we have nowadays is direct rendering on the GPU hardware. Second fastest is often server side software rendering. X11 server side rendering often comes last.
The issue with methods 1 and 2 is that they include the application sending large amounts of pixmaps to the display server (akin to playing video).
Only effective use of method 3 makes X11's network capabilities useful.

But, when faced with the decision, application developers tend to favor 1 or 2 and ignore 3.
History teaches us this: it was happening before the Xrender extension; it happened again now, as Qt5 does not have an effective server side rendering backend.
Thus, making network capability a core part of the display system can be an exercise in futility, as application developers may simply not make use of it.

2. Server side rendering, which as I've shown is an integral part of X11's network capabilities, adds considerable complexity to the display server.
This is an huge issue in Wayland. In Wayland, the display server, the window manager and the compositor are rolled-in into a single program, known as the Wayland compositor.
To make this work, Wayland compositors must be relatively simple, not much more complicated than X11 window manager/compositors.
This is not compatible with supporting the sophisticated server side rendering features provided by X11. The X.org display server is a huge program, in part because the X11 protocol is complex.

If you insist in asking the wrong question, you'll always get non-sense as an answer.

The server isn't being bloated with new button styles and widgets. X11 server side rendering is accomplished with a a relatively small number of power primitives which haven't been changed in years.

The reason why applications are doing less server side rendering, however, has to do with much more than fancy buttons and widgets.
For example, the Qt4 folks came to the conclusion that their raster backend was quite a bit faster (for local applications, of course) than their X11 backend.
This matters little for drawing the buttons and widgets of an application. But it does matter a lot for the main application area, specially when it's something a bit more complex than a text editor.
It matters when you're navigating a PDF in Okular on a not-so-fast laptop. It matters when you're navigating through the mess of wires in an integrated circuit layout application.

For someone who chastises others for bell and whistles, you can't actually see under the surface.

should read "which Wayland does _NOT_ have"

True, it's not about network access per se.

Whether you are using "ssh -X" or just using DISPLAY to point your application to another machine, it is useful because of two properties in the X protocol, which Wayland does have.

Property 1: Although we routinely use shared memory extensions in modern X setups, a lot (including the core functions to which all applications must be able to fall back) works over a socket, which can be a unix local socket or a TCP socket.
Property 2: The X11 protocol has a slew of very sophisticated features which enabled graphical applications to work around the latency of the communication and to reduce communication bandwidth. An application can store gylphs in the Xserver and then, referencing those gylphs, it can draw nice anti-aliased text using a very small amount of bandwidth.

Wayland lacks both properties, but property 2 is the big issue.
Redirecting X11 applications over a network doesn't work well if the application sends a ton of commands synchronously, unless the network is low latency (eg, local LAN).
Redirecting X11 applications over the network doesn't work well if the application sends the entire graphics window as a single pixmap, untless it's a high bandwith network (eg, local GbE LAN).

Wayland works over a Unix socket too. And you can set which socket the application will attach to with WAYLAND_DISPLAY.
The first problem is that the protocol assumes shared memory but it would have not complicated things that much to make it work without requiring shared memory.
But the real problem is that the only method Wayland applications have to draw is by sending the entire window (surface) as a single pixmap. Works wonderfully over shared memory, works like crap over my cell phone's 3G connection.
A 800x600 surface rendered at 60 fps requires 86.4 MB/s.

Adding to Wayland the rich set of server-side rendering features would complicate things too much for Wayland to be possible.
And it would be a somewhat futile exercise because, increasingly, X11 applications are doing less server side rendering and more pushing of large pixmaps.

99% of people don't want X11 style network transparency. They want "ssh -X" and friends to work. They want to be able to remotely run individual graphical applications.
But X11-style network transparency isn't the only way. And it's not the best way.

Despite all the features available in X, application developers give limited effort to making applications work well over high latency limited bandwidth. An increasing number of applications work poorly over this links. Qt4 applications with the default raster backend work poorly sometimes even my workplace's GbE LAN (Qt5 doesn't even give you the option). Let's not even think of running Kate from home.
No application I actually use supports detaching and re-attaching to a different X server.

People have been pushed to replace "ssh -X" with NX and Xpra (or, in despair, VNC) because of these limitations (Google about them).
Similar solutions can be implemented in Wayland and they don't need the protocol to become networks transparent.

Supporting X11-style network transparency in the Wayland protocol is a futile exercise which compromises the simplicity required by the Wayland model.

Not to mention, if "ssh -X " and friends suits you... then it will work for a long time. As long as your Wayland session includes XWayland (which it will, probably for ever) and your applications retain a X11 backend, this will still work.
It's not going to die tomorrow just because we switch to Wayland compositors.

As I wrote in the another post[1], you need to limit both lateral and vertical accelerations, which puts constrains on how much you can get from banking.
Eg, if you bank almost 90, the passengers will experience no lateral acceleration, but they will experience vertical acceleration, for which tolerance is even lower.
At 800 mph, even the sloping the line up/down will be a problem.

This is all well understood and researched, as it's a massive and expensive problem for all modes of transportation that go at least as fast as a car in a highway.
The Hyperloop proposal simply glossed over reality in this aspect, along many others.

[1] http://tech.slashdot.org/comments.pl?sid=7030445&cid=49155263

You can also tilt the track, canting in railway terms.
Canting in normal railway lines is limited due to the need to handle slow trains, but on high speed rail it's often allowed to be higher.
That's why it's uncommon to use tilting trains above 250 km/h: it's usually preferable to tilt the track than to increase the weight of trains by adding tilting systems.
Though the Japanese have some.

That said, "much" is a relative statement, Whether you tilt the train floor or the track the accelerations experienced by the passenger
- lateral: is v^2/r - g*sin(tilt_angle); acceptable limit is +/- 0.1g
- vertical: 1g + v^2/r * cos(title_angle); limit is 1g+/-0.05g, IIRC

As you can seen from the math, the problem increases with the square of speed, while the benefit from tilt is is limited and bound by the need to keep both lateral and vertical acceleration within bounds.

The HyperLoop Elon proposed was estimated to cost 1/10th of the LA-SF CHSR project, but it only had 1/10th of the capacity.

Unlike the CHSR project, the proposed HyperLoop project actually only connected the outskirts of LA to the Oakland bay, leaving out the expensive part of going to downtown LA and downtown SF.

The estimated HyperLoop projects assumed they save on expropriations by placing the track elevated over existing highways.
But to travel at 800 mph without making your passengers sick and barfing, the route actually needs curves to be 16 times as smooth as the 200 mph CHSR.

The estimated HyperLoop costs were low by an order of magnitude even when comparing to known costs of elevated track and even of oil pipelines. Let's not even talk about the actual precision needed to make this work at 800 mph.

Note that server push applies to content the browser could request _from the same server_.
Usually ad content is served from third party servers.

But ultimately yes, this can lead to wasting some of your bandwidth in content your browser would have otherwise not asked.

What happened to HTTP/1.1 pipelining is fortunately not a common case: popular webserver breaks the standard and doesn't get fixed, making the standard de facto useless. While it's not impossible for the same to happen with HTTP/2.0, this type of situation is more the exception than the norm.
All popular webservers today strive for a good degree of standard compliance.

But, maybe as importantly, as pointed out before, that was not the only problem with HTTP/1.1 pipelining. You also have the head of line blocking problem, which is a fundamental design problem.
This reduced the case to enable HTTP/1.1 pipelining in the browsers and to fix the broken server software.