skysight-inc/HackerNews huggingface dataset:
Ok thanks, I guess this is somewhat understandable.

Through I wonder a bit why they don't automate the tests (maybe the computation cost?). (E.g. rust automatically runs the tests of all libraries/programs published on crates.io to find regressions, through that takes a day or so to complete).
Yeah, it's not about text/code duplication as much as it's about behavior duplication. In theory both, hopefully three or more!, code paths share the exact same behavior and if that behavior ever changes it will need to change EVERYWHERE you introduced a method to abstract it away.

Depending though, the indirection trade off may not be worth the abstraction to DRY it up. Then you end up with code like what was popular in the bad old days of Ruby. Essentially, you can get carried away.
Last I tried it (a couple years ago), repositories got corrupted.

I'd like something to replace darcs, but so far I haven't found it.
What's the value proposition of Pijul? I mean, not being Git is not a good reason to convince anyone to adopt it as a VCS. A tool needs to actually be better at something and add tangible value where others may not have. What's the absolute best reason to convince anyone to adopt Pijul?
After witnessing the collateral damage of many software reuse projects (anyone remember "components"?), I came up with a different ruleset, useful for "compromising" with "software architects":

First, translate the data.

Second, divine a common format and share the data.

Third, create the libraries for this common format, to be reused amongst projects.

I have never reached #3 in my professional career. Sure, we wrote the libraries. But other teams, projects have never adopted before whole effort became moot.

So I kept my projects in tact and moving forward, while letting mgmt think they're doing something useful.
I think it is more that 'expert programmers' where told to leave 'domain-specific' bits for power-users to deal with.

Therefore,

- game scene development in games, are in scripts.
- Equity derivatives and swap contracts are in Excel
- scientific modeling is in python

I also agree with your other though that, dynamic loading enables 're-use' of the core framework, so those frameworks/engines become marketable technology assets so to speak.

The programmers, then in some instances, created DSLs to then auto-generate performant framework-specific code from the DSL-written user specs.

But those, usually, are quite limited and also some power users migrated to be descent (not the expert engine/core-level, perhaps) programmers
They will still have to update rust when the next major version of Firefox ESR is pushed out this June/July...
Your analogies would make more sense if you spent 2 hours on documentation for every hour you spent coding or bug finding.
As PG said, take on as much technical debt as possible: it’s literally leverage.

Now sometimes “clean” code is the worst of both worlds. It wastes time and isn’t really clean.
Totally agree. his books would be even better if he got rid of the obnoxious chest thumping and just laid out his arguments. I read it a few months ago and it was the only book of the year that I wanted to reread. I continually find myself relating things back to it.
This is a good time to ask for a question I have always wondered about these slow hash functions: are they slow because they are computationally intensive or is it that they have other tricks that makes them slow without costing too much load on your server (like needing RAM access, syscalls or anything that add latency but not much CPU load). If it's the former, isn't it a good DOS target, making your server busy hashing random crap and unable to process other requests?
> ... My code traded the ability to change requirements for reduced duplication, and it was not a good trade. For example, we later needed many special cases and behaviors for different handles on different shapes. My abstraction would have to become several times more convoluted to afford that, whereas with the original “messy” version such changes stayed easy as cake.

The article's starting example and revision clearly illustrate how the original code was changed. Duplication was removed - just like so many advocate for.

Unfortunately, the article doesn't state the changed requirement that broke the new design, leaving that to the reader's imagination. And I can imagine cases in which the revised code would be superior to the original.

It sounds like the problem arose from the need for specialized handles on different shapes. If so, I don't see how using various createXHandle functions (where "X" is an identifier associated with a specialized handle) would necessarily cause convolution. It could become quite convoluted if not done with care. For example, keep the createHandle method, but pass customization parameters to it. But that's really the naive way to go.

What we'd be faced with is nothing more than the kind of specialization requirement we usually see with Object Oriented programming. We can use composition over inheritance to great effect there. We can extend the author's refactored design and end up with something clean and maintainable.
Darcs has a some pathological algorithms.

IME, darcs has never lost a repo of mine and Pijul has. So I'm not clamoring to use pijul instead - I don't use darcs in a way that runs into the pathological cases anyway.
Which one? Anki or AnkiApps?
The effects reported in that study are probably not real [0, 1].

[0]: http://nautil.us/blog/impossibly-hungry-judges

[1]: http://journal.sjdm.org/16/16823/jdm16823.html
This is my milage, been there 5 times. I agree with the salutations. Just learning a few lines of French goes a long way of the locals liking you. They truly appreciate the effort and was able to have quite a few conversations and even was invited to a night into town, it was fun to experience Paris through the eyes of a local.
> living where surfing before and after work was an option

Paraphrasing Steve McQueen, more like, where work in between surfing was an option.
> Well in his case, did refactoring the code to clean it up add business value?

Yes, it made future modifications easier and discouraged adding special-case behaviour.

And after reverting the change they did apparently fall into that trap.
California Housing Shortage
They don't want to need to update Rust in order to do a presumably small security patch on Firefox.

Which honestly sounds like a totally awesome and legit reason to use -esr. Keep -current current with upstream, stable branch gets patches from firefox-esr.

Keep in mind stable patches to the ports tree are pretty rare on OpenBSD. They didn't do them as binary packages until fairly recently, either.
Basement-dwelling losers and men with a lack of manhood are in fact a real thing. Sorry if that bothers you.
The implications of Pijul are really interesting. Some of the guarantees afforded by Pijul's model are clearly superior to those afforded by Git, but I can't help but get the impression that Pijul is:

1. considerably more complex under the sheets, and

2. considerably more complex in situations you're going to have to deal with as a user.

It would be nice to read an article from someone familiar with Pijul, that would take a look at the "ugly" (from the user's perspective) parts, and either explain how they aren't issues in practice, or at least show how you would handle them and argue why the benefits outweigh the costs.

For example, accurately representing repository states with files appears difficult: the page on Pijul's theory[0] explains how Pijul does not limit the repository to containing valid states, and mentions that "...else, we say the file has a conflict, and presenting the state of the file to the user in an intelligible way is not obvious.". There's an independent article about Pijul[1] that gives some examples of how you could end up with two different conflict states in Pijul that render into identical files.

I also had a look in the patch list for the master branch[2]. I managed to find a few patches I couldn't understand by looking at them. I realize that Pijul is still some ways from being ready for mass consumption, but the selling point of Pijul is its theory of patches. The documentation for "pijul patch"[3] notes that outputting patches as text "may lose information", and that "the text representation is merely a pretty-printed representation, and is not sufficient to apply the patch". This suggests to me that the difficulty in viewing those patches is at least partially due to viewing Pijul patches being a hard problem.

Here's an example, "Fixing a conflict with #387": https://nest.pijul.com/pijul_org/pijul:master/patches/6E7Kee...

Some lines at the top appear to be for informative purposes. They reappear later on, but slightly different (e.g. imports reordered, or with changed whitespace), and without any color (green or red) that would indicate that they were added or removed. They're shown in a context (e.g. line 219, 222) where they fit in as additions together with other lines that were added, though. The output of "pijul patch" for this patch[4] looks somewhat similar, and likewise not very easy to digest.

I really want to like Pijul, but I'm worried that it's too powerful and requires too much from the user. I would like to be wrong, though, so I would really welcome an article explaining these "darker" sides.

0: https://pijul.org/manual/theory.html

1: https://jneem.github.io/pijul/

2: https://nest.pijul.com/pijul_org/pijul:master/patches

3: https://pijul.org/manual/reference/patch.html

4: https://pastebin.com/b8XT5WPE
I have 2 rules I use when determining whether to duplicate code or to refactor:

1. How many duplications are there? If the code is duplicated once, that's fine. If it's duplicated twice (so 3 instances of it), then it's time to consider refactoring, subject to the next rule.

2. Why is the code duplicated? If it's "incidental duplication", i.e. code that happens to look the same, don't refactor. Only refactor if there's actually a reason why the code is the same. Which is to say, attempt to predict the future: if a change is made to one instance of the code, do I expect it to be replicated to the other instances too?
I agree with you. To me, the action felt wrong when he described it. I wasn't sure why at first, but I think perhaps because the work was not in service to any actual task.

If he was in charge of writing the next piece of functionality for that code, it would be poor teamwork to completely refactor it without discussing the reasons for the design, but at least it would have been within his area of responsibility.

This is also the reason why I like having code review. The review would have been a good place to raise his concerns. They could have had their eventual conversion earlier, before feelings were hurt or wasted efforts were made. It would even help in the opposite case, where the author's code was legitimately poor and the reviewer had good suggestions.

It's not a panacea, but I find code review helpful. In my experience, review was the time when a lot of knowledge-sharing occurred. Some might feel that only senior developers should review, but as a junior I learned a lot about why the author made the choices they did. I learned how people expected the code to change, about language features or pitfalls, etc., and it helped me grow as a developer.
Sure, everything that has a backdoor is bad. But what does that have to do with SMS 2FA?

Surely SMS 2FA (without a backdoor) is better than nothing. Sites should still offer something better than SMS for 2FA as it has widely documented issues. But as an end user presented with SMS 2FA or no 2FA; SMS 2FA is the safer option.

Is there a reason to assume an arbitrary SMS 2FA implementation would have a back door? That would be news to me.
It's great to hear that people are trying to use ocaml for ML :)
To me it seems like owl is the most mature ocaml project in this area. I recall they even had some GPU support. Unfortunately, I didn't have a chance to try it out so I can't comment first hand on how "ready" it is.

https://github.com/owlbarn/owl
I would even take your learnings from your experience a step further and say that one should be proactive in talking to teammates and exploring ideas on how to improve the codebase if you think there is room for improvement. For instance, it may well be that inheritance is the wrong pattern for that given codebase, but there are indications that the current architecture isn't scalable.

With more investment, more research could have been put into looking at better suited architectures such as the Entity Component System architecture, where Entities such as Rects and Ellipsis are composed of units of functionality (position, resizability, etc), which is a proven architecture for this sort of application. Then, implementation would be a matter of getting team buy-in / weighing the refactor pros and cons with your team.

Tangential, but Entity Component Systems are a great way to structure systems with many types of entities that share subsets of functionalities.
https://kyren.github.io/2018/09/14/rustconf-talk.html.
SpaceX Is Going to Blow Up a Falcon 9 Rocket Just After Launch
The quality of a team is the quality of the communication.
If the architecture and design isn't well communicated, you get people going off in the wrong direction, or polluting a clean design. Also, people are most attached to their code based on their time investment. If you trash someone's code/changes, you trash their time, which could have been more efficiently decided with a conversation ahead of time. If you find yourself surprised by design changes, find design flaws in a code review, or have different definitions of "improvement", the communication in your company may be lacking.
> but the point of Pijul is that you don't need to "do things right" to avoid the potential problems of your version control system.

The criticism directed by the Pijul guys at git cherry-pick is actually not a problem at all. At best, the argument made by Pijul's backers is that Pijul implements this feature differently and in a way that arguably may be creating a problem where in Git there is none.
Interesting, you have published the results/source somewhere public? Would love to take a look at it.

If you're using a language that doesn't need a AST/where the AST is the same as the source code, I'm sure we could pull out more benefits of this approach. Seems one would need a lisp or lisp-like language that is homoiconic.
> the tooling around it is atrocious. Compared to something like Bitbucket

I've yet to find anything comparable for repository hosting. I use it for projects where some of github's features are frivolous, but it would be a bit goofy adopting it at a big company.
In the language maybe but both Rust and Zig show that it's possible to have much less 'bloat' for error handling even without using exceptions.

I'd say that go designers have still work to do: Zig especially show that you can be a 'simple' language and yet have both sane error handling and generics.
Any multi platform framework will inevitably hit the hurdle of supporting only the common denominator. For many applications this is fine, but for the sake of consistency I hope native applications will still live for a while.
Why Rust? I Have a GC
Restricting partners usb access? Restricting websites and restricting install permissions.

Overkill and probably the opposite of what they envision an IT department doing.
You might have only been to higher-end restaurants, and not the "good ol' french" types that are as much about the atmosphere as they are about the food. The kind of thing I could only name as "à la bonne franquette".
For a representative sample of the kind of place I'm talking about, try 'Chez Gladines' in the 13th arrondissement.
Every game that Zachtronics releases has a gameplay trailer, for comparison. Perhaps it would be useful to look at some of those for inspiration:

http://www.zachtronics.com/tis-100/

https://store.steampowered.com/app/504210/SHENZHEN_IO/?curat...

https://store.steampowered.com/app/716490/EXAPUNKS/?curator_...

I think a gameplay trailer could be made from content from that video, by stringing together a series of short clips. Show the player moving around, manipulating things. Each clip a few seconds in length. Similar to the trailer for Exapunks, you could display text like "Solve puzzles" "Manipulate bits" "Hack your way to safety" (or whatever makes sense). Maybe end with a sequence where something drastic happens (the player does something and the whole screen changes), fade to black.

I think it'd be useful to show the player what the gameplay is actually like. Sure, it's not for everyone, but you can still show what it is.
The idea of computable reals go back to at least Turing. The idea is that a real number (or an operation on real numbers) is computable if we can compute the decimal digits, one by one. This way, if the user wants to know it to any desired precision, they just have to wait until the computer has printed that many decimals. You can equivalently treat them as terminating computable functions of type (nat -> bool), which computes the n:th binary decimal.

This is actually a quite constructive notion! At least, it works well with intuinistic mathematics, which is why Andrej Bauer is writing about it.
KDE FreeBSD 2020.1
So the bad guy can just notify the bank that you are traveling abroad, and then use the easier method to gain access.
I call these "spaghetti abstractions", and they're the worst kind of spaghetti.
Compared to git, it relies on patches rather than a branch approach.

I think it's more intuitive. Less opportunities to do silly things and some things that are punishing in git are not with patch-based version control.
Stock photo shows voltage regulator circuitry beneath cpu, most likely SMD capacitors. I wonder if the author thinks these are the parts he is writing about?
That and follow it up on a code review pointing out that it's duplication that could lead to bugs later.
It's a bit difficult to understand what's going on based only on the slides you've linked; do you have a link to a recording of the talk by any chance?
Calling Gizmodo a part of the news cycle is pretty generous. If the story was coming from somewhere mainstream like the AP, Reuters, or even CNN or Fox it'd likely stick around for a bit. Gizmodo is mostly niche articles for tech enthusiasts that like bite sized intrigue articles.
In my experience, you are way off base. Doctors can be very arrogant but I've never met someone from another profession who could point me to research articles regarding their proposed plan of action. Doctors at major hospitals are often either a) residents who are in their nth year of leaning post med school, or b) expected to publish at least case study papers regularly or communicate with those that do.
I am arguing about this on FreeBSD forums - from an end user perspective. I think the benefits of saving disk space by sharing libraries do not justify the inconveniences we, desktop BSD and Linux users, obtain from being forced to disrupt and upgrade hundreds of installed software packages, just because one single desired upgrade requires to pull its dependencies. The whole ecosystem falls down like a card house - once in a while I have to say "screw it" and auto-update more than a thousand packages, praying my Python and other projects survive, just because I want a browser update or a security fix.

I wonder if there are others who support this opinion that desktop Unix has very complicated future unless complex apps will begin to bundle their own libraries.
Upvoted. We'd probably come up with different implementations, I strongly prefer composition and "interpreter" style code, but whenever I've seen casual mutations in different dataflows, it was because of doing one off changes while ignoring the whole.
Duplication is far cheaper than the wrong abstraction.

https://www.sandimetz.com/blog/2016/1/20/the-wrong-abstracti...
While Twilio does a lot right, they still only offer SMS and their own proprietary Authy solution for 2FA for their website. No TOTP (and still no plan to offer the industry standard) means that this has a whiff of hypocrisy.
OpenBSD has a six‐month release cycle; Firefox-ESR backports will be able to use whatever version of Rust is in 6.7-stable (release coming this May).
American Economic Association: Climate Change Economics [video]
Soji Yamakawa: “Vulkan Is a Crap”
The author also didn't sound like a particularly senior engineer at the time for many reasons. So the original code author and the "boss" may have been taking into consideration timelines and future work/requirements coming down the pipe.

A very valid reason could have been as simple as "We are re-visiting this in a couple sprints after feedback and will have a better idea of how it needs to change. The extra day spent on this wasn't worth pushing getting it into peoples hands, and we don't know if it would be a waste." The author would have known this if he started a conversation about it.
I was about to look up morphine induced seizures as it sounded intriguing haha
They are computationally slow, no tricks. The purpose is to prevent attackers from calculating the plain passwords if they actually got access to the content of your DB. They are not that slow (let's say less than a second to calculate) - fast enough for your user to not notice , slow enough so that attacker can't do gazillion tries per second with their GPU or something.

As per DOS: rate limit per ip and account, and it's not an issue.
To me the #1 thing that fixes the social issues described in this post (changing code someone checking in code a few hours after they pushed it) is a code review process. The most valuable thing about always doing pull requests and code review is sharing information and having discussion about changes, not necessarily the immediate improvement of the code. A team will gain more knowledge about what everyone is doing by reviewing each others pull requests than they do from a daily standup by a pretty large margin in my opinion.

In this particular example, reviewing a PR would have meant that a discussion about whether or not that abstraction was a good change before the code was ever merged.
You need to meet some more "average people."
The first thing I did when I read this was come to the HN comments and search for people complaining about DRY:

https://news.ycombinator.com/item?id=22022599

https://news.ycombinator.com/item?id=22022842

https://news.ycombinator.com/item?id=22022896

https://news.ycombinator.com/item?id=22022836

The author of this piece was not engaging in a DRY activity even if he thought he was. He (perhaps unwittingly) admits to it himself:

> My code traded the ability to change requirements for reduced duplication, and it was not a good trade.

The acronym DRY was coined in The Pragmatic Programmer, and the author of that book makes it clear that DRY is about not repeating requirements in code. You definitely don't want to deduplicate similar code if it involves multiple requirements because then you entangle yourself, which is what the author of this piece did.
"Your friends and other people in your age group hate the new music so they only listen to music from when they were young."

Young people hate a lot of music made these days and listen to older music. It's not just a 'when I was young' thing anymore.

There's something very profound that comes from artists who make music, as opposed to a producer who makes some licks, a mediocre singer who belts it out, and a label that brands it.

When the brand/hype/marketing of the 'current flavour' dies down, what is left?

Music older than 4 years has to compete on its own merits, and most of it is forgotten, the better stuff hangs around.

Because music is ever more produced and less created, a lot of the stock today just stand the test of time.

When I was young you'd hear 50's music in the grocery store. Now you hear 80's music. But I think in 30 years we're still going to hear a lot of 80's music (and 60's, 70's and other eras) but the ratio of 'recently contemporary' to older music will be a lot lower.