HNHacker News
TopNewBestAskShowJobs

ISV_Damocles

571 karma · joined September 26, 2012

submissionscomments
ISV_Damocles··on Linux distro creator tries to enforce a trademark he doesn't own
This has certainly soured my view of the Elementary OS project. Someone has created a project to help himself and other users and chose an obvious name for it, then a representative from the company behind it wants the name changed and threatens legal action if they don't?

Regardless of the actual trademark status at hand, they decided that they would rather burn a bridge with a dedicated user who spent their free time to improve their product and in a way to provoke fear of legal costs. Why wouldn't he look for supporting data to offset that legal threat?

They're literally abusing the power imbalance in this situation to try to get things done their way, and I don't understand how anyone in here is siding with them?

ISV_Damocles··on Positive Energy Warp Drive from Hidden Geometric Structures
Here's why I believe you are being downvoted:

1. The original topic was about Ender's Game only, not the entire series, so you basically shifted the goalposts. 2. More importantly, I think you are using the wrong literary terminology and you and the others are talking over each other. Where you say "plot point" I believe you meant "plot device."

The Ansible is definitely the primary plot device that makes so much of the story and how it flows possible, but the ansible is not the point of the plot itself.

Throughout Ender's Game the plot point is reinforced that the rules of civilization will be broken when a credible threat shows itself. That is shown with the various physical conflicts Ender has with the other children at the individual level, it is shown with the tolerance the military has in order to shape Ender at the organizational level, and it is shown with the vilification of Ender so society at large does not have to grapple with just how badly it broke its own rules - so it can be done again if necessary for survival.

ISV_Damocles··on So you want to build a generator (programming)
Maybe `(graphics programming)` would be better, because I assumed it was for generator functions.
ISV_Damocles··on A brief history of Rust at Facebook
> That requires a lot of people to be using older versions, that is, it assumes there's an audience of people who are interested in using older Rusts. But we don't have that in Rust, even if it was that way with Node. Look at this chart from our survey last year: https://blog.rust-lang.org/images/2020-12-rust-survey-2020/r...

So I would cite the classic statistics example of adding armor to the parts of returning aircraft that weren't shot up: https://worldwarwings.com/the-statistics-that-kept-countless...

That survey (that I wasn't aware of despite using Rust) likely self-selects the most enthusiastic users of Rust. There could certainly be a large number of other users, or potential users, that would answer things differently.

> This is controversial, because in some sense you're not wrong, but this also creates a lot of churn, and churn that doesn't really have to happen. In a model where most folks target the latest stable, you're creating tons of work for most of your users, at the expense of making things slightly better for a very small number of users.

I don't agree that it's that much extra work? As a user running `cargo update` should be enough and the versions increase. If cargo refused to update to a version beyond the currently installed `rustc` version, then this should be completely safe on their end.

Then the library authors can either do what they currently do and not backport features/patches for earlier Rust implementations, or they can if they want to support those users (so no extra work is required), but now it's very clear to them (based on download stats on crates.io) how much demand for prior rust compilers there is, and they can decide if they want to provide a stronger backwards compatibility for their library, and the users can tell based on the semver releases for the library if that library supports older versions of `rustc` or no.

This is still personally one of my more minor complaints about the Rust ecosystem. It's still far better done than most other major languages, and the current state of Cargo/crates.io was a major factor in our picking Rust over C++ for the project we're using it for. So this is a critique because I do actually care about this and see how it could help both adoption (less worry about "what's the right version of Rust to use?" for newbies) and long-term maintenance (if you can't come to a project a few months later and install any security fixes because there are library changes that require you to upgrade your compiler and there's a cascading set of dependencies-of-dependencies that make that riskier to do, so application-level developers may not want to jump on such a "treadmill").

ISV_Damocles··on A brief history of Rust at Facebook
I am still pretty new to Rust (about a year of usage), but I think there are ways to have this "forward compatibility" problem be a less significant impact in real world usage, though.

Node.js went through similar rapid development of the runtime as Rust is with the compiler. Node's package.json includes an "engine" field to indicate which runtimes are supported from which version, so NPM could immediately tell you if you were trying to use a library for a newer Node version than you have installed, and could automatically downgrade to an older version that still supported your Node version, if one existed.

That eliminates much of the pain of using libraries by others that are sticking to the latest release of the language.

But it also encouraged library authors to try to push that supported version number down as far as they could, because that would juice adoption of their library in the wild, further making forward compatibility less of an issue. (This isn't exactly apples to apples since most of the advances in Javascript the past decade have been syntactic sugar, not new powerful features, and there is a hard split on async/await versus callbacks as that was more of a feature than just sugar.)

In Rust, if libraries could broadcast their minimum Rust version in their crates, and treated changing that as a breaking change (major version bump), and were open to backporting features onto prior majors (for the bigger, important libraries), there can be a rolling drop-off of older versions of Rust instead of hard, unpredictable dropoffs.

ISV_Damocles··on The Turing-Completeness Problem
That's mostly correct. :) We used `do-while` to demonstrate that we could replicate the behaviors of a normal assembly language within the dependency graph representation.

However, we do have a restricted version of `do-while` implemented as described in the Sequential Algorithms RFC[1]. We want to push people into writing parallelizable code by having the default constructs and data types encouraging that, but we know certain algorithms are only possible in a sequential form, and some of them (like the Newton-Raphson method) are not predictable in the number of sequences to run so we have an escape hatch in the language that lets you do the classic iterative programming, but all of them wrapped in a maximum iteration counter so we'll still be able to assign a maximum expected runtime to them (and be sure they halt, perhaps with an error).

[1]: https://github.com/alantech/alan/blob/main/rfcs/007%20-%20Se...

ISV_Damocles··on The Turing-Completeness Problem
Yes, we didn't want to make this article too long or confusing, but we have a static, compile-time-defined event system[1] to allow for applications that wait for external inputs to start executing again. Each event handler is guaranteed to halt even if the application continues to run.

[1]: https://alan-lang.org/alan_overview.html#a-static-event-syst...

ISV_Damocles··on Why the Apple II Didn’t Support Lowercase Letters
So you don't need to distinguish keywords from variables by case when you have syntax highlighting, and lowercase has been shown to be faster to comprehend than uppercase while driving[0], so switching that metadata signal to a secondary channel (color of the text) seems natural. colorForth[1] was made on a similar premise to exploit that channel, but as a read-write rather than just read channel.

[0]: https://trid.trb.org/view.aspx?id=475144

[1]: https://en.wikipedia.org/wiki/ColorForth

ISV_Damocles··on [dead]
And the hilariously Orwellian statement to "increase" security by requiring Javascript to be enabled:

> The browser must have JavaScript enabled.

ISV_Damocles··on [dead]
Key Quote:

> The browser must not provide automation features. This includes scripts that automate keystrokes or clicks, especially to perform automatic sign-ins.

ISV_Damocles··on Show HN: Alan – An implicitly parallel programming language
There was a question earlier from someone who wanted to know how Alan compares to NESL and Fortress. We took too long to draft up our response and were surprised to find it deleted when we got back.

In case you're still lurking, we wanted to give you our answer. :)

Our array-level parallelism is very similar to NESL's, but we also include IO concurrency based on dependency graph analysis and a coarser Event-level parallelism. Fortress does share many similarities with Alan, including being able to declare your own operators, but is a runtime typed language while Alan is compile-time typed so we should have a higher performance "ceiling" in comparison. We're also owning the runtime entirely so we can make optimizations that a JVM-targeted language would not be able to.

ISV_Damocles··on Show HN: Alan – An implicitly parallel programming language
We think the design of the language will support that in the future, but we need to write a GPU-based runtime that lives inside of the runtime and get it to decide when to offload work to GPU first, and that will take time.
ISV_Damocles··on Show HN: Alan – An implicitly parallel programming language
Still working on those. :) We definitely beat Python, and we're faster than Node.js and Java at startup time. Where we are in the spectrum from C to Ruby we don't exactly know yet. But we do expect to improve and get much much closer to C as we make improvements to our runtime, such as writing a JIT for the VM.
ISV_Damocles··on Show HN: Alan – An implicitly parallel programming language
So we're very early and only do CPU parallelism right now, but we plan to tackle that problem domain in the future.
ISV_Damocles··on Trump Moves to Ban Foreign Telecom Gear, Targeting Huawei and China
Copying a product to reproduce bugs as well is exactly what WINE is all about. When bugs are part of your interface for others to integrate with, then I don't believe they should be considered off limits to copy. Otherwise an incumbent company could intentionally put in bugs, sue competitors to prevent them from implementing them, and effectively take over an existing standard.
ISV_Damocles··on Trump Moves to Ban Foreign Telecom Gear, Targeting Huawei and China
That's why I separated it out. The post I replied to made a blanket statement about IP law in general, which I think is currently very flawed and certain actions that Huawei and others have done with respect to patents I have no issues with.
ISV_Damocles··on Trump Moves to Ban Foreign Telecom Gear, Targeting Huawei and China
> (We should also not forget or excuse Chinese IP theft which has enabled Huawei to produce competitive products in the first place...)

I certainly can, because it would be hypocritical to be against Microsoft using IP rights as a bludgeon on Linux, Qualcomm on Apple, Oracle on Google, and then be upset with Huawei on anything but stealing trade secrets.

Patents have not helped the common man for at least a hundred years as companies have paid for dubious patents to bludgeon smaller competitors with. Copyrights have strangled the arts since Steamboat Willie and have prevented the public from deciding what stories they want to share.

Trademarks and Trade Secrets, however, seem mostly fine, as knowing the real origin of a product is a greater good for the public than letting copycats grift them, and being clever doing something should be rewarded but once it can be replicated, the competition heats up and again helps the general public with better quality goods and services.

ISV_Damocles··on Construct-JS – A library for creating byte level data structures
> It's funny because C opted to leave the number of bits machine dependent in the name of portability, but that turns out to have the opposite effect.

That depends on what you consider the portable part. In the era of proprietary mainframes operating on proprietary datasets, data portability probably didn't matter as much as code portability to perform the same sort of operation on another machine.

C's size-less `int`, `float`, etc allows the exact same code to compile on the native (high speed) sizes of the platform without any editing, `ifdef`s, etc.

(Side note: That's what bothers me a lot about the language wars -- the features of a language are based on the trade-offs between legibility, performance, and the environment from the era they were intended to be used in. Often both sides of those spats fail to remember that.)

ISV_Damocles··on Why Do So Many Egyptian Statues Have Broken Noses?
Breaking the nose to placate concerns about a supernatural phenomenon seems like the very definition of a ritual (placate concerns about a supernatural phenomenon) defacement (literally removing a surface feature from the face of a statue)?
ISV_Damocles··on Hexagonal Grids (2013)
Using H3 to analyze data originally indexed in different formats is definitely cool, but you can totally do that with S2 as well.

I personally feel the unidirectional edges[1] are a real differentiator. If you have these space-time buckets and compare counts between two points in time, you can see the change in density, but you don't know how active it is. Tracking transitions between hexagons in an anonymous, aggregated fashion lets you see if the "stagnant" areas of your map are stagnant because the actors actually aren't moving, or if there's a large "mixing" of the actors but you've reached a quasi-static-equilibrium in the system.

It also lets you see which regions are more connected to each other if, for instance, hexagon A always flows back and forth with hexagon B which also flows back and forth with hexagon C bordering both but no such flow between C and A, so from data you can spot potential rivers, deduce roadblocks/accidents, that certain businesses must be closed, etc.

[1](https://uber.github.io/h3/#/documentation/api-reference/unid...)

ISV_Damocles··on Hexagonal Grids (2013)
Thank you so much for your wonderful documentation. The H3 team at Uber used it so much for so many things. :)
ISV_Damocles··on Hexagonal Grids (2013)
I just want to make it clear that there's a real reason behind H3, not just "invent something really cool." I don't work at Uber, anymore, but I did work on the team that originated H3 and worked on H3.

To condense it down to a few bullet points, we realized:

1. We needed to move from geofences to a grid for both data science reasons and scaling reasons to perform realtime aggregated and anonymized activity analysis for things like surge pricing.

2. With a grid along with quantized time ranges (eg 10 seconds or 1 minute intervals) we can reduce data collection to distributed increments across a small cluster of machines with O(1) compute time rather than a more complicated R-Tree (O(log(n)) + Point-in-Poly (O(m)) system for geofences (that also can't backfill prior results when new geofences are added)

3. With a grid, data science can be assured of approximately equal area and time across these space-time buckets so normalizing the data for analysis between them is not necessary, regardless of where on the planet it came from (cross-city analysis and forecasting). With a hexagon grid, data science can also be assured that all neighboring cells are the same distance from each other and that all neighboring cells share a measurable edge rather than an infinitesimal point (like squares) so flow analysis between the cells is similarly simplified and needs no normalizing.

4. With a hierarchical hexagon grid we can quantize the data at the finest granularity (which is higher resolution than commercial GPS, about the size of a coffee table in diameter) and it can be rapidly reaggregated upwards to other resolutions (with some small error introduced since hexagons do not properly tessellate) for data science to determine what the "right" resolution is for the analysis at hand, then the realtime aggregating system can be updated to index at that resolution natively, as well, to improve bucketing accuracy (H3 resolution 9 was one such blessed coarser resolution).

When we determined exactly what we needed, we didn't invent it to feel like we did something really cool, we reached out to Dr. Kevin Sahr in academia to help us make it, who used part of his DGGRID code to do so[1], and then spent nearly 2 years to make sure everything was legal for open sourcing.

What we did at Uber was focus on getting his core more easily consumable: Request that the core does not allocate memory on its own, but is passed in memory (so integration with memory-managed languages would be much simpler), implement many of the algorithms described by Red Blob Games to make manipulation of the data in the grid system more amenable, update the build and test system to a more modern standard (CMake, code coverage, and unit tests), and write C bindings in various languages.

[1](https://uber.github.io/h3/#/documentation/overview/use-cases) (references the paper that covers the work he did)

ISV_Damocles··on Amazon DocumentDB, with MongoDB compatibility
Now I kinda hope Oracle decides to buy out MongoDB and integrate it into their own cloud. Then Oracle can decide to pull the same bullshit that they did with Google over the Java APIs with the MongoDB APIs but now against their current enemy Amazon (and Microsoft, too).

Then a combined Google + Amazon + Microsoft may finally be able to reverse the API Copyright insanity that is hovering ominously over the tech industry, and Oracle can continue to be a shining city upon a hill of shitty technologies you should never allow your business to adopt.

ISV_Damocles··on Facebook open-sources a speech-recognition system and a machine learning library
They probably squashed the history before release because they only got legal's approval on the current state of the repo and not all prior history (which may or may not have had hacks referencing internal systems at some time).
ISV_Damocles··on Google Tried to Patent My Work After a Job Interview
A common misconception! It's actually the science of the color cyan, but people kept mispronouncing "Cyantology". ;)
ISV_Damocles··on Internet Archive is adding in-browser emulation support for Commodore 64
From the Internet Archive FAQ: [0]

> The Internet Archive (Archive.org) is a nonprofit library that preserves digital cultural artifacts, and provides online access to over a million users a day with the goal of universal access to all knowledge.

Since it's a library, it has special copyright exceptions that make their emulation efforts legal, as Section 108 was updated to allow libraries to circulate digital copies of material online and off-premises. [1]

So it would have been a huge legal headache if they hadn't been given the explicit exception to do this.

Edit: oh, caveat that IANAL, but this was what was explained to me on another forum thread a couple of years ago when they first started their emulation efforts.

[0]: https://archive.org/about/faqs.php

[1]: https://crln.acrl.org/index.php/crlnews/article/view/8932/96...

ISV_Damocles··on Americans are changing their relationship with Facebook
Would be even better if you could filter on your end. Users just tag their posts; "Pets," "Kids," "Politics," etc and then you can uncheck any tags from a friend you're not interested in, but leave the rest as-is. Maybe all checked by default but you could uncheck a tag directly on the post that bothers you.
ISV_Damocles··on PepsiCo Is Acquiring SodaStream for $3.2B
I found that the Coke-alike syrup could taste a lot like Coke, but you had to add a little less than half the amount of syrup they recommend.

I eventually dropped it, though, because the CO2 canisters were too expensive and didn't want the hassle of modding it to use a rechargeable CO2 system (and the subsequent years of being tied to it to get back to a neutral return-on-investment versus just buying Coke).

ISV_Damocles··on Geospatial indexing on Hilbert curves
H3 has advantages in the analysis of the gathered data. Movement of users between cells is guaranteed to go through edges instead of points, so you can do flow analyses with electric current modeling.

A hex grid is the most efficient way to pack circles and is therefore the best "pixel" type to approximate radii, so simply choosing a hex size best matching the desired query radius can give you a very fast nearest-neighbor approximation.

And H3 retains all of S2's good features like hexagons following a curve (not the Hilbert curve, though) so hexagon IDs of similar value will more than likely be near each other, making range queries from a database still useful.

ISV_Damocles··on A Rust-Based Unikernel: First Version of a Rust-Based LibOS
I also agree that application -> cluster of machines is where we're going. I think it needs to be baked into an specialized programming language to really work well, though, and all of these things we rely on the OS for would have to be handled.

But unikernels running on top of a hypervisor seems like a terrible solution to the problem? You're trading away the convenience of the OS tooling that's built up over the past 40+ years to get closer to the metal and squeeze more performance out, then injecting virtualization in between and throwing that performance gain back away? Why not just make a regular application at that point and not throw away all of the runtime debugging support? A unikernel application running on top of a hypervisor basically turns the unikernel part into just an incredibly large and inefficient libc, in my mind.

← PreviousPage 3 of 5Next →