Bootstrap / recover Ubuntu Linux using chroot

Especially if you have a dedicated server from Server4You the option below might be what you are looking for to e.g. reinstall another linux kernel version using the recovery boot option:
mdadm --assemble --run /dev/md/0
mdadm --assemble --run /dev/md/1
mdadm --assemble --run /dev/md/2
mkdir /mnt/chroot
mount /dev/md/2 /mnt/chroot
mount /dev/md/0 /mnt/chroot/boot
mount /dev/sda1 /mnt/chroot/boot/efi
mount --bind /proc /mnt/chroot/proc
mount -t sysfs sys /mnt/chroot/sys
mount -o bind /dev /mnt/chroot/dev
mount -t devpts devpts /mnt/chroot/dev/pts
chroot /mnt/chroot


How to tune IntelliJ IDEA and make it a bit faster

Reduce the GC interval by increasing the heap. The default heap of 750M is far to so low for today’s needs.

$ vim ~/Library/Preferences/IntelliJIdea2016.1/idea.vmoptions
Should look like that



Ubuntu Linux on Windows

Canonical and Microsoft have been working on a joint project the past few months of bringing the Ubuntu user-space to Windows 10 as an initiative for helping developers running this OS.

The Ubuntu user-space complete with the Bash shell and common command-line utilities -- even apt-get, Apache, GCC, and other common Ubuntu packages -- all can be deployed on Windows 10 without any use of containers or VMs.


How to get the process id (PID) of the running Java process

Java 8 and before: 

public static void main(String[] args) throws Exception{ Process proc = Runtime.getRuntime().exec(new String[]{ "/bin/sh", "-c", "echo $PPID" }); if (proc.waitFor() == 0) { InputStream in = proc.getInputStream(); int available = in.available(); byte[] outputBytes = new byte[available]; in.read(outputBytes); String pid = new String(outputBytes); System.out.println("Your pid is " + pid); }}
…from Java 9 on:

System.out.println("Your pid is " + Process.getCurrentPid());


Current status of WebAssembly — PoC implemented by all four major browser vendors

WebAssembly is an emerging standard whose goal is to define a safe, portable, size- and load-time efficient binary compiler target which offers near-native performance—a virtual CPU for the Web. WebAssembly is being developed in aW3C Community Group (CG) whose members include Mozilla, Microsoft, Google and Apple.

I’m excited to announce that WebAssembly has reached an important milestone: there are now multipleinteroperable, experimental browser implementations. We still have a lot of work left on the standard implementation before shipping, but this is a good occasion to present our progress so far, talk about what’s coming next, and invite feedback.

Why WebAssembly?

The low-level asm.js subset of JavaScript has demonstrated not only that it’s possible for browsers to achieve safe, sandboxed, near-native computational performance, but that there’s tremendous demand for this kind of capability on the Web. Thanks to the Emscripten compiler, we’ve seen asm.js used for a diverse and growing array of applications, including mapping, cryptography, compression, games, CAD, image editing, and facial recognition.
The WebAssembly CG formed last year to take the Web the next step further, with a standardized binary format whose storage size and decoding times could be optimized beyond what is possible with JavaScript. Additionally, by being a new standard, WebAssembly is able to evolve to accommodate low-level features independently of the evolution of JavaScript.
At the same time, we knew it was important for WebAssembly to be “of the Web:” it had to access existing Web APIs and integrate tightly with JavaScript by, e.g., allowing calls between WebAssembly and JavaScript. Unlike classic plugin models, this will allow WebAssembly to be more easily integrated into JavaScript applications and libraries, just as asm.js has been able to do.
Finally, we’ve been able to draw on our years1,2,3,4,5,6,7 of experience with Emscripten and asm.js to guide and focus the initial design of WebAssembly. And crucially, with the great performance of asm.js code on modern browsers, the creation of polyfills will allow developers to begin using WebAssembly even before native implementations have reached saturation in the browser market.

Rust’s impact on the industry

Mozilla has seen better days. 
Once it offered a serious competitive threat to Microsoft’s Internet Explorer. Today, Mozilla’s Firefox squeaks into third place with just 12% market share of desktop browsers, according to NetMarketShare, and is worse than a rounding error among mobile browsers. Other projects, like Mozilla Thunderbird, are even less relevant. 


Brandan Eich on WebAssembly, Web Workers, and Decorators

When it comes to the Web's future, JavaScript creator Brendan Eich remains bullish on WebAssembly but also gives a thumbs-up to Service Worker technology.

Speaking at the O'Reilly Fluent conference in San Francisco on Wednesday, Eich called WebAssembly the most exciting development he has seen in the past year. The project boosts Web performance by providing a portable code format to run in browsers at native speeds. Major browser vendors Apple, Google, Microsoft, and Mozilla all are on board with the effort.


Docker Swarm vs Kubernetes

A new study from Docker shows its Swarm orchestration framework beats Google's Kubernetes in raw startup time, but critics say it's about more than speed alone

Does Docker's Swarm container orchestration system outperform Google's Kubernetes? A recent benchmark says so, but the bigger picture is more complex.

According to a study commissioned by Docker from technology consultant Jeff Nickoloff, Swarm outperformed Kubernetes in container startup time. Most of the Swarm-managed containers started in under a second, while Kubernetes took 2 to 3 seconds.


Mozilla’s Servo engine written in Rust outperforms other engines by far

While the Rust-written Servo engine being developed by Mozilla is still experimental, Google's Jake Archibald has done a performance comparison of Servo against other engines and the results are mighty impressive.

While Archibald did these tests on OS X, the results are interesting enough to share. The test includes an animated background, transform, and border radius on 499 elements:

Chrome Canary - 15 FPS 
Mozilla Firefox Developer - 9 FPS 
Apple WebKit Nightly - 5 FPS 
Mozilla Servo - 60 FPS

Servo is delivering some serious performance. The test appears to be done with Servo's new GPU-accelerated rendering backend.


Rust matures

The Rust team has introduced the latest version of the systems programming language -1.7, which continues the course of 1.6. What this release focuses on is library features -roughly 40 library functions and methods are currently stable in 1.7.
Two months after releasing Rust 1.6, the team is announcing the 1.7 version. According to the official blog post, this version is mainly about library features. “While we have several language features cooking for future releases, the timeframe in which 1.7 was developed included the holidays, which means less time for commenting on GitHub and more time for spending with loved ones,” the Rust team wrote.