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.
674 karma · joined April 15, 2015
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.
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.
[1] https://github.com/tc39/proposal-pipeline-operator [2] https://github.com/tc39/notes/blob/master/meetings/2018-03/m...
> “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.
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.
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.
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.
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
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.
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.
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.
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.
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.
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.
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.
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.
Inbox made that management drop dead simple. I lament it's loss.