skysight-inc/HackerNews huggingface dataset:
I don't think it is uncalled for when there have been several instances of boycotts organized for that reason.

Nobody is that upset about anodyne OOP design patterns
Or washing dishes; pretty much anything in the kitchen.
> Homebrew has telemetry but it's only for Homebrew commands.

It was also more than a little controversial.
>GDPR is an EU law that applies to sites that market directly to EU citizens.

That is wrong. The GDPR does not make reference to citizenship.

It explicitly notes that it applies when either when the data subject is physically in the EU/EEA, or when the data controller/processor is based in the EU/EEA.
Yes, it's the first working implementation before good boundaries are not yet known. After a while it becomes familiar and natural conceptual boundaries arise that leads to 'factoring' and shouldn't require 'refactoring' because you prematurely guessed the wrong boundaries.

I'm all for the 100-200 line working version--can't say I've had a 500. I did once have a single SQL query that was about 2 full pages pushing the limits of DB2 (needed multiple PTFs just to execute it)--the size was largely from heuristic scope reductions. In the end, it did something in about 3 minutes that had no previous solution.
We started with macOS because I have a background in Swift development. Linux is definitely not an after thought to us!

As for the telemetry concerns, I totally get that. We've tried to strike a balance and it seems like we've got it wrong. This will be fixed in the next update.
Point 2 is how I feel these days. It's hard to trust any low-level (installable) dev tools supported by VCs. Personally, that hard to trust is also moving up the stack, maybe more so because of the increased attacks on the software supply chain vendors (i.e. CodeCov, SolarWinds)
> And they are all so simple that there will never be a problem.

"Simple JS can't have unexpected security/performance pitfalls".

Hah.

https://www.cvedetails.com/vulnerability-list.php?vendor_id=...
My gut tells me this argument is too simplistic, but... this is it, basically.

I don't know whether it's a cause or an effect. Maybe it's a self-feeding dynamic?
Carmack's writing on the proper length of functions (although he expresses it in terms of when to inline a function): http://number-none.com/blow/john_carmack_on_inlined_code.htm....

2014 HN discussion: https://news.ycombinator.com/item?id=8374345

A choice quote from Carmack:

> The function that is least likely to cause a problem is one that doesn't exist, which is the benefit of inlining it. If a function is only called in a single place, the decision is fairly simple.

> In almost all cases, code duplication is a greater evil than whatever second order problems arise from functions being called in different circumstances, so I would rarely advocate duplicating code to avoid a function, but in a lot of cases you can still avoid the function by flagging an operation to be performed at the properly controlled time. For instance, having one check in the player think code for health <= 0 && !killed is almost certain to spawn less bugs than having KillPlayer() called in 20 different places.
TSA to Require Pipeline Operators to Notify It of Cyberattacks
Sexual freedom is largely predicated on birth control. There's a natural limit on how much sex you're going to want to have when it implies pregnancy.
Might depend on the debugger? The main ones I've used also let me go through the chained version one at a time, including seeing intermediate values.
It is easier to destroy than it is to build. It was fun as a child to pull grass and pick it apart, to smash glass with a hammer, and to burn things with fire. It’s a way to explore. Now that I’m older I’m much more mindful about what I break. Are we collectively too child-like as a species?
Just chiming in on the telemetry issue, there are definitely situations where you could accidentally paste/type sensitive data into the terminal, so you'd need to treat any user data from terminal sessions as toxic waste.
Isn’t “Where technically feasible” a huge loophole?
Bootstrap vs. Vue: Performance Comparison
Such superorganism traits arise only if they are evolutionarily advantageous, and only when evolutionarily pressure selects for those traits. However, overpopulation previously was never really an issue, high population density was the exception rather them the rule, and various nation states clamored for scarce resources through war. This means that such forces haven't been part of our species for long.

In such an environment, wouldn't evolutionary forces be less likely than, say, ubiquitous xenoesteogen exposure from new chemicals like plastics or a vastly different diet and lifestyle from our evolutionary origins?
> “premature abstraction”

Also known as, “AbstractMagicObjectFactoryBuilderImpl” that builds exactly one (1) factory type that generates exactly (1) object type with no more than 2 options passed into the builder and 0 options passed into the factory. :-)
> Domains being essentially free allows for too much easy spamming of internet users.

My experience with spam [1] is that 90% of the non-trivially-filtered-kind comes from either taken over 'mainstream' email provider accounts (eg. gmail, yahoo, ...) or from exploited websites that can send email (eg. a wordpress or prestashop instance). Obviously dedicated 'spam' domains tend to get blocked _very_ fast on a multitutde of RBLs. It's the domains shared between spam and non-spam users that are the real problem.

Making domains more expensive probably won't help fighting spam. It will, however, increase the barrier to having an online identity to people who can't blow a couple months' rent on an urbit identity.

On the other hand, being able to register domain names without _any_ identity checks and oversight from legally responsible registrar entities could possibly increase abuse in some other ways.

[1] - I help run a mail server for a hackerspace.
Yup. You have to stay under the airspace but this or GPS is one way of hiding yourself from the major GDS systems.
Hannibal marched across the Alps with African war elephants
Patrick from Replit here. Excuse the self-promotion, but if you're curious how Fig got started by building their MVP on Replit, check out their interview on our blog: https://blog.replit.com/fig.

Edit: And of course big congrats to Matt and Brendan on the launch! It's been a lot of work and a long time coming. You've built a great product!
Free qualified leads straight from the US Govt
When it required me to enter my "work email" to "connect with teammates" before I could use it, I dragged it to the trash.
Nope. This is simply factually incorrect.

Take the Pennsylvania constitution, written also in 1776 (by many of the same authors, as we know, as the federal constitution). They also have a "2a" clause. Below:

"That the people have a right to bear arms for the defense of themselves and the state"

There is simply no other way to interpret it -- the 2a was meant as an individual right to own common-use firearms.

Anyone who says otherwise, and is educated on the matter, is lying.
The Julia REPL. Unicode, colored stacktraces, special modes for documentation and package management, accepts LaTeX commands to enter special characters, has paste mode:

“In Julia mode, the REPL supports something called prompt pasting. This activates when pasting text that starts with julia> into the REPL. In that case, only expressions starting with julia> are parsed, others are removed. This makes it possible to paste a chunk of code that has been copied from a REPL session without having to scrub away prompts and outputs.” → https://docs.julialang.org/en/v1/stdlib/REPL/
Code like this is like (not) caring about memory leaks in a Missile Control module where the explosive is the garbage collector:

When code is one shot, accomplishes its goal, and does not need to be extended or relied upon in the future, why do all these things?

Is there any goal above that is not also serviced, at least in significant part, by open-sourcing it?

Bravo to The Economist for releasing it. This is unabashedly a Good Thing.
ooh, thanks for reminding me about libraries, I got a lot of work done upstairs in the main branch of Seattle's library, I gotta get around to checking out the options in my new city.
Yeah to some degree. I am in that 25 years of experience range. The software I write today looks much more like year 1 than year 12. The questions I ask in meetings I would have considered "silly questions" 10 years ago. Turns out there was a lot of common sense I was talked out of along the way.

Most people already know what makes sense. It's the absurdity of office culture, JR/SR titles, and perverse incentive that convinces them to walk in the exact opposite direction. Uncle Bob is the culmination of that absurdity. Codified instructions that are easily digested by the lemmings on their way to the cliff's edge.
I've found GitLab as a product to be more difficult to use than GitHub. The pages seem more dense with lots of color, many more actions: they just feel busy. Basic features, like getting a permalink to a line of code, take 3-4 clicks in GitLab, when it's just 1 in GitHub.
Thanks. Yeah, It's too amorphous, ubiquitous, close-up, and squishy soft-"science" (philosophical-ish) sociological and psychological phenomena to really investigate, and conducting any sort of large-scale experiments would be extremely cruel and unethical.

I think we can only look at history, macro trends, and some imprecise civilizational differences to throw approximate qualitative hypotheses against the wall to make some guesstimates, and still be wrong most of the time due to unaccounted factors or even happenstance of maladaptive random behaviors like not dating people with green eyes, political revolutions that organize society differently, or inexperience/shyness denying the immense rewards of social/sexual/pairbonding opportunities.
> People don't complain about it not being a Photoshop clone.

Actually, no. As the person doing tech support for GIMP, I can tell you with 100% assurance that people do complain about GIMP not cloning Photoshop's UI. Quite a lot, in fact.

> It doesn't need the same workflows as Photoshop, but it definitely needs to improve them

Agreed.

> I will add that copying Photoshop would be an easy all-around win

It wouldn't be easy. Nor would it be a win. You would be stuck in the cycle of always following whatever changes Photoshop developers make. And dealing with the same criticism Photoshop devs get. Why would you want that?

And why would you, in your spare time, continuously copy someone else's work? There's no money in this. And it's not fun for sure. So why? Low self-esteem?

> cheaper alternatives to Photoshop... Gravit ... not exactly photo manipulation

Mhm, how about... Not photo manipulation at all and not alternative to Photoshop at all? :)
- Letterboxd, as a movie fanatic, this app is great, and its community seems very welcoming.

- Feedly, it almost makes me forget I'm really missing Greader.

- Stripe, docs, dashboard, landing pages--everything they do ends up being top notch.

- Github (this is a weird one), didn't really appreciate the care for the UI until I had to use Gitlab extensively, the worst offenders are the PR UI--everything looks so cluttered, and it doesn't happen on Github.
Reminds me of some of the issues fictional humanity deals with in The Ministry for the Future - https://en.wikipedia.org/wiki/The_Ministry_for_the_Future
Documentation is rarely adequately maintained, and nothing enforces that it stay accurate and maintained.

Comments in code can lie (they're not functional); can be misplaced (in most languages, they're not attached to the code they document in any enforced way); are most-frequently used to describe things that wouldn't require documenting if they were just named properly; are often little more than noise. Code comments should be exceedingly-rare, and only used to describe exception situations or logic that can't be made more clear through the use of better identifiers or better-composed functions.

External documentation is usually out-of-sight, out-of-mind. Over time, it diverges from reality, to the point that it's usually misleading or wrong. It's not visible in the code (and this isn't an argument in favor of in-code comments). Maintaining it is a burden. There's no agreed-upon standard for how to present or navigate it.

The best way to document things is to name identifiers well, write functions that are well-composed and small enough to understand, stick to single-responsibility principles.

API documentation is important and valuable, especially when your IDE can provide it readily at the point of use. Whenever possible, it should be part of the source code in a formal way, using annotations or other mechanisms tied to the code it describes. I wish more languages would formally include annotation mechanisms for this specific use case.
I assume they use it to track DAUs/MAUs. Otherwise, they only have data on installs, but wouldn't have visibility into user retention.
I can be loaded with 20kg of fruits (a crate or 2 on the handlebar and in bags), I will go slowly of course, but I don't really want to stop at a red light if the road is empty as it's already difficult enough (other drivers usually understand it and don't get mad at it), I'll also sometimes need to ride at the middle of the road, to avoid some holes on the side. Some drivers don't understand this and get crazy, most also don't anticipate things at all, they'll dangerously pass you just to stop 50m further..

I've been also close to be hit by behind 5 times, where the driver noticed me at the very last moment, and once hit on the side (left handlebar and shoulder broken)

Bikes need a status in-between pedestrian and cars, for many reasons, not just mine, environment, security.
Development trends are cyclical and even the most sound principle has an exception. Even if something is good advice 99% of the time, it will eventually be criticized with that 1% of the time being used as a counter.
I recently read this cover to cover and left a negative review on Amazon. I'm happy to see I'm not the only one, and this goes into it in a whole lot more detail.

The author seems like they took a set of rules that are good for breaking beginning programmers bad habits and then applied them into the extreme. There's a whole lot of rules which aren't bad up until you try to apply them like laws of gravity that must always be followed. Breaking up big clunky methods that do way too much is great for readability, right up until you're spraying one line helper methods all over your classes and making them harder to read because now you're inventing your own domain specific language everyone has to learn (often with the wrong abstractions which get extended through the years and wind up needing a massive refactoring down the road which would have been simpler with fewer methods and abstractions involved at the start).

A whole lot of my job is taking classes, un-DRY'ing them completely so there's duplication all over the place, then extracting the right (or at least more correct) abstractions to make the whole thing simple and readable and tight.
Out there there is a contradiction. The planet can support billions more people, so we don't have to be careful about growth. The environment is in peril and people are at fault.

Most of the pressure is in developing nations with more lax laws around managing natural resources...

But, also this only matters because of people. If we didn't live on this planet all this would not matter even if it happened. Imagine an exo-planet that is experiencing species decline for any reason (cataclysmic, new species of locust-like predator taking over, etc.), does it matter at all? Would we care?

Ultimately the real question is, does it affect our survivability as a species.
> It's not good, however, to name the functions (let's add: in global scope) f, g, h, f2, f3, gh, etc. just to avoid typing more characters. Instead, we choose a name which can be understood with as little additional context as possible.

Ah, you're not talking about the same things: you speak code, he speaks type theory.

You are completely correct on that: a good naming convention is better for readability, particularly with a large codebase.

So, let's try to find a compromise. It really depends on the size of the lexicon in the language considered: if all you have is 50 rules in your type theory, do you really need to give each of them a name fully describing its semantics? Of course you don't, so calling them inl1, sub2 etc. shouldn't be an issue, if the name can still act as a reminder of the rule meaning. In the same spirit, rules usually connect together few objects: a context, at most half a dozen of type variables which come up all the time in the rule set, a few operators. Maybe someone with some experience with functional programming would find it easier to understand. In fact, I think I pretty much paraphrased the quote above.

> Yes, but then I wouldn't need to work to understand the syntax, making the process of understanding the concepts easier.

I very much agree with that, but I also think that it's a question of training. In software engineering, people routinely devise DSLs, learn new languages to handle a specific problem or adapt to new working conditions. Once you get the hang of it, it should become easier.

Here's a small tip: Gamma in the greek alphabet corresponds to the letter C in the Roman one, so it sort of makes sense, if one's using Greek letters, to use Gamma for Context - like one would use Delta for difference in math, for instance. It's confusing at first, but it might also help in learning the Greek alphabet - again, same as what we have to go through in math classes.
Sorry about that. Should be fixed now.
> There's a formal concept for this in philosophy, but that's up to you to figure out.

I think I know this one! Is it the paradox of the heap?

https://en.wikipedia.org/wiki/Sorites_paradox
> Just as an example, if I wanted to get a list of every song I liked on Spotify and import it into Apple Music, how would that even work? The songId of Spotify is undoubtedly different than the one Apple uses. Are Apple and Spotify supposed to agree on a common file format?

Why wouldn't it work? Desktop apps had m3u playlist formats which could be read by multiple players - from Winamp on desktop, iTunes on a Mac or even car headunits. It's now kinda wierd to say that rockstar engineers of Apple/Spotify can't find a way to export playlists and liked songs (a global singletons essentially) they got from the SAME publishers and probably ingest from the SAME content owner data sources.
This is a deluded way of thinking the world works.

Is it how things should be?
Probably.
But this is nothing close to reality.
Walton ropes in former Samsung CTO for R&D in Seoul, reveals MD
Consider yourself lucky!

You have a strong evidence that your idea worth something and caused someone’s interest besides friends&fools.
I'm using authy on mobile. Can you say more?
> socials that are working with cops ... whatsapp

WhatsApp?
“Capitalism” as a concept (rather than a reality) does not allow for nonconsensual transactions like slavery. (Unless you sell yourself into slavery to get money for someone else).
I think it's a Mac and an HDPI thing. I had to stop using emacs because it was too slow on my work MacBook Pro connected to a 4K screen. Scrolling was painful and only marginally better with nativecomp.
The Stripe API docs are the most beautiful and useful API documentation I've ever seen.

https://stripe.com/docs/api
Standard stuff, ubuntu/gnome-terminal.
The state-machine that can determine the start-of-instructions can be run in parallel. In fact, any RegEx / state machine / can be run in parallel on every byte with Kogge-stone / parallel prefix, because the state-machine itself is an associative (but not communitive) operation.

As such, I believe that decoders (even complicated ones like x86) scale at O(n) total work (aka power used) and O(log(n)) for depth (aka: clock cycles of latency).

-------

Obviously, a simpler ISA would allow for simpler decoding. But I don't think that decoders would scale poorly, even if you had to build a complicated parallel-execution engine to discover the start-of-instruction information.
It’s very tempting, as in your insightful quote there, to form opinions on everything. However it would be nice if more of us said “I don’t have enough information to have an informed opinion here” more often.

And I include myself in that.

(Edit - yes I am a middle class Englishman!)
Neat! A bit ago, I wanted something similar, so I glued company and pcomplete in an Emacs eshell https://xenodium.com/eshell-pcomplete-company-completion
That sort of test doesn't really apply here in any meaningful way.

Suppose you want to validate that a certain column is in the file. You could place your assumptions around that explicitly in the read_tsv function call and have it generate the error for you on reading the file, or it can generate an error when you try to use that column. Either way, there's no "test" yet the intention is clearly stated in the code, and the code will simply fail out rather than proceed if it encounters input that can't be meaningfully used.

This code is in many ways a declarative use of other code, describing the data, doing some joins and filtering, and plugging it into well tested libraries of code. The data structures that store the data and the library functions that deal with the data are designed in a way that bugs often result in errors immediately.

In many ways it's like writing a SQL statement. One could make test data tables and make sure that the SQL statement does what one expects, but the SQL statement already embodies intent in the same way that a test of code would embody intent.
you can do something quite simple like posting a tweet or inserting something into a public chain, like Etherium. Then follow that back to the private immudb hash.
Ask HN: What are your favorite conspiracy theories?
A good chunk of Twitter et al.

Where are you?
Involuntary goodness.

Is the point that you should feel good about any regulation, by virtue of its being the result of a democratic process? For (counter)example, I might not normally feel good about implementing “Muslim ban” functionality even if I recognize the nominally democratic process that forces me to.
What sort of IT stuff does the hedge fund do?
You can flip Y coordinate in Inkscape since v1.0. Unsure how it affects EPS exporting though.
Read it again critically. Maybe you will see it differently, I know I did when I read it a second time after a few more years of experience.
Thank you, that is helpful. I'm surprised that people are willing to send eth based on the promise to later transfer an address!
It is so cool to see how far things have come since ClojureScript first worked with React Native in 2015. Krell is the best REPL for this IMHO, and it does this largely by getting out of your way. :)
Transcript of controller telling plane to land in Minsk
I think the big change hasn't been on the male side, but rather on the female side. There's always been creepy men willing to do this... the big change has been the mainstreaming of the acceptability of this among females. It used to be embarrassing to be seen as the kind of girl that spends time with old rich guys in exchange for gifts.

Now being on their yacht in Biscayne Bay is worth the instagram clout for many girls. Go for a walk on the beach in Tulum and you'll see the average age difference of couples is something like 20 years. Instead of keeping it a secret, college age girls know their friends are doing it, as well, so there's no social pressure to hide it.