HNHacker News
TopNewBestAskShowJobs

uxcn

235 karma · joined January 6, 2015

https://twitter.com/uxcn_
submissionscomments
uxcn··on Use Atom to edit in Chrome
I'm still sad Pterosaur [1] is no longer maintained.

[1] https://github.com/ardagnir/pterosaur

uxcn··on Meet LKL: Turn Linux Kernel into a Library
Since software will be linking directly against LKL, does this mean it also needs to be GPL? Will the same symbol restrictions apply?
uxcn··on Please don't use Slack for FOSS projects
A lot of the alternatives are mostly extensions to the IRC concepts though (group chat, #hashtag, private chat, mentions, etc..). If all you need is text, IRC is fine.

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.

[1] https://www.bitlbee.org/main.php/news.r.html

uxcn··on Please don't use Slack for FOSS projects
The nice thing with IRC is that it's scriptable. So for example if you want a klaxon to sound every time the secret word is mentioned, it's easy to do.
uxcn··on Systemd mounted efivarfs read-write, allowing motherboard bricking via 'rm'
It is. Various optional things from POSIX are missing though (https://github.com/uxcn/yafd/blob/master/src/c/pthread-dw.h).
uxcn··on Systemd mounted efivarfs read-write, allowing motherboard bricking via 'rm'
> It's entirely possible that Apple takes code or inspiration from the Linux software project, but I think it's better to say that OS X is Unix based.

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.

uxcn··on Systemd mounted efivarfs read-write, allowing motherboard bricking via 'rm'
No, OSX is based on NeXT, which was based on Mach, and BSD. As far as I know, iOS is proprietary.
uxcn··on Systemd mounted efivarfs read-write, allowing motherboard bricking via 'rm'
Linux is just source for a kernel that the userland for the various distributions are built on though. It's already largely on people's phones with Android. In fact, Chrome OS is based on Linux.
uxcn··on The Problem with Putting All the World’s Code in GitHub (2015)
Git's definitely an improvement over Subversion (CVS, etc...). Without the commit history there's a lot you couldn't do (e.g. bisect stuff), but things would still be workable. Distributed models are almost always more robust than centralized ones 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.

uxcn··on Jonathan Blow's new game, The Witness, is out
Some of it might have to do with familiarity. Working in * nix, you tend to combine tools to do stuff, whereas with Windows or OSX everything is normally only a few clicks away. I think it's probably a bit of a barrier for using * nix coming from something else. I'm personally used to it though, and it's a lot more productive for me than Windows. That's not to say there are a lot of tools that unfortunately just don't exist yet.
uxcn··on Microsoft's forthcoming Minecraft Education Edition is written in C++
NIO was 1.5. Before that, a lot of network programming wasn't practical where performance was a concern. I would guess it was the same with Linux before 2.6.
uxcn··on Microsoft's forthcoming Minecraft Education Edition is written in C++
Thanks, I actually missed this. The difference with modifying OpenJDK is that it's a common codebase as opposed to a language fork.

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.

uxcn··on The Problem with Putting All the World’s Code in GitHub (2015)
Losing code wasn't really a risk with Sourceforge either. Submitting patches on mailing lists or controlling access to using SSH will always be workable. The benefit of Github is the directory and collaborative aspect.

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.

uxcn··on Microsoft's forthcoming Minecraft Education Edition is written in C++
The earliest version of Java I worked with in production was 1.5, but the group I was working with had been using it in production a long time before that. There were other groups using Java for a lot of other things (JDBC, JMS, etc...). All the stuff I worked with relied on core Java and NIO though, which I'm not entirely sure how a lot of things were done before 1.5.

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.

uxcn··on Microsoft's forthcoming Minecraft Education Edition is written in C++
Even before 0x, a there was definitely a genuine performance need that drove a lot of stuff from Java to C++. A lot of people I know would write Javaish code with Boost.

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).

uxcn··on The limitations of sampling profilers
The main problem the article is talking about is tracking 99th percentile issues (e.g. tail latency) which, given the nature of sampling is difficult to capture otherwise.

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.

uxcn··on It’s Time to Open Up the GPU
Video encoding also might also be worth putting effort toward. There are probably a lot fewer people using GPUs for video encoding than for linear algegra, but it's still something nobody is currently doing with open operating systems or otherwise really. If AMD did it, I think people would take notice. nVidia started adding APIs.

Video encoding on CPUs is extremely inefficient and essentially precludes on-demand encoding.

uxcn··on Microsoft's forthcoming Minecraft Education Edition is written in C++
It's still popular. For example, LMAX still uses Java. There were a number of things you needed to avoid if you wanted to use it where latency mattered though. GC pauses are fairly detrimental.

Where latency is really critical, things are implemented in FPGA though.

uxcn··on Microsoft's forthcoming Minecraft Education Edition is written in C++
Around Java 7, there was experimental support for scalar interpolation. I'm not sure how it progressed though.
uxcn··on Microsoft's forthcoming Minecraft Education Edition is written in C++
I would guess a lot of stuff wasn't completely POSIX either (still kinda true). It's really only recently C++ added a standard memory model, portable threading, etc... POSIX is even kind of falling behind for this stuff IMHO.
uxcn··on Microsoft's forthcoming Minecraft Education Edition is written in C++
Not that I prefer Java where performance is important, but profile based optimization combined with optimizing across translation units is non-trivial. C/C++ compilers have been increasing support for these more recently. Jan Hubicka's blog has a good example [1].

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...

uxcn··on World's Fastest Rubik's Cube Solving Robot [video]
How are times compared for rubik's cube bots? I would guess there's some variance even for the same bot solving the same cube from the same state.

It might be interesting to see a competition based on number of moves.

uxcn··on Unikernels are unfit for production
It's not the same as using something like DTrace on a live system, but he's describing it as though eliminating the flexibility implies some sort of event horizon.

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.
uxcn··on Unikernels are unfit for production
I think Bryan Cantrill and Joyent are doing a number of interesting things, but this reads more like an ad than a genuine critique of Unikernels.

    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.
uxcn··on Non-volatile Storage: CPUs no longer more performant than I/O devices
I think Altera had more to do with generic user modifiable compute. They have been working with FPGAs for a while now (http://www.enterprisetech.com/2014/06/18/intel-mates-fpga-fu...).
uxcn··on Non-volatile Storage: CPUs no longer more performant than I/O devices
One of the other constraints is the actual data copy. I don't have any benchmarks on hand, but you pay the penalty for the copy, potentially cache misses, and the potential TLB miss. Obviously, there are ways to avoid it without resorting to bypassing the kernel, but there's still a non-negligible cost.

Maybe it would be beneficial to have a coherent interface as well, considering NVMe.

uxcn··on WebExtensions in Firefox 45
Native.js is interesting. I would wonder how it plans to handle things like callbacks for various events though. As an example, a keypress in a textbox (e.g. pterosaur). I haven't looked at the WebExtensions API in detail yet, so it may already be a solved problem.

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.

uxcn··on WebExtensions in Firefox 45
I understand, and even agree with, a lot of the goals behind the WebExtensions API. I'm honestly still worried firefox isn't going to encourage plugins like pterosaur, pentadactyl, etc.. going forward.

Will modifying the UI and the DOM essentially be verboten?

uxcn··on Show HN: Ampache – Self-hosted personal music and video streaming server
I think the last version I used was 3.5.4, it looks like a lot changed since then. I'm glad to see MusicBrainz support got added. Ampache was definitely a nice way to organize and stream stuff.
uxcn··on Calculating integer factorials in constant time, taking advantage of overflow
I honestly haven't heard the term constant time used in a context other than asymptotic in computer science, even in relation to side-channels. I think this is the way the majority of people use the term. I worry that trying to use it another way will probably just confuse people, not to say I don't think it isn't a valid concept.

In relation to side-channel attacks, wouldn't it be sufficient to just pad the difference between upper and lower bounds using no-ops?

← PreviousPage 3 of 10Next →