Fuchsia OS is about to replace Android OS

Fuchsia is designed for security and privacy Security and privacy are woven deeply into the architecture of Fuchsia. The basic building blocks of Fuchsia, the kernel primitives, are exposed to applications as object-capabilities, which means that applications running on Fuchsia have no ambient authority: applications can interact only with the objects to which they have been granted access explicitly. Software is delivered in hermetic packages and everything is sandboxed, which means all software that runs on the system, including applications and system components, receives the least privilege it needs to perform its job and gains access only to the information it needs to know. Fuchsia is designed to be updatable Fuchsia works by combining components delivered in packages. Fuchsia packages are designed to be updated independently or even delivered ephemerally, which means packages are designed to come and go from the device as needed and the software is always up-to-date, like a Web page. Fuchsia aims to provide drivers with a binary-stable interface. In the future, drivers compiled for one version of Fuchsia will continue to work in future versions of Fuchsia without needing to be modified or even recompiled. This approach means that Fuchsia devices will be able to update to newer versions of Fuchsia seamlessly while keeping their existing drivers.

Just like Go, Fuchsia seems to pursue a pragmatic philosophy, not trying to built upon a microkernel but a sweetspot kernel concept that solves actual problems, instead of following a microkernel dogma.

Sailfish, iOS, iPadOS

Nashorn JavaScript Engine leaves Java with JDK 15

Summary Remove the Nashorn JavaScript script engine and APIs, and the jjs tool. The engine, the APIs, and the tool were deprecated for removal in Java 11 with the express intent to remove them in a future release. Motivation The Nashorn JavaScript engine was first incorporated into JDK 8 via JEP 174 as a replacement for the Rhino scripting engine. When it was released, it was a complete implementation of the ECMAScript-262 5.1 standard. With the rapid pace at which ECMAScript language constructs, along with APIs, are adapted and modified, we have found Nashorn challenging to maintain.

A good approach to streamline the Java standard runtime and focus on what matters.

OpenJDK, Java 15, JVM

Quarkus, an alternative to Spring Boot, backed by Red Hat

Quarkus is more than just a runtime. It is a Kubernetes-native Java stack for building fast, lightweight microservices and serverless applications. It is purpose-built to capitalize on the benefits of cloud-native applications. Quarkus delivers significant runtime efficiencies for applications deployed on Kubernetes with fast startup times, low memory utilization, and small image footprints. Everything you need to grow your career. With your free Red Hat Developer program membership, unlock our library of cheat sheets and ebooks on next-generation application development. SIGN UPEverything you need to grow your career. A modern Java stack One of the founding principles of the Quarkus project was to bring developer joy to enterprise Java developers. What does that mean, and how does Quarkus bring joy? Kubernetes-native Java Quarkus is a Kubernetes-native Java framework targeted for containers and serverless due to its fast startup, low memory, and small application size.

For me Quarkus not worth not rewrite any Ktor or Spring Boot app that does not have any major issues. Quarkus is still on the level of being yet another service framework than a fundamentally new way of developing services.

Spring Boot, Quarkus, Kotlin, Java, Ktor

GraalVM shows promising performance and outperforms OpenJDK in many cases

GraalVM offers a comprehensive ecosystem supporting a large set of languages (Java and other JVM-based languages, JavaScript, Ruby, Python, R, WebAssembly, C/C++ and other LLVM-based languages) and running them in different deployment scenarios (OpenJDK, Node.js, Oracle Database, or standalone). This page provides an overview of different scenarios in which GraalVM can make a difference for your applications. Some of versatile GraalVM capabilities, that might be missing on this page are thoroughly summarized and disclosed in Top 10 Things To Do With GraalVM blog post. For Java Programs For existing Java applications, GraalVM can provide benefits by running them faster, providing extensibility via scripting languages, or creating ahead-of-time compiled native images. Run Java Faster GraalVM can run in the context of OpenJDK to make Java applications run faster with a new just-in-time compilation technology. GraalVM takes over the compilation of Java bytecode to machine code. In particular for other JVM-based languages such as Scala, this configuration can achieve benefits, as for example experienced by Twitter running GraalVM in production.

A common runtime for all popular and industry-relevant languages, the GraalVM is not only backed by Oracle but also Red Hat.

OpenJDK, Rust, Kotlin, Java

Due to memory safety issues, Chromium considers evaluating safe programming languages

The problem Around 70% of our high severity security bugs are memory unsafety problems (that is, mistakes with C/C++ pointers). Half of those are use-after-free bugs. Pie chart of uses-after-free, other memory safety, other security bug, security asserts (Analysis based on 912 high or critical severity security bugs since 2015, affecting the Stable channel.) These bugs are spread evenly across our codebase, and a high proportion of our non-security stability bugs share the same types of root cause. As well as risking our users’ security, these bugs have real costs in how we fix and ship Chrome. The limits of sandboxing Chromium’s security architecture has always been designed to assume that these bugs exist, and code is sandboxed to stop them taking over the host machine. Over the past years that architecture has been enhanced to ensure that websites are isolated from one another. That huge effort has allowed us — just — to stay ahead of the attackers. But we are reaching the limits of sandboxing and site isolation. A key limitation is that the process is the smallest unit of isolation, but processes are not cheap. Especially on Android, using more processes impacts device health overall: background activities (other applications and browser tabs) get killed with far greater frequency. We still have processes sharing information about multiple sites. For example, the network service is a large component written in C++ whose job is parsing very complex inputs from any maniac on the network. This is what we call “the doom zone” in our Rule Of 2 policy: the network service is a large, soft target and vulnerabilities there are of Critical severity. Just as Site Isolation improved safety by tying renderers to specific sites, we can imagine doing the same with the network service: we could have many network service processes, each tied to a site or (preferably) an origin. That would be beautiful, and would hugely reduce the severity of network service compromise. However, it would also explode the number of processes Chromium needs, with all the efficiency concerns that raises. Meanwhile, our insistence on the Rule Of 2 is preventing Chrome developers from shipping features, as it’s already sometimes just too expensive to start a new process to handle untrustworthy data.

No matter whether Rust or Kotlin will become the language of choice, both are backed by LLVM which will ultimately become an even more important piece of technology.

Chromium, Rust, Kotlin, Java

TUXEDO Book BA15, a Linux notebook from Germany

It's running and running and running and running and ... The almost only way to stop the TUXEDO Book BA15 is to switch it off. Sounds odd? Well, our BA15 combines AMDs incredible power-efficient Ryzen 5 3500U mobile processors with a huge 91Wh battery for groundbreaking runtimes whilst providing strong performance for all everyday tasks. Groundbreaking battery runtime thanks to its 91 Wh capacity Due to its very large 91,25 Wh battery the TUXEDO Book BA15 is even able to reach maximum runtimes of up to 25 hours in power-saving idle mode. Even in more practical every day situations the 15.6 inch laptop lasts for very long times, so that you can do your daily work, websurfing, mail-writing and such things for up to 13 hours, even 1080p videostreaming at 50% of display brightness results in up to 10 hours of battery life.

For the Linux user base to grow, it needs to become a commercially viable option that comes pre-installed alongside notebooks for professionals.


Microsoft builds a Wayland compositor as part of its Linux on Windows endeavor

In term of presentation, I need to clarify a few things. We announced today that we're also adding support for Linux GUI applications. The way this will work is roughly as follow. We're writing a Wayland compositor that will essentially bridge over RDP-RAIL (RAIL=Remote Application Integrated Locally). We're starting from a Weston base. Weston already has an RDP Backend, but that's for a full desktop remoting scheme. Weston draws a desktop and remote it over RDP... and then you can peek at that desktop using an rdp client on the Windows side. RAIL works differently. In that case our wayland compositor no longer paint a desktop... instead it simply forward individual visual / wl_surface over the RDP RAIL channel such that these visual can be displayed on the Windows desktop. The RDP client create proxy window for each of these top level visual and their content is filled with the data coming over the RDP channel. All pixels are owned by the RDP server/WSL... so these windows looks different than native window are they are painted and themed by WSL. The proxy window on the host gather input and inject back over RDP... This is essentially how application remoting works on windows and this is all publicly documented as part of the various RDP protocol specification. As a matter of fact, for the RDP server on the Weston side we are looking at continue to leverage FreeRDP (and provide fixes/enhancement as needed to the public project). Further, we're looking at further improvement down this path to avoid having to copy the content over the RAIL channel and instead just share/swap buffer between the guest and the host. We have extension to the RDP protocol, called VAIL (Virtualized Application Integrated Locally) which does that today. Today this is only use in Windows on Windows for very specific scenario. We're looking at extending the public RDP protocol with these VAIL extension to make this an official Microsoft supported protocol which would allow us to target this in WSL. We have finished designing this part in details. Our goal would be to leverage something along the line of wl_drm, dma-buf, dma-fence, etc... This compositor and all our contribution to FreeRDP will be fully open source, including our design doc. We're not quite sure yet whether this will be offered as a separate project entirely distinct from it's Weston root... or if we'll propose an extension to Weston to operate in this mode. We would like to build it such that in theory any Wayland compositor could add support for this mode of operation if they want to remote application to a Windows host (over the network, or on the same box).

Microsoft continues to invest into the interoperability of Linux and Windows. The only question remain who will benefit more from those contributions the Linux or the Microsoft ecosystem. Last but not least there is also the question of whether Microsoft pursues the strategy of feeding something before one consumes it alive.

DirectX, Windows, macOS, GNOME, Wayland

Oracle's GraalVM 20.1 Runtime with significant improvements

- "Significantly improved performance" for some benchmarks on JDK 11 due to synchronization fixes, helping some workloads as much as 50% better performance. - Their Java mitigations for the Intel Jump Conditional Code (JCC) Erratum is now only enabled for Intel CPUs needing the workaround and not all CPUs. - For GraalVM's JavaScript support the ECMAScript 2020 features are now enabled by default. The NPM package runner (NPX) is also now part of GraalVM distributions. - GraalVM Enterprise can now run C++ code in managed mode as part of GraalVM's LLVM runtime. - Performance improvements for Python along with other language compatibility enhancements.

Looks like the JVM becomes obsolete and a new battle between GraalVM & WASM arises.

Java, .NET, Kotlin, JDK, WASM

Microsoft to support GPU acceleration, Linux GUI apps on WSL2

Microsoft is promising to dramatically improve its Windows Subsystem for Linux (WSL) with GUI app support and GPU hardware acceleration. The software giant is adding a full Linux kernel to Windows 10 with WSL version 2 later this month, and it’s now planning to support Linux GUI apps that will run alongside regular Windows apps. This will be enabled without Windows users having to use X11 forwarding, and it’s mainly designed for developers to run Linux integrated development environments (IDE) alongside regular Windows apps.

The problem with the WSL voodoo is that it is 99% compatible. However the 1% has serious implications. Now people can easily been swallowed into the Microsoft ecosystem executing simple workloads and as soon as they try something serious, they quickly recognize it does not work and have to revert to Windows-native ways of doing something. One crucial example: you cannot delete a file that is used by a process on Windows; on Unix you can. Hence applications like Gradle do not work when being used by a Windows & Linux process at the same time.

Linux, Microsoft, Windows, WSL

A small step for Lenovo but a big step for Linux

This Summer, Lenovo will unleash a trio of new ThinkPad laptops powered by Fedora 32. It will be a substantial boost for Linux visibility, and Lenovo’s vocal endorsement is a step in the right direction for establishing desktop Linux as a viable alternative to Windows for creators, developers, and everyone in between. But you probably already knew all this. What you don’t know is the steps Lenovo and Fedora — and by extension Red Hat — are taking to truly treat Linux as a first-class citizen when these systems launch.

Probably one of the most significant steps in the past few years for making Linux accessible to a much broader user base. If this gains momentum, Linux might have potential to a 10% user base within the next two years, growing 10x.

Linux, macOS, Notebook, Dell

Power saving improvements for latency-sensitive tasks on Linux

IBM engineers have been working on improvements to the Linux kernel's power savings while running latency-sensitive tasks but still delivering comparable performance. Their own numbers for a patched kernel are showing significant power saving benefits as much as ~20%. The new patch series builds off earlier work published by IBM on providing a per-task "latency_nice" knob for scheduler hints. Latency_nice can be used for indicating latency requirements of a given task so the scheduler can make better decisions. With that latency_nice work published over recent months, among the use-cases talked about there was for better turbo/boost frequency decisions based upon grouping of tasks with similar latency requirements. Additionally, hypothetically having the scheduler not assign low-latency tasks to a CPU encountering AVX-512 based workloads where generally the core frequencies become quite limited.

Let's hope, the improvements will actually materialize in one of the next kernel releases soon!

Linux, macOS, Notebook

Valve's SteamVR has ended macOS support to focus on Windows and Linux.

And let’s not forget that the writing is on the wall for macOS as a general purpose operating system anyway, since Apple will most likely use the move to ARM processors in Macs to further lock down macOS, making it more like iOS. While macOS might be more popular than Linux in absolute numbers, the cold and harsh truth is that the Linux userbase simply has a far larger group of skilled developers, programmers, and tinkerers willing to put the effort into making non-native games work on Linux and to improve support for things like VR devices. These are exactly the kind of people Apple seems to have a deep-rooted disdain for. Expect more of these kinds of announcements over the coming years, as game companies (and other developers) have to decide whether or not to support an isolated and locked down platform like macOS on ARM – a platform without first-party OpenGL or Vulkan support, with a steward actively pushing you to use a proprietary API that you can’t use anywhere else.

Apparently it became too risky for Valve to bet on a very specific and Apple-exclusive set of APIs for game development. Despite Apple users being a consumption friendly base, their spending need to justify the extra efforts to maintain an exclusive development branch that cannot be reused on Linux or Windows.

Gaming, Linux, macOS, Vulkan, OpenGL

High-end Lenovo notebooks with pre-installed Fedora Linux

Today, I’m excited to share some big news with you—Fedora Workstation will be available on Lenovo ThinkPad laptops! Yes, I know, many of us already run a Fedora operating system on a Lenovo system, but this is different. You’ll soon be able to get Fedora pre-installed by selecting it as you customize your purchase. This is a pilot of Lenovo’s Linux Community Series – Fedora Edition, beginning with ThinkPad P1 Gen2, ThinkPad P53, and ThinkPad X1 Gen8 laptops, possibly expanding to other models in the future. The Lenovo team has been working with folks at Red Hat who work on Fedora desktop technologies to make sure that the upcoming Fedora 32 Workstation is ready to go on their laptops. The best part about this is that we’re not bending our rules for them. Lenovo is following our existing trademark guidelines and respects our open source principles. That’s right—these laptops ship with software exclusively from the official Fedora repos! When they ship, you’ll see Fedora 32 Workstation. (Models which can benefit from the NVIDIA binary driver can install it in the normal way after the fact, by opting in to proprietary software sources.)

Let's hope it will not remain a niche offering or become an one-off shot from Lenovo and Fedora. The nerdy Linux community proofed several times that it does not understand the market or the vast majority of business users who - in their vast majority - want a macOS experience and not a do-it-yourself tinker gadget nightmare.

Being a dedicated Linux user myself, I see the Linux community, in their vast majority just does not consist of pragmatic business users but dogma-driven idiomatic oddballs. Yes, not everybody... I know, please let me alone with the problems of generalization. I am talking about hard statistics here and a lot of personal life experience.

Fedora, Linux, Ubuntu, Mac, macOS

The WebGPU capability might bring ML/AI to the browser

WebGPU is an emerging API that provides access to the graphics and computing capabilities of hardware on the web. It’s designed from the ground up within the W3C GPU for the Web group by all major browser vendors, as well as Intel and a few others, guided by the following principles:[...] We are excited to bring WebGPU support to Firefox because it will allow richer and more complex graphics applications to run portably in the Web. It will also make the web platform more accessible to teams who mostly target modern native platforms today, thanks to the use of modern concepts and first-class WASM (WebAssembly) support.

WebGPU aims to work on top of modern graphics APIs: Vulkan, D3D12, and Metal. The constructs exposed to the users reflect the basic primitives of these low-level APIs. Let’s walk through the main constructs of WebGPU and explain them in the context of WebGL – the only baseline we have today on the Web.

Java is struggling to support GPUs for years already. It looks more and more that WASM will become the bytecode of a new IT era.

HTML5, Vulkan, OpenCL, AI/ML

Java 14 performance is improving a lot, GC times go down

Over the last 6 years, since JDK 8 was released, the Java platform has evolved a lot. I will not go into details, but one thing is certain, the overall performance has improved a lot. One big change we made in JDK 9 was to make G1 the default garbage collector. Parallel GC, the old default, focused on raw throughput and this change shifted the platform towards a more balanced model where latency is as important as throughput. G1 is designed to avoid the long occasional full collections that eventually occur with a stop-the-world collector, like Parallel GC. To achieve this G1 does parts of the collection work concurrently with the Java application. This comes with a slight throughput cost and it becomes extra visible in benchmarks only measuring throughput. If people observed a performance drop when migrating from Java 8 to a later version of Java, this was the main reason, i.e. a shift in the GC approach to be more latency and throughput balanced. Applications that want maximum throughput can switch back to Parallel GC (by using JVM option -XX:+UseParallelGC) and take advantage of all other performance improvements JDK 14 comes with.

Probably the biggest disadvantage of Java vs C/C++ is not the performance penalty (of GC) as an average Java app would outperform an average C/C++ app, anytime as Java makes it easier to write performant code than C/C++. However the garbage collector of Java causes interruptions that are unacceptable for some scenarios. With this improvements, the GC times have been reduced so much that the biggest disadvantage is not its biggest disadvantage anymore.

Java 14, Java 15, Performance, Benchmark

Web tech displaces and pervades native tech

Google is replacing some Android apps for Chromebooks with Progressive Web Apps (PWAs). A PWA is essentially a webpage that looks and feels like a traditional app. This will certainly be good news for many Chromebook owners. In some cases, PWAs are faster and more functional than their Android counterparts. PWAs also take up less storage and require less juice to run. It’s also no secret that some Android apps on Chrome OS are terrible. Google has struggled for years to optimize Android apps to work on tablet-sized screens. And while the viable selection has certainly improved since the Pixelbook days, there are still a number of programs notorious for not playing nice. Even though PWAs have been available for a while, it’s likely that some users didn’t know how to get them or why they were a better alternative. Some users also just prefer getting all of their apps with the same process. (I certainly do.)

A step that is long due. Also I do not know why Google is going slower in bringing even more web tech to Android & Chrome OS devices. For Kotlin fans: This won't mean Kotlin would lose influence but rather that KotlinJS could gain more traction.

PWA, Web, WASM, WebAssembly

Microsoft buys a real-time OS

Microsoft’s 2019 acquisition of Express Logic brought its ThreadX real-time operating system into the Azure fold. Now branded as Azure RTOS, it’s an industrial-grade, real-time operating system for devices that fit somewhere between Arduino and Raspberry Pi, needing more than firmware but less than a full Azure Sphere-like Linux. The OS adds to Microsoft’s edge compute capabilities, already running on more than two billion devices. At the heart of Azure RTOS is the ThreadX picokernel. It’s designed to scale across a range of hardware, with a customizable deployment image that only bundles the services needed by your code. Those services are implemented as a C library, simplifying building and delivering runtime code. The kernel is distributed as C source code, so it’s possible (though not recommended) to modify it to deal with specific hardware or application requirements. Services run side by side as threads—they don’t layer—allowing ThreadX to be optimized for speed and for switching between services. Performance is essential, as real-time operating systems need to respond quickly to event-driven inputs as they often operate in safety-critical roles.

Microsoft acquires yet another company for its product. This time it is Express Logic that is behind its ThreadX picokernel. For corporations its all about their product portfolio. At the C-level technology, banking and manufacturing, they all look the same from 10 km above.

Windows, RTOS, Azure

Online repair comes to the Linux file-system XFS

Please pull this first batch of new changes for 5.7. There's a lot going on this cycle with cleanups in the log code, the btree code, and the xattr code. We're tightening of metadata validation and online fsck checking, and introducing a common btree rebuilding library so that we can refactor xfs_repair and introduce online repair in a future cycle. We also fixed a few visible bugs -- most notably there's one in getdents that we introduced in 5.6; and a fix for hangs when disabling quotas. This series has been running fstests & other QA in the background for over a week and looks good so far. I just did a test merge and it seems to go in cleanly, so please let me know if you encounter any surprises. I anticipate sending you a second pull request next week. That batch will change how xfs interacts with memory reclaim; how the log batches and throttles log items; how hard writes near ENOSPC will try to squeeze more space out of the filesystem; and hopefully fix the last of the umount hangs after a catastrophic failure. That should ease a lot of problems when running at the limits, but for now I'm leaving that in for-next for another week to make sure we got all the subtleties right.

Over the past few quarters XFS got a lot of polish and keep evolving at a fast pace. I might consider switching from ext4 to XFS once I switch to a new notebook this year. Also ext4 is very mature and performant and I have never lost any data despite several power-offs and hard-resets that happen quite a lot on a Linux desktop.

XFS, Linux, File-system

SEO: nofollow vs ugc vs sponsored

Nearly 15 years ago, the nofollow attribute was introduced as a means to help fight comment spam. It also quickly became one of Google’s recommended methods for flagging advertising-related or sponsored links. The web has evolved since nofollow was introduced in 2005 and it’s time for nofollow to evolve as well. Today, we’re announcing two new link attributes that provide webmasters with additional ways to identify to Google Search the nature of particular links. These, along with nofollow, are summarized below: rel="sponsored": Use the sponsored attribute to identify links on your site that were created as part of advertisements, sponsorships or other compensation agreements. rel="ugc": UGC stands for User Generated Content, and the ugc attribute value is recommended for links within user generated content, such as comments and forum posts. rel="nofollow": Use this attribute for cases where you want to link to a page but don’t want to imply any type of endorsement, including passing along ranking credit to another page.

This is a good approach to enrich the web with semantics even though the ranking implications will keep evolving. One concern is how many sites will actually apply these link relation attribute values when they do not know their implications clearly.

Web, Google, SEO

Shenandoah - a low-pause-time garbage collector proposed for production in Java 15

In JDK 12 and later, Shenandoah is enabled via the -XX:+UnlockExperimentalVMOptions -XX:+UseShenandoahGC options. Making Shenandoah a product feature means that -XX:+UnlockExperimentalVMOptions would no longer be needed. A bunch of related Shenandoah options would turn from "experimental" to "product", subject to review. The default values for the options would not change. It makes this change a rather cosmetic change in flag classes. At the time of its integration into JDK 12, Shenandoah had been already shipping in Red Hat 8u and 11u downstream releases as a supported garbage collector, and used by RHEL and RHEL downstream users. Because of this, Shenandoah 8u and Shenandoah 11u are already non-experimental and thus not affected by this change. Since there are only a few users that run something other than 8u and 11u, we expect the actual impact of this change to be minuscule.

GC1 remains the default general purpose garbage collector in Java 15. However this option is really nice for scenarios where a trade-off between overall throughput and latency needs to be made. Remember engineering is always about making appropriate trade-offs between two desired attributes of which one is more important than the other.

Java, Garbage Collector, Realtime, Java15

After crushing Intel in the server segment, AMD finally crushed Intel in the desktop segment

To put AMD’s Ryzen 4000 in perspective, you have to understand that in AMD’s 50-year history, it has never beaten Intel in laptops. It’s won a few battles in desktop: Athlon, Athlon 64, and the current desktop Ryzen chips. AMD’s fortunes change dramatically with the Ryzen 4000 chips, which are clearly the new leader in performance laptops. Even more astonishing is AMD’s ability to offer so much performance in such tight thermal and power constraints. While a comparably thin Intel-based laptop would have to crank up fans to annoying levels, the Ryzen 9 4900HS can do so with relatively moderate fan noise. Worse news for Intel, AMD’s Ryzen 4000 can spar with laptops that weigh two to even three times as much. This is something we frankly didn’t expect. Ryzen 4000 is without a doubt the most game-changing performance laptop CPU we’ve seen in years.

AMD’s Ryzen 9 4900HS has totally crushed Intel's top line i9 CPUs while having a lower TDP of just 35 watts! However, it might be still too late for AMD as the time of the x64 architecture on the desktop comes to its end and ARM CPUs are pushing the boundaries.

Intel, CPU, AMD

MLIR is probably the most significant addition in LLVM v10

MLIR is intended to be a hybrid IR which can support multiple different requirements in a unified infrastructure. For example, this includes: MLIR is a powerful representation, but it also has non-goals. We do not try to support low level machine code generation algorithms (like register allocation and instruction scheduling). They are a better fit for lower level optimizers (such as LLVM). Also, we do not intend MLIR to be a source language that end-users would themselves write kernels in (analogous to CUDA C++). On the other hand, MLIR provides the backbone for representing any such DSL and integrating it in the ecosystem.

MLIR addresses software fragmentation and serves as a glue between traditional languages that target LLVM - like Kotlin. MLIR opens up the Machine Learning space to languages beyond Python. MLIR is a kind of WASM that opens up the browser runtime to languages beyond JavaScript.

TensorFlow, LLVM, MLIR

Benchmark: GraalVM vs OpenJDK vs Amazon Corretto JVM, featuring Java 8, 11, and 14

When taking the geometric mean of the 32 tests that were carried out, OpenJDK 8 upstream actually came out the best overall followed quite closely by GraalVM 20.0 Java 8. Meanwhile the Java 11 version of GraalVM 20.0 was by far the slowest. On the Amazon Corretto front, version 11 was quite similar to OpenJDK 11 upstream but its Java 8 implementation was coming out similar to that slower Java 11 milestone.

There is little surprise that GraalVM 20.0 Java 8 performed best as Java 8 had a long time to mature, also even further within GraalVM. Still among the newer JVM implementations the reference OpenJDK 14 Java VM performed quite decent.

Java, GraalVM, Benchmark

Nashorn JavaScript engine is being removed in Java 15

Remove the Nashorn JavaScript script engine and APIs, and the jjs tool. The engine, the APIs, and the tool were deprecated for removal in Java 11 with the express intent to remove them in a future release. The Nashorn JavaScript engine was first incorporated into JDK 8 via JEP 174 as a replacement for the Rhino scripting engine. When it was released, it was a complete implementation of the ECMAScript-262 5.1 standard. With the rapid pace at which ECMAScript language constructs, along with APIs, are adapted and modified, we have found Nashorn challenging to maintain.

This does not mean that you will not be able to run JavaScript using Nashorn with Java 15. However it does mean that you will need an extra dependency to do this which is going to be Nashorn itself. Nashorn will be simply removed from the standard Java runtime.

Java, JavaScript

YouTrack vs Jira and why Jira is the Microsoft Teams among issue trackers

Reports generated by YouTrack are more flexible too. For example, you can create a matrix report for multiple projects using any of their issues’ fields for X and Y axes. In Jira you can do it too — if you buy an appropriate plugin. However, sometimes they lack basic information about time tracking and time management. In Jira we have used a plugin called “Tempo” which has given us — both developers and managers — a nice view of time spent on work. Unfortunately, YouTrack’s reports for that are less clear. But there is an issue for that awaited by more people, so hopefully JetBrains will upgrade this part of reports-making in the future.

Just because so many people are using Jira, it tried to satisfy far too many needs over time and ended up not satisfying any particular use case. Whereas YouTrack is sharp, precise and brings pleasure & joy to project and software management.

Issue Tracker, Comparison

Rust-based Redox OS is getting yet another package manger that is capable of atomic updates

It has been a while since the last Redox OS news, and I think it is good to provide an update on how things are progressing. The dynamic linking support in relibc got to the point where rustc could be loaded, but hangs occur after loading the LLVM codegen library. Debugging this issue has been difficult, so I am taking some time to consider other aspects of Redox OS. Recently, I have been working on a new package format, called pkgar.

The only things that make Redox OS special and gives it a chance to compete long-term with Linux is Redox' syscall API & ABI compatibility with Linux.

Linux, Rust, OS

Clear Linux is probably still just Intel's toy Linux

We, Intel, work with many Linux distros pretty intensely on hardware support and performance and many other things. Many of our customers nowadays have Linux distros of their own rather than using a "standard" distro as is. For many reasons, we also build Clear Linux. By knowing what it takes to get features into a Linux distro (our own) it's easier for us to work with others who are/have a distro. We also want to make sure we can do the best performance etc etc... and sometimes that means doing experiments that are only possible if you have your own distro in house. Now on Desktop... based on a lot of history (Moblin/Meego/...) we know that it is very hard to do a "general consumer desktop", and we tried something different, aim JUST at software developers (e.g. advanced technical users not afraid of a command line who write code but also generally have more modern, higher quality hardware) and do a very narrow thing that was hopefully more tractable. Turns out that there is no such thing really, people expect, almost demand, that any obscure piece of hardware "just works" (often stuff we can't even buy anymore to test it etc) and... well we got asked for 15+ different desktop environments etc etc... an infinity of "weird stuff" that has nothing to do with "developer". We have been trying to accommodate those as much as we can, but there are clear limits because we also do not want to just throw junk over the wall. It also means we are likely going to change a bit how we work, rather than "everything" we need to make sure that what we do ship is usable, with a bias to servers and what developers use rather than "random stuff". With the 3rd party repo stuff getting more ready, there's ways where others can provide their own repositories for "weird stuff" without us being a bottleneck.

I do not even question whether it is a good idea to depend on a Linux distribution of a vendor that has absolutely not interest on supporting its competitor's hardware as good as its own... What I question is why should I depend on a Linux distribution that also does not belong to the RPM nor the DEB package manager camp? Clear Linux' package manager might be nice and fast and have many whistles and bells but it will make you invest quite some time as soon as you find something you want to install and that is not provided for their package manager.

Linux, Software Development