skysight-inc/HackerNews huggingface dataset:
I actually even tried compiling the module with HiPE but it made almost no difference so I didn't update the Gist. I've updated it to reflect the tiny improvement it made.

In terms of web, CRuby 1.9+ simply uses OS threads for concurrency and parallel IO. You will run out of CPU resources before "the runtime won't scale" on modern Ruby.
Why Another Podcast App
The ad industry destroyed web surfing. The EU just drew attention to that.

Sites without tracking cookies don't need to show a cookie banner.
I work in HPC, and, well, it's VERY hard to make a good profit there.

- Customers are stingy (think academic labs, supercomputer centers etc.), are not typically married to your solution architecture so for every purchase they will put out a tender that you have to bid for and win.

- Performance is king, which means very expensive R&D, and customers don't spend much on all these "enterprise value-adds" that enterprise focused businesses use to pad their bottom lines.
Agreed. And even web apps can be truly serverless, like TiddlyWiki.
Of the choices that he proposes, #2 seems like the obvious solution to me - but he writes it off as too difficult.

Phabricator’s stacked diffs [0] works wonderfully well to support this exact workflow (it isn’t clear from the post which versioning system the author uses and what workflows it supports - maybe I missed it?)

[0] https://jg.gg/2018/09/29/stacked-diffs-versus-pull-requests/
I believe the idea is rejecting that definition.
Nice try, you managed to push to the limit of this algorithm!
Historically many different companies and frameworks have targeted the web platform and almost always they lost to "plain old Javascript".

That trend is going to continue, specially considering WebAssembly.

But as of now there's no sign of Javascript becoming less dominant as almost all the innovation is in the land of React, Webpack, Babel, etc.

I mean, what you're claiming "will emerge" is already there in form of Typescript, Node, React, Webpack etc and has a pretty good traction.
Pair-programming 100% of the time sounds like a nightmare to me. I need uninterrupted focus - something I can't do with someone else there constantly, even if we're working on the same thing
I think in such a situation, receiving a review is great, even though the downsides mentioned in the article ("what am I going to do while I wait for the review to come in?") are still presents.

However, it doesn't do away with how unsatisfying performing a review is. If I spend a day doing code reviews, that is not an enjoyable day to me. This is regardless of how useful I feel it is; it's just not a job I enjoy doing. It'd be nice if there was some change we could make to make it a more pleasant aspect of the job.
Code review was never about catching bugs. Not primarily, anyway. Code is written for humans to read (and modify), and a reviewer's job is to make sure the code can adequately fulfill that purpose. A reviewer is a proxy for the person who has to touch the code in the future – indeed, often they're the same person! Lumping all code quality issues under "stylistic changes" is just a disingenuous false dichotomy.
QA incurs a cost. It's perfectly natural to dislike this cost, but that's also largely irrelevant: the question (in each specific case) is whether the benefits are worth the cost, or not.
Yes, this is true right now, but does not mean it will be true in the future -- I meant to imply that Ansible was the safest, due to it's GPLv3 licensing (from what I understand GPLv2 is more permissive).

My second point was that I expect those terms to change depending on how IBM moves forward, and movement on that front (from the current state of things) should act as a canary.
First step to get right would be having automatic code formatters in place properly to cut out stylistic nits. With tools like Prettier, gofmt, yapf, Black and similar you can focus on the code itself, not how it looks. Of course it can take a while to find some common ground to some stylistic options (which is why I love opinionated formatters that don't give the choice) but it pays off quickly regardless and you gain huge wins with a tiny set of tooling.

For myself, I actually stopped caring of code styles and only run code formatters in a pre-commit step (if possible). By giving all the trust of fixing stylistic issues to the formatter and just focusing on the code itself while coding I ensure myself that I focus on the most important thing: getting stuff done.
At least it's clear that it depends on a service, with all that entails.
I'd later learned through someone else who'd worked with 'new guy' that they'd had similar problems, and apparently he only really works well on his own. I'd been 'given' him on this project because the first person wasn't really sure if he (first person) was at fault, or if 'new guy' was. I was the test case that confirmed.

By no means was the purpose to just 'reformat' (far from it!) :)

I have wrestled with this a couple times before over the last ... 15+ years. When working with other folks, I'm normally not in 'full time w2' arrangements - it's usually shorter term contracting, so the dynamics are a bit different. That may also be why the style/formatting is usually less important to me. As with the project above, I'd seen many well-formatted projects with descriptive variable names that don't function. And... seen horrific spaghetti code that "just works" but people are afraid to touch it.

Finding that middle ground is a never-ending journey, but I feel I've got a decent sense of how to get pragmatic results, and it usually involves repeatable sample data, repeatable processes and tests and/or docs. Building those as a foundation will make stylistic changes a breeze, because the confidence to make "trivial" changes will be there. Coming in to new codebases with no tests, sample data or processes should be considered scary/risky, and when people don't seem to have an understanding of the risks involved, I get even more scared.

It took us 9 weeks on this project to get to a point where we made a first push out to production (and even then we ran in to a few small bumps). But we'd practiced with tests (only have dozens, not hundreds at this point) and pushing to staging, and as the client reviewed... we kept finding more and more bugs - things that had existed in the code for years that we were seemingly the first people to exercise in front of the client. I'm sure their confidence in us was bruised a bit - we apparently just kept showing bugs(!) - but it feels like we provided more of a base in 9 weeks than we inherited from the previous 4 years of teams (automated builds, sample data, automated unit tests, automated browser tests, etc).

Just did this a couple days ago and it's still very fresh/raw in my mind :)
Obviously Debian always will be there...
In case performance is all you are after, this has much less potential for inlining than the rsync implementation has.
> where the author says they feel like code review is optional. If you think it's optional

I think these are two different things. The author says they don't enjoy code review, and that that probably is because it feels optional. From the post, I gathered that that's not what the author thinks - the first few paragraphs emphasises that they think it is an important part of the work. But apparently, that knowledge isn't enough to change the experience of reviewing.
This is a book written by Konrad Zuse, the inventor of the first programmable computer.

Re-posting since I just realized that my previous submission was broken.
BORI / GLBT President and 'Paid-Pawns' Step-Parents
It would be great if you can also generate TLDR; for each section and put it at the start. There are several automated text summarizers out there to experiment with, for example, https://www.textcompactor.com/
This seems like it misses the point. Obviously there are professional numerical analysts, statisticians, mathematical physicists, etc. who have sufficient background and interest to keep up with cutting edge research and do solid work in machine learning. The argument is not that everyone needs a CS degree per se, but rather that you shouldn’t have your excel guy who just went through a machine learning MOOC but has no further training or deeper understanding try to apply machine learning to life-or-death problems.
Ads were never as intrusive as that damn cookie/gdpr banner.

In case you didn't know, there are no sites without tracking cookies.
Comparing Working with JSON Using the XHR and the Fetch API
Wow, thanks for writing that up! I’ve had some thoughts about collaborative prepping for “realistic” scenarios and this gives me something to chew on. Personally I’m not in an earthquake zone, but my 5th floor apartment is just about sea level in Holland so I’m thinking about what the coming decades might look like here.
Great points. Regarding point 2:

> 2. The reviewer concedes that there can be equally valid approaches to a given problem or taste wrt. aesthetics. They do not try to gratuitously force their style upon the reviewee. The reciprocal must hold as well.

If my code is being reviewed, and the reviewer has opinions about how they would do it, I like it when they share their preference but also

1. consider if the code as submitted has the same result

2. share their personal preference for how they would have written it

3. explain why they prefer it over the code I wrote

4. not block the review on me rewriting the code to match their preference

I think it’s fine (and valuable) to comment “I hate this code, shipit” or (better) “ship it, if you change foo to bar then <explaination of why they prefer it>”

The worst code review comments are “this isn’t performant/idiomatic/maintainable, fix it” or other statements of opinion presented as facts. This kind of faux-objective feedback is terrible, since a fact can be argued against (or could be wrong). A statement of opinion like “I don’t like it” or (best) “I had to think really hard before I understood it” is great, since that’s what someone diving into the code for a maintenance ticket/incident will be thinking but won’t have the original author on hand to walk them through the code.

Linking to articles or references that explain why you prefer a particular implementation also gives the reviewer a learning opportunity & lets them save face when they post a follow up CR “thanks, didn’t know that”.
I got halfway through his course and it seemed to do a decent enough job of teaching it as you go. the main thing I struggled with was the mathematical notation.
My parents lost my social security card at some point in my early childhood and it took 2 years and 3 visits to the DMV to get a replacement

How's that? No DMV issues Federal documents like Social Security cards.
Thank you for the clarification! The latent space is so well behaved that that I can find linear relationship between the latent vector and the feature labels, and then use the regression slop as the "understanding" of the space
Well, Joe Armstrong once proposed a global database of open source functions, that you could dynamically lookup and fetch [1]. Sounds like Functions as a Service :)

[1] http://erlang.org/pipermail/erlang-questions/2011-May/058768...
I agree that most code review change requests are style-related.

One reason I can think of this happening is that in order for one's brain to focus on just the parts of the CR that matter, stylistic oddities need to be sorted out. Ideally after some time, a reviewee would stop opening PRs that contradict the basic stylistic standards that the group adheres to (and thus stop wasting everyone's time). Ideally there would also be a linter to get everyone to that point as quickly as possible.

Imagine if you were running an assembly line, and every person in every shift did their welds significantly differently. It would be a waste of time for the inspection workers to have to continuously remind everyone that it's hard to check quality on a variety of different welding methods, rather than just one or two. It would be a better use of everyone's time to just agree on what kinds of welds are acceptable.
It's a terrible and completely unreasonable stance for an employer. You get the hours you pay for. You don't get to own people's free time.
A bit off-topic: How can you integrate a jupyter notebook in a blog post like this one? It looks really nice!

Nice article, btw, interesting topic!
I should have been more careful in my wording here.

What I meant by this is the total energy expenditure of current payment systems (Credit cards, PayPal, WeChat Pay, Alipay, SWIFT, ACH, SEPA) including the overhead of fraud detection, chargebacks and the cost of fees on the economy.

To be entirely fair you would also factor in the cost of QE & inflation.

Although cryptocurrency isn’t widely used as such, notarization and its associated costs could also be taken into account.

All of these factors are obviously extremely difficult to estimate properly.

I still stand by my assertion that a mature cryptocurrency would be less costly for the global economy than the current systems of regional central banking and the damaging credit & debt cycles it brings with it.
Code Review Matters and Manners: Maria Khalusova, Trisha Gee
There are lots of sites without tracking cookies.

HN doesn't set tracking cookies, for example. The only two cookies set are the cloudflare uid and a user login cookie, both of which are hardly meant for tracking.
Work on Features, Not Repositories
Perhaps "A Computational Introduction to Number Theory and Algebra" by Victor Shoup? This was recommended by Dan Boneh in his crypto course.
Is modern Verilog not frustrating? I don't know much about it, but you're certainly right that the older stuff can be.
A useful metric would be energy consumption per transaction. Visa alone processes about 1700 transactions per second, Bitcoin 3 per second.

Bitcoin is essentially unused compared to the world economy, yet consumes a comparable amount of energy.
OP-Z
> Komposition is built for keyboard-driven editing, currently with Vim-like bindings, and commands transforming the hierarchical timeline, inspired by Paredit for Emacs.

=D
(For those who haven't experienced coding by AST-transformation, see http://emacsrocks.com/e14.html )
Case in point, no clue about music but love my Pocket Operator!
Serverless Node.js with OpenFaaS and Express.js
"There's no such thing as a bad book" - you can and should treat it as a learning experience and take away one positive thing. "I wouldn't do that", "If I see that again, I'd do it this way", etc.
So have I, but I haven't forgotten how much of a godsend it used to be. I do occasionally wonder if eclipse was actually better then or if it has just stagnated while the rest of the world marched on.
In some states, you'd have committed a crime already

Name one.

1) you don't need any drivers license to be employed in anything but driving

2) all states recognize other states' licenses ("full faith and credit") until a grace period after you take up actual residency or employment.
What about analytics?
True, but for rsync's case of setting the mtime of a file, performance of this logic is utterly insignificant.
You know that it is almost like 90:10 ratio for human errors: everything else in flying?
Mediocre code review is a human linter; decent code review catches obvious bugs; good code review catches subtle bugs; great code review teaches you something. I’m always excited to learn (or teach) when there’s a better way to write something. Even if not adopted, the surrounding discussion is a boon to future readers.

If people are giving crazy suggestions, or resenting good ones, something is seriously wrong with your team.
Hi, thanks for your answer and interesting point of view!

To my defence, I wrote this post the very night I installed and fired up everything Vue-related. Having taken a step back now, it might sound a bit too theatrical. I've accomodated to the framework pretty quick, which either says a lot about Vue or that I have overreacted to the change in the first place.

I must return the note to you, though — do you, as a non-web developer I suppose, actually learn a new language everyday? I suppose you take Haskell from your experience but it may be an emblematic example only. The web development world (esp. frontend) has its own amount of newness (and hotness, to be frank) every so often. Not to play the "What kind of dev is the best" game here, just interested in discussing.

Also, I am genuinely interested in the usage of "web developer" vs. "software engineer". Why is it that you use a different term, e.g. why not "software developer"? As an engineering school student, web development is only part of my skills (and only its basics are taught in class, actually) and I see myself as a software engineer more than anything. Yet, you seem to exclude web development from software engineering. Am I just having the wrong definition?

Thanks
Fascinating numbers. Do you know if that 95% number could be brought down by tooling? We have deployed fairly strict code style guides + included some linters and other tools to watch over code quality to reduce these conversations about style, but it obviously doesn't catch everything.
For a lot of those courses there's pretty much one way to solve the coursework, so all solutions are pretty similar. It's practically impossible to tell the difference between an original solution and a copied solution with the variables renamed and some code moved around. Or the student can look at the solution and reimplement it themselves, without solving it on their own. Sharing solutions can even get you expelled in many unis.
Exactly, that's what the parent comment was saying.
In one of the teams I worked in we had a policy to mitigate some of the things we found inefficient in our code reviews:

1- anything done in a pair doesn't need a code review.

2- any story that is more than 3 story points should be worked on in pair.

3- if you are doing a code review and you find something that needs to change you don't leave a comment, you update the branch and ask the original branch owner to review your new commit.
Studied flamboyance
That would be super cool idea and I have thought about it! To deal with music, we may want to use RNN, LSTM or WaveNet instead of GAN as the backbone generator and use my tl-GAN idea to find the "feature" axes for controlled generation. I would love to contribute to such projects.
I totally understand that large organisations don't want to sign papers about things that are none of their business. It's ridiculous that they need to sign them. This shouldn't be a requirement for Open Source contributions. But with some businesses claiming their employees' unrelated work done in their free time, I can see how this has become a necessity.

It's harmful for open source, and a terrible situation that's not to anyone's benefit. I guess US law should make more clear that employers don't own their employees' private work?
Our Continuous Testing Odyssey – Part III
LKML: Pavel Machek: Re: Linux 4.19
I can see Joel's points here and this is relevant to the discussion.

It's probably the article he has written I disagree with the most as there is a simple way to deal with this; be very clear about the projects, code and designs the employee works on each month and sign them over as they are delivered. That way the employee's own work will be clear should there be any legal wrangling. This could be done by a status in Jira for example.

https://www.joelonsoftware.com/2016/12/09/developers-side-pr...
It the software is GPL, and you use it for your company/university to do work with, that is a very dubious claim and more likely falsifiable in court.
I build Django sites often based around TinyMCE and this is my experience. If you've got a blob of content then drop in an MCE field but the minute you're dealing with structured data - WYSIWYG often makes things more complex.

TinyMCE really is quite extensible and flexible if you keep to it's sweet spot. It can produce fairly clean and consistent markup based on a whitelist of elements - which is critical if you're storing HTML directly in a database field.
You’ve ignored second-layer technologies.

There need be only one decentralized, immutable ledger to handle all transactions, the store of value and registration of assets for the entire planet.

While we’re comparing Apples and Oranges, credit cards don’t confirm payments for weeks and there are significant fees associated with accepting transactions, apart from that risk for the merchant.
To my eyes it also looked like a Duff's device which kept track of the successful state.
I see both arguments in this thread and elsewhere.
Red Hat's Open Source only approach does mean that none of these projects can be closed down, though: AFAIK, IBM are acquiring people and a brand, but no significant proprietary IP. If higher-ups at IBM turn out to be as clueless as Oracle, then key engineers will just walk and continue working on those projects elsewhere.
The one thing I really wanted to do was add a kind of stacking visualisation to the timeline to show depth of callstack. At the moment it is not clear at all how deep you are in recursion. I was thinking thin drop shadows that make it look like the timeline is a stack of paper.

I did half implement "Markers" which are coloured lines on the timeline similar to breakpoints.

I decided to shelve it until I had rewritten the whole thing to be more stable, which I think will require doing it as a fork of CPython.
I think the author is talking about a 'Forced Code review' because it is supposedly a good practice to have a code review before you put something into production (which it is).

The current practice is a coder submitting the entire code for review, and getting comments on every aspect that the reviewer feels like. This is not an efficient process as it takes up a lot of time, but reviewer also put in a position as to 'How would he solve the problem the current code has already solved'

I feel a good code review process should have two components:
1/ Self-review. A team/company should agree on baselines/conventions that any code shipped by them should have, and ensure that any code not corresponding to that will be rejected. This review should be done by developer himself, rather than a reviewer.

2/ A code review by an experienced dev who needs to check for libraries/custom functions that are used might not break something somewhere else, or wont work because some other change is going somewhere else, that they know of. This way, potentially buggy code can be avoided, and process could be faster as well. Ofcourse, if they want to provide feedback on a better algo, they can, but should be optional
so another story here:

code review mandatory at last place I worked, the place had a policy of any code you push in that does not match the guidelines must be changed. Guidelines was that no em allowed, must use rem. Old part of codebase assigned to me, I found some things in CSS I improved (reuse of code, a small overflow bug)

Got comment - you need to change em to be rem.

I can't do that because there is em all over the place and this can have side effects. The diff shows it as my code but if you look you can see it is actually the old code just moved to right place.

Those are the rules fix them.

since this code was in a big release of stuff and none of our stuff was allowed through unless I changed one em to rem even though I could not be sure there wouldn't be problems I went ahead and rolled back my changes.

fixed overflow bug other way. no code reuse ever in that part of codebase.
Only if it is directly related to your research under office hours and is done solely by your university. If you use the university laptop to do some OS at home it is not, though in the US it could be and usually is.
Pull request reviews are for merges into production, (or staging depending on your QA process) but you should always have a develop branch you can thrash on in the case that you are pushing a feature that is being worked on by another team (e.g. front/back end)

Fix the workflow. Reviews are the best quality control measure out there, perhaps even better than unit tests.