HNHacker News
TopNewBestAskShowJobs

wwwigham

674 karma · joined April 15, 2015

[ my public key: https://keybase.io/www; my proof: https://keybase.io/www/sigs/Z47alkN-fwsa7FlMQZTF9A24_7hjUiskAbc5coXsxkw ]
submissionscomments
wwwigham··on The Day AppGet Died
There's no common code between the projects; they're not even written in the same language. It's hard to say it's a "fork". They both just use yaml manifest files on GitHub as a registry (which could be good for appget! It should be easier to set it up as a trusted package registry with verified non-malicious packages!). That's the commonality. I'm not sure we should grant monopoly on _broad architure choices_ when software patents are already considered so toxic. And appget _did_ at least get a callout in the release announcement, so it _was_ mentioned as an inspiration, in the same breath as chocolatey and others...

The meat of this blog post, to me, seems like the terrible hiring pipeline with no feedback. That seems like a really bad experience. I can only imagine that someone really dropped a ball somewhere.

wwwigham··on The Day AppGet Died
I feel bad for the OP for getting ghosted by the Microsoft hiring process, I'd at least want a prompt response of _some_ kind; but the package manager features OP says are "copied" are common to cocoapods, homebrew, and others... Winget is certainly not the first, and probably won't be the last package manager to take that tack, so I don't find that appeal terribly compelling (The bad hiring process though... That's annoying). If winget is a "copy" of appget, it doesn't look like a very _good_ or _complete_ one at a glance, so the author could probably keep at appget, what with the publicity; winget doesn't even uninstall or upgrade packages (yet, at least), so it's just a glorified search bar strapped to msiexec (not to lessen anyone's effort or plans, software takes a lot of time and effort to build).

If the JS package manager scene has taught me anything, it's that so long as one another's manifests/registries are readable, developers will happily try multiple programs which actually do the managing, and, to some degree, a little competition is what actually makes things gradually improve. I, at least, hadn't heard of appget prior to today. (Just chocolatey and oneget, both of which I'd used, both of which are likewise "invalidated" by winget, but persist regardless.) But I can only reasonably consider it if its primary maintainer reconsiders its "dead" status.

wwwigham··on Microsoft's GitHub account allegedly hacked, 500GB stolen
To be fair, we had to file for exceptions to the 30 day policy for a lot those. Not that any of them are terribly important to be private; a private GitHub repo is just a convenient discussion form for collaboratively composing blog posts and such (change tracking and reviews are so nice). The blog post one, in particular, probably gets a pass because everything composed on it is eventually published in the open anyway (albeit without the discussion and editorial history).
wwwigham··on Chrome 80 Is 30% Slower Than Chrome 75
I haven't confirmed it with hard numbers yet, but I think these perf regressions may also be affecting node; node 13.1 executes our test suite in about 5 minutes on my workstation, while a canary build of node running the latest v8 (which I was trying because it fixed a perf regression in debug stepping performance which first appears in node 13.2) seems to take almost 7 minutes. Now, I thought it was just maybe a consequence of it being a prerelease build; but seeing this, if it's actually just indicative of broad perf regressions in v8... I'll be honest, I'd be surprised, since every v8 release blog is always talking about perf _improvements_.
wwwigham··on F# Pipeline Operator in JavaScript with Babel
If I recall correctly, it's because the proposal[1] was last presented to committee in March 2018[2], and since then it's been essentially deadlocked as the committee members can't agree upon an "f#" style operator vs a "hack" style operator vs a "smart mix" of the two. Personally, I hate placeholder sigils and magic "context" variables (and hope they have no place in JS), so a simple "left operand becomes first argument in call to right operand" is all I'd really want.

[1] https://github.com/tc39/proposal-pipeline-operator [2] https://github.com/tc39/notes/blob/master/meetings/2018-03/m...

wwwigham··on TypeScript’s quirks: How inconsistencies make the language more complex
Index unsafety w.r.t. bounds and `undefined` is something TS would like to fix; but it's not ergonomic to fix until there are, something like automatic refinement range types applied to array length fields. Without it, TS'd get in the way, demanding `undefined` checks it almost definitely didn't need. Those range types and their complexity are, ultimately, what currently block TS from making these indexed accesses safer.
wwwigham··on SMS is not 2FA-secure
I'm pretty sure the Microsoft authenticator has a backup TOTP token you can have it display if you have issues receiving the notification. It is quite a user friendly auth scheme, at least I've never had to resort to any kind of SMS backed auth.
wwwigham··on Show HN: Bepis – Crazy Format for HTML+CSS in JavaScript
I love me a good, simple, jokey template language. Reminds me of the one I made a few years back[1]. Everyone should write a small template language of their own - it's a neat parser-writing exercise, and the rendering implementation can be comparatively trivial (assuming you don't plan to actually use it in a place where rendering perf matters).

[1] http://ham.io/not.js/

wwwigham··on A Brief History of the Current Empirical Software Engineering Science Turf War
> The projects should be chosen by controlling their characteristics rather than relying on GitHub “stars” which capture popularity and are unrelated to software development.

> “stars” ... are ... unrelated to software development.

I wouldn't call sentiment about software _entirely_ unrelated to software development - minimally I'd assume that more popular projects, receiving more traffic due to higher engagement, would also receive more scrutiny, and thus have more bug(fixe)s. That would be an interesting characteristic to attempt to select for, no?

> Part of issue 9 is left unchallenged: 34% of the remaining TypeScript commits are to type declarations. In TypeScript, some files do not contain code, they only have function signatures. These are the most popular and biggest projects in the dataset. We corrected for this by removing TypeScript.

Those are... Still code? At least as much as header files in c are, and they can totally still contain bugs. Now, if we're talking about how they're often redistributible copies (like headers), especially way back at the time of the paper before @types came about, and how duplication due to that may inflate meaningful SLOC, that's interesting. Would be nice to see a good argument for it to be corrected and controlled, rather than dropped outright. Then again, TS has grown a ton in the intervening years, and the "largest" repos listed are... Very unused now. Wholly outdated. Entirely obsolete. You'd probably get different results with fresher data, too.

> The classification of languages is wrong: consider Scala. In FSE, it is lumped with Clojure, Erlang & Haskell under the “Functional Paradigm”. For this to be meaningful, there must exist some shared attribute these languages have that makes programs written in them similar. Referential transparency and higher order functions could be that. But, while Scala has higher-order functions, it is imperative. So, it is not a perfect match. Worse: Java also has higher-order functions, yet it isn’t in that group.

Many newer languages are multiparadigm, but I'd probably still say that Java encourages the imparitive OO style, while Scala prefers the functional composition style. I don't think "a single unifying characteristic" really helps, given the feature bleed between modern languages. I think you only get a great classification by examining, eg, what the community style standards are.

It'd be nice if open data studies like the one under discussion here were reliably posted in a format where the analysis could be easily recalculated, readjusted, tweaked, and represented. It's the kinda thing that could be neat to play around with in a notebook.

wwwigham··on Oil Is the New Data
Monitoring 11000 wells (in the US alone, according to Wikipedia) at that rate is only roughly 1KB/s per well. I'm actually surprised it's so small. Sampling intervals for most sensors must be on the order of multiple seconds - or there's not many sensors.
wwwigham··on Oil Is the New Data
You could call it Luddite, but I think I'm much more comfortable with human judgement being involved. Especially since that also provides an obvious place for blame to lie, if such preventative enforcement is used extrajudiciously or without reasonable cause (there is a degree of tension between supervisors and workers - that's part of why unions exist). I can also trust to some degree that the supervisor will pull someone aside and engage in a conversation, as a fellow person - robosupervisor might not be so considerate without serious consideration by it's implementors and executors (especially if such consideration doesn't help the bottom line).
wwwigham··on Oil Is the New Data
While the essay's main drive is on climate, can we put that aside for a minute and talk about the orwellian surveillance apparatus talk in the central section of the essay? Or am I supposed to take the lack of comments on that as a combination of apathy and the increasing acceptance of persistent surveillance?

Like

> When I reflect back on this meeting, it was a surreal experience. Everyone present discussed the idea of building a workplace panopticon with complete normalcy.

I get being uncomfortable working with Big Oil when you care about climate, but that kind of discussion spooks me way more. That goes way beyond climate and uncaptured externalities - that's pretty much a direct line on helping repress a people (in the service of ossifying existing power structures, ofc); potentially an attempt to utilize technology to help enforce a modern day kind of class slavery. Is that not the most obviously wrong new piece of information here? Isn't that that most notable component of this essay? Big Oil seeks to extract more Oil - that's to be expected, given their profit motivations, however unfortunate. You feel about that how you feel about that, and with respect to this essay, I don't think it's putting up much new information. But the surveillance goals of the management there? Those feel _new_ - like, if some engineer made the mistake of agreeing to assist creating those tools, that seems like it'd be _much_ more likely to goad people to anger. Me, at least, clearly.

> In particular, they wanted to implement computer vision algorithms that could detect suspicious activity and then identify the worker engaging in that activity.

Using ML to pick people out of a crowd for enforcement before they actually do anything seriously wrong... Literally the plot of a bunch of fictional dystopian thrillers, no? I find the concept that we'd actively seek to build such a thing quite disconcerting.

wwwigham··on Shipping a compiler every six weeks
Are those releases shipped in stable channels or only to, eg, VS preview users?
wwwigham··on Shipping a compiler every six weeks
Over at the TypeScript compiler we recently slowed our release cycle from 2 months to 3 months specifically because of an observation noted here: nobody used our beta (or RC) builds. On a 2 month schedule, we had 1-2 prelease builds during any given 6ish week period. The faster releases we had before were great for us - if something wasn't ready, we could just sit on it till the next release, since they were so often. However because they were so often, we struggled with collecting feedback on prereleases - we always, consistently, got most regressions reported only after the full release. We didn't really like this so a few things were tried. First we added an earlier prerelease cut and feature freeze (the beta) - this made the release smaller (as the earlier freezes meant more time focused on regressions or on the next release), and we still didn't get any feedback. Some of our users gave us the feedback that they'd test against our betas, but only if we had less of them... So we lengthened our release cycle to try that. We've not done many on the longer 3 month cycles yet, so I can't say if it's helped or not yet, but from the feature development side, I can definitely say that the longer releases definitely slow down how quickly things are built on top of one another.

In parallel, we've also been improving our test infrastructure in ways similar to Crater. In the past few cycles we've added a bunch of tests which only exist to test compatibility - all of DefinitelyTyped is now tested on our builds, and a number of community projects that we've produced build scripts for are built as well. I would _love_ to be able to crawl GitHub and just build arbitrary stuff, but TS/JS build chains are almost never a simple `npm run build`, so the best we can get is, approximately, loading a repo into an editor and checking for a crash (which we do have a tool doing). The rust ecosystem's dogma around using `cargo build` and `cargo test` to handle _everything_ really does help make what they're doing possible.

wwwigham··on TypeScript 3.7
Javascript formally releases once a year, but individual feature adoption in browsers is totally separate from that, and happens.... whenever they feel like it. v8 (chrome's js engine) doesn't have a set release schedule, but has already had 6 formal minor releases this year, each partially adopting some new JS runtime features, all of which have already shipped to chrome.

At our current pace, we formally release 4 times a year, for reference, which is actually a far cry from the more continuous deployment browser vendors currently have setup.

The main difference is that most people kinda ignore new JavaScript stuff for awhile until it trends or gains sufficient rollout. It's an interesting world - I can't really say that people are actually JavaScript version aware, beyond, maybe, what compatibility presets @babel/preset-env gives them.

wwwigham··on TypeScript 3.7
We actually primarily use StackOverflow for this (as it's the first resource many devs go to, as you did, and it's collaborative). We even pre-seed questions and answers for releases, sometimes.

If you find an answer on SO is out of date - suggest a new answer (or ask for one) and get it updated (there's far, far too many for us to keep explicit track of them, there's only a handful of us on the team)! :D

wwwigham··on TypeScript 3.7
JavaScript itself keeps changing, so we need to keep pace with that, for one. Beyond that, we relentlessly seek to improve how people interact with our editor tools, and make additions to the (type) language and compiler to support that. .d.ts files from js files, for example, are highly motivated by a desire to better support incremental compilations with .js inputs, as .d.ts files are used as incremental metadata. Assertion signatures were added to better express the cross-call control flow patterns some (assertion) libraries already use, to make using them in a well-typed way more ergonomic.

Generally speaking, it's not often we add something that _invalidates_ the old way to do something (in the language) - our additions are usually made to make new patterns possible to express.

wwwigham··on Tesla has applied for a patent for a new electromagnetic windshield-wiper system
In a Tesla, isn't there a camera in the middle between the driver and passenger inside the passenger compartment at the very top of the windshield?
wwwigham··on TypeScript vs. ReasonML
It's probably worth noting that that the "intellisense that vscode gives out of the box" is _also_ still delivered by TypeScript. Slap a `//@ts-check` into a js file and you'll find just where the typechecker thinks your jsdoc or usages are lacking or confusing (then maybe add a jsconfig with stricter settings than the default!). If you then fix those, you should be capable of getting _nearly identical_ completions in js and ts (because they really are just variants of the same language).

IMO, TS is all about static enforcement of inline documentation (types), just like how a linter enforces style. You can choose not to enforce it automatically... But at this point I don't get why you wouldn't? I wouldn't argue that style enforcement is best done by hand in the code review stage... So I don't see how further quality checks based on semantics derived from documentation would be any different.

wwwigham··on TypeScript 3.6
Yeah, inquiring minds want to know.
wwwigham··on TypeScript 3.6
Even if you don't opt in to full TypeScript, please do remember that the same engine powering the TypeScript language is also what powers IDE support and completions for JS in vscode and VS, so even if you're not using TypeScript _the language_, you're potentially still using TypeScript, _the static analysis tool_. Even without opting in to full type safety, having those tools available can still be a huge quality of life improvement.
wwwigham··on Ninth Circuit Goes a Step Further to Protect Privacy in Border Device Searches
The question is posed because according to the article, the verdict is that the border patrol is allowed to perform _manual_ searches of electronic devices, just not forensic searches, even without reasonable suspicion, in pursuit of finding "digital contraband". A term which is notably ill defined and which the EFF would like to see limited to just CP, to clarify.

It's probably worth noting that since the search is still _allowed_, information can still be divulged from devices and then used as the basis for a parallel investigation (I believe), provided that information isn't used as evidence. So it doesn't sound like much is practically different, so much as technically legally different - slightly more hoops must be jumped through to convict based on arbitrary device searches, is all.

wwwigham··on Microsoft Has First Major Impact on Chrome
If you run out of RAM virtual memory means excess pages will just get written to/read from disk, usually. Which is... Not really different than what it does now, I think?
wwwigham··on Ask HN: Configuration Management for Personal Computer?
I had a period where I _did_ reimage my machine every week. Keeping it running productively wasn't that bad - data was kept on a separate drive from the OS, and a script was used (as a post-reimage step) to reinstall all the apps I used and link all the data folders (and config files and profiles) into place. For me for Windows, that meant having a powershell script that used a combination of chocolatey (to install what was available via package manager in that way) and saved installers run from the command line in quiet mode (plus a bunch of link commands).

The only real drain is that you need to remember when you install a new app that you need to add it to your script. Beyond that, simply keeping most non-application data on a drive that didn't get reimaged with the OS (and could store things that could be linked into the system drive) handled a lot.

wwwigham··on John Gustafson’s crusade to replace floating point with something better
Is the variable length regime handling that much easier to deal with (space-wise) than the NaN and subnormal handling needed in IEEE floats? I'd think that the regime scheme would effectively be equivalent to creating a multitude of different-width subnormal routes. Is it really the NaN handling that kills IEEE float performance?
wwwigham··on FPGAs Have the Wrong Abstraction for Computing
> I don't think it makes much sense trying to accomplish this on FPGAs; you're better off using CPUs, GPUs, or making something domain-specific like TPUs.

I dunno, we have a lot of libraries and frameworks who make it their purpose to efficiently run code on either a CPU or GPU (or TPU, if we're talking about things like tensorflow); a FPGA is conceptually just an extension of that except, ofc, that on-the-fly FPGA recompilation usually outweighs any performance benefits you'd get from using the FPGA based hardware accelerator, so the only reasonable uses are one and done layouts with occasional patches/updates. If we could get an FPGA gate pipeline that was as efficient as the modern shader pipeline, I think what we could use them for could expand greatly - imagine a tracing JIT that could dynamically load hot sequential code into an FPGA to speed it up, the same way we can load matrix ops into a GPU today.

With where FPGA toolchains are today, it just doesn't work _because_ the compilation process is so bad and slow, and nobody except the engineers within Xilinx and Altera even have a reasonable shot at making it better since both the compiler and the compilation target are closed. Part of it is simply that these compilation passes aren't really configurable (beyond expressing layout and pipelining preference) - if I could get near instant bitstream generation in exchange for 30% extra space used, I'd use that setting for all but my final builds, and strongly consider invoking it at runtime.

wwwigham··on A Note on SIMON-32/64 Security
The construction is at least at face value a pretty simple ARX cipher - the only real questions being why choose the specific rotation constants they do for each round (ciphers developed in the open usually do things like key off digits of pi) and why compose specifically via xor, then add, then rotate in each round, rather than more of a blend.

If this style algorithm does indeed have an intentional backdoor: That's some crazy mathematic chops and I'd love to read the theory behind how it (the intentionally weak algorithm) was found (since hopefully that leads to a natural way to generate stronger algorithms, or at least check for weak ones). That'd be a valuable takeaway for the security community once the secret's spoiled, if it is the case.

wwwigham··on A Note on SIMON-32/64 Security
The math isn't too suspicious from what I can read, though I'm by no means an expert - it's just set stuff, from what I can tell. I think that Twitter post is just confusing the different fonts for the sets vs the scalars. "The cardinality of the set of keys is equal to two to the power of the length of the key" is a pretty sensible statement. The Yi is probably a typo, considering the `Xi = Xi` on the prior line is a bit redundant (and this is preprint, so I'd forgive it).

In any case, my real takeaway:

> Our main result is that we can find a 64-bit key in about three days (average time) on two Odroid MC1 clusters (8 Gb) [18] from two pairs of plaintext/ciphertext.

The algorithm isn't strong vs key reuse. I'm unsure if it actually claimed to be so - key reuse is almost always a big problem, though, and in this case they're exploiting the birthday paradox to make the search for the key more efficient.

wwwigham··on A final proposal for Rust await syntax
I wonder why similarly to the existing `yield` keyword operator in the experimental generators support doesn't rate highly in the decision making here. Maybe they plan to revise generators to `expression.yield`, too? Also `expression.return`?

Control flow from a dot-access rubs me just a bit the wrong way - honestly, I'd rather the syntax be a bit cumbersome because if I saw multiple nested `await`s in a single expression, I'd think the code was suspect and review it more, while I'm probably not going to have quite the same reaction for `x.await?.await?.foo.await?`, just because it _looks_ like normal property chaining.

wwwigham··on Simplify Gmail: Bringing the Simplicity of Google Inbox to Gmail
No, no - I definitely miss the autobundling. The auto bundling of github emails by repo is possible the only thing that's been keeping me sane, since I get a _lot_ of notification traffic, much of which I should read about, at least... I can't really setup rules for that - I could setup rules for repos I already participate on (ungh, that's a lot), but every random new repo would be another tag and another rule. Eck.

Inbox made that management drop dead simple. I lament it's loss.

← PreviousPage 2 of 5Next →