235 karma · joined January 6, 2015
I actually use a number of things through BitlBee [1] just to combine everything into one client. Scripting things in python is also fairly useful.
Apple can't take code from Linux as the code is GPL licensed. OSX is largely based on NeXT and BSD. Linux and OSX are both POSIXish though.
As I understand it, the main benefits are still risks though (e.g. central directory). The code itself isn't really at risk, especially with signed commits.
I know Redhat is one of the other major OpenJDK contributors, and a lot of distributions are relying on IcedTea. It will be interesting to see how this develops.
It's much easier for people to contribute to projects now, and a lot of projects might not have grown as quickly without it. The central directory also makes it a lot easier for other people to find stuff which probably also plays a role.
I doubt Github will go down the same path as Sourceforge.
Java is definitely still really popular for development overall (TIOBE 2015 #1). My personal concern with Oracle vs. Google though is that Oracle does not own the language, and the copyright claim on APIs seems pretty aggressive. The JVM and Java have open specifications which in theory anyone should be allowed to implement (practice is admittedly a bit different). Even the official JDK was open source, which Oracle seems a bit hostile toward considering what they've done with purchases like MySQL and how the community largely responded.
Claiming copyright on an API seems somewhat akin to Keurig 2.0. Although, I think courts are having trouble keeping pace with technology.
A lot of the stuff that makes Java great for building high level systems quickly is still kind of missing from formal C++ though (IoC, JMX, etc...), and it would have been nice to see some of the internal stuff get open sourced.
I wonder if people are starting to avoid Java because of Oracle (e.g. vs Google).
Overhead is an issue with instrumentation, but as the article mentions, there are a number of clever ways to minimize it. Some simpler examples are physical probing and dynamic instrumentation. FTrace might be a nice example of instrumentation on Linux worth looking at.
Video encoding on CPUs is extremely inefficient and essentially precludes on-demand encoding.
Where latency is really critical, things are implemented in FPGA though.
I have to wonder if they plan to keep the codebase portable though. One of the major benefits of Java was that nearly everything has a JVM.
[1] http://hubicka.blogspot.com/2014/04/linktime-optimization-in...
It might be interesting to see a competition based on number of moves.
This also bothered me...
virtualizing at the hardware layer carries with it an inexorable performance tax
Hardware has been adding a lot of virtualization support over the last decade, and it's generally been a net performance gain as far as I'm aware. I could see things like IO scheduling potentially being an issue. Although, IO performance on top of operating systems in general does not particularly inspire confidence. The primary reason to implement functionality in the
operating system kernel is for performance: by avoiding
a context switch across the user-kernel boundary,
operations that rely upon transit across that boundary
can be made faster.
I haven't heard this argument made once. There are performance benefits (smaller footprint, compiler optimization across system call boundaries, etc...). However, the primary benefit is not performance from eliminating the user/kernel boundary. Should you have apps that can be unikernel-borne, you
arrive at the most profound reason that unikernels are
unfit for production — and the reason that (to me,
anyway) strikes unikernels through the heart when it
comes to deploying anything real in production:
Unikernels are entirely undebuggable.
If this were true, and an issue, FPGAs would also be completely unusable in production.Maybe it would be beneficial to have a coherent interface as well, considering NVMe.
More specifically, editing text seems oddly neglected, which is disappointing considering webmail, blogs, social media, stack overflow, etc... I'm glad noscript is being given special consideration.
Will modifying the UI and the DOM essentially be verboten?
In relation to side-channel attacks, wouldn't it be sufficient to just pad the difference between upper and lower bounds using no-ops?