skysight-inc/HackerNews huggingface dataset:
It doesn't look the same, bug go's up.Reader and io.Writer are the interfaces you implement if you want the equivalent of "reading from stdin"/"writing to stdout". Once implemented io.Copy is the actual piping operation.
I think the Unix pipeline works because this it has this moldable and expressive text substance that is exchanged. Gstreamer also has pipelines, but the result in my opinion is quite awkward because events of many types are exchanged. Windows Powershell also has a pipeline where objects are exchanged, but it also somehow failed to become a huge success.

i think the unix pipeline concept doesn't quite scale to other domains that try to exchange a different unit of information between the pipeline elements.
Australia’s beloved kangaroos are now controversial pests
Haskell was the only possible I found.

Iterators don't really fully capture what a pipe is though? Theres no parallelism.

And streams don't have the conceptual simplicity of a pipe?
Well you can't read either from /dev/null, and I don't think that's just a question of permissions. I'm pretty sure it's impossible to get /dev/null to behave like an executable.
I have used statistical analysis and formal methods in production code. Mainly Astree, https://www.absint.com/astree/index.htm

When you have bought the tools to verify code in some safety critical project and know how to use it, it's easier to use it in less critical software too. You will soon hit the wall where formal correctness loses to time constraints and new features. You end up verifying only the code that is used repeatedly in multiple projects and does not change.

Formal verification is not substitute for testing and code review. You can verify that the code is correct but you don't know if you have the correct code.

The answer is: Because correctness of programs produces only limited value for normal use cases. It's more important to add more features than it is to produce solid code. If you don't have code reviews where all new code and changes are being read and analyzed by others (increasing the cost of the software 5-10 times) your interest in correct code is limited.
>Where did I say anything about relying on anything "indiscriminately"?

Well maybe I read a little too much into your comment but I interpreted it as "if you have small functions called only a small number of times in your code then you're a noob". I attempted to provide a counter-example.

I'm sure that you didn't mean it quite as literally but there probably are a bunch of young, inexperienced coders browsing this thread and I think these rules of thumb can be pretty counterproductive when they reach impressionable minds. Then you end up with people cargo-culting weird ad-hoc rules without even understanding the reasoning behind them.

>Avoiding repetition at all cost is definitely a mistake. Avoiding repetition where it's justifiable could be a sensible choice.

I completely agree on that.
Blurry boundaries do not mean no boundaries. Amazon, with their AWS services is squarely a tech company. Netflix arguably a bit less than say above-mentioned Amazon, but they do heavily depend on technology and innovate in that sphere, however are certainly less tech company than Xilinx, Motorola or International Rectifier, but certainly more than Domino or Papa Johns.
To take any significant advantage of it you need to use data-driven, transformational approach of solving something. But funny thing is once you have that it's not really a big deal even if you don't have a pipe operator.
Monads are effectively pipes; the monad controls how data flows through the functions you put into the monad, but the functions individually are like individual programs in a pipe.
Recent Gnome works very well with all-HiDPI; I had to leave XFCE when I switched to HiDPI because it hadn't good support.

Recent is key here; I have been using Gnome in HiDPI mode for a couple of years but I had to do some tweaks to have it working well; now it seems to work more or less out of the box. Same holds for Qt based applications.

Mixed DPI screens kind of works, but there are hitches; I definitely suggest going all in.
It's been part of F# since 2007 and C# since 2013, so the feature was probably known at design time of the language. However, language design is always a complicated dance of trade-offs, so there's never a way to initially account for all features that are eventually desired and implemented.
I think the internet would have been a much better place if SCTP caught on 15 years ago. It solved so many problems way ahead of it's time. Ah well.
A while back I made a PoC that used pipes to create bidirectional json-speaking connections between applications and then distribute the communication between distributed nodes. The idea being, don't just distribute TCP streams between distributed processes, but give 'em objects to make data exchange more expressive. I don't know where my PoC code went, but it wasn't very stable anyway. Just figured it was something we should have adopted by now (but that Plan9 probably natively supports)
OCaml has had the pipe operator |> since 4.01 [0]

It actually somewhat changes the way you write code, because it enables chaining of calls.

It's worth noting there's nothing preventing this being done before the pipe operator using function calls.

x |> f |> g is by definition the same as (g (f x)).

In non-performance-sensitive code, I've found that what would be quite a complicated monolithic function in an imperative language often ends up as a composition of more modular functions piped together. As others have mentioned, there are similarities with the method chaining style in OO languages.

Also, I believe Clojure has piping in the form of the -> thread-first macro.

[0] https://caml.inria.fr/pub/docs/manual-ocaml/libref/Pervasive...
Imagine such device but with a colored e-ink screen. It would be pure bliss!
Why is this the top comment? What value does it add? This is almost a textbook case of “the middlebrow dismissal”.

Paradise Lost is one of the single most influential and brilliant pieces of literature in the history of the English language.
Thanks for the references! The main issue isn't the support and maintenance of a such distributed network, but its integration with current solutions and avoiding centralized middleware services that will weaken the schema described in the documents.
>Cron jobs are the definition of the anti pattern of treating servers like pets and not cattle.

Cron jobs are the definition of "if it works don't fix it" and YAGNI.
This outlined version appears to end at the same point as the paywalled version. Am I missing something?
A list of organizations innovating in Quantum Computing
libxo
>Until that one server goes down in the middle of the night or it has issues.

The extra complexity of any workflow manager would make it even more certain to "goes down in the middle of the night or have issues".
Future crew seems to have reached a lot of folks... I watched it for hours as a teenager in Croatia,looped on computer store's monitors. I still check it out every now and then - though watching it on YouTube just doesn't seem as satisfying!
Doug be praised..
https://en.wikipedia.org/wiki/Douglas_McIlroy
Julia has a pipe operator, which applies a function to the preceding argument:

julia> 1:5 |> x->x.^2 |> x->2x

5-element Array{Int64,1}:

2
8
18
32
50
Seems like when I load another example, it gets stacked on top of the currently playing example.

(Chrome, OSX)
For every debit there has to be a matching credit so nothing comes out of thin air.

If you go to your Friendly Neighbourhood Bank for a loan they are giving you their money, so you can then give that money on to someone else.

Now the bank is not so friendly that it gives you their money, instead they offer to lend you their money, on the proviso you pay it back in full and with interest.

For example lets say you want to buy a new car, so you go to the bank to get the loan.

The bank transfers the money to pay for the new car to the car dealership and you end up with a new car and a whole lot of debt.
From this point of view I like TLA+, it gives you a simple but powerful programming language and then allows you to check stuff like "this must not happen" or "this must happen" (and more).

Formal proof as in coq-proof are often not reasonable for many dynamic projects
Hi, thanks for your comment.

You are correct that this model will not generalize to numbers outside this range.

My goal was just to have a reference when this questions comes up in a discussion about creating feature interactions that are about differences, multiplications, etc.

So I wanted to show that, yes, the model is capable of approximating it. Of course, we would need a sample that covers the necessary range to generalize.

This is a good topic for a future article.
Also known as: collaborative multitasking.
Maybe a hybrid architecture? Some elements working symbolically and others taking a statistical/DL approach.
Google fined €50M for GDPR violation in France
Hi, thanks for your comment:

I opened an issue on Github. This didn't seem obvious to many people that read the article, so it's nice that now we can keep this in mind while using the model:

https://github.com/dmlc/xgboost/issues/4069
One Two Three Micropatches for Three Windows 0days
It is because formal methods rarely agree with the cost benefit analysis of doing so.

At some point it is less expensive to just build the car and see if it rolls.
It will very likely fail to predict new data. The model can approximate the interactions over the range it saw on training, but we need to show it larger ranges if we want to predict for a bigger grid.
I think it's deeper than that. Men are more assertive as well as many women preferring it that way. The easiest place to see it is online dating apps, a system that has only existed for a decade or so. Size, strength, and status symbols (like having a nice car in your picture) are big selection factors for profiles of men seeking women. But these factors hardly matter for women seeking men. This clearly influences males to seek positions of status and power moreso than females, even though they're equally capable.

I would argue that eventually this small selection bias causes generic personality bias toward more assertive traits, larger size, and aggressiveness in males. In humans and many ape species this selection runaway has gone so far I doubt we can do anything about it.

It would be interesting if we could find a closely related species where the females are larger and more dominant. Human "dominant male" sexual dimorphism isn't the norm across the animal kingdom but is very common in apes.

Anecdotal, but I've heard MANY women say "I wish I had a male boss", but I've never heard the opposite from either male or female friends. Could this be related to similar selection factors? Who knows, but researching this kind of stuff is nearly radioactive to your career so we may never know.
While I do agree they can sometimes be tricky to use, Gstreamer pipelines are also it's best feature. Is there a better way?
I mean this respectfully. Think about it this way:

If there's an obvious solution that so many people are having trouble implementing, what is more likely?

1. That all those people are stupid or have no willpower, or
2. that the obvious solution doesn't work for everyone?
You don't have to trust the ratings agencies. You can look at the corporate balance sheets yourself.

Find me a recent issue that isn't properly priced considering the riskiness of the firm.
Compared to waking up and going to work?

I think it's a hard argument addicts are conservative.

But possible.

But you'd need evidence. I think the default hypothesis is addicts enjoy new experiences.

The articles conclusion is a bit crazy though. You can't swap it out with new experiences. Either preventive or cure. It's not that simple. Drugs are more than a new and exciting experience.
My own story using ProtonVPN
2 full racks of ribs will bring you pretty close: https://www.nutritionix.com/i/nutritionix/bbq-ribs-1-rack-12...
China’s sweet 700-year-old tradition
Same reason why the majority of CPU's are synchronous instead of asynchronous, cheaper to design by far.
The main reason is formal method is still not cost-efficient, not even close.

The problem is similar to statically typed languages. Of course, having a sound type system can help you avoid a lot of stupid mistakes. But the key point of modern statically typed language does not lose a lot of velocities. Sometimes even faster because there are better IDEs out there for auto-completion, importing, and much other stuff. I switched from JavaScript to TypeScript only to find I'm faster to write code without losing anything.

Before we make formal method widely accepted by the industry, we probably need depdent type languages first. An excellent example is Idris. https://www.idris-lang.org/
It's a dependent type language, and it can also apply formal method to prove theorems. With its IDE, it is more like pair programming with the type system, it can really fill up a lot of code according to type. This kind of system could have huge potential to be much more powerful than say, IntelliJ IDEA with Java etc.

After then you could write code very faster, you could optionally write some proof for the core domain of your system if you like.
> In mathematics, the word means that a statement transcends the laws of time and space. In law, it means a group of 'reasonable people' can be convinced.

This was historically and still is largely false. A mathematical proof is a written argument and most proofs are too complex to be "obviously correct", therefore mathematical proofs are usually more like your latter case: It is an argument that convinces people. Mathematics has a long history of doing things "that sound right but haven't been proven yet but it seems to work out ok", e.g. this was done all the time in the earlier days of analysis.
When is incremental progress good?
'Re: djbdns and EDNS?' – MARC
That assumes a 90 hour work week produces more value than a 40 hour work week. In programming, I'd bet the other way on average.
> If your code does n operations in sequence, just list those operations. Don't hide them off somewhere.

In principle I agree. In practice, if your function needs to do more than say five things one after another then something has gone wrong. If you were sending a human a set of instructions on how to do something, that's the point where you'd start grouping them into logical "meta-steps" (e.g. prepare the ingredients, make the broth, prepare the meat, finish cooking the dish).

Chopping a 12-step function into 3 4-step functions without regard for what each step actually does will make it less readable, just like doing the same to a recipe, or putting paragraph breaks and full stops into a passage at random. But a single function that does a long sequence of things is a code smell in the same way as an overly long sentence; it's well worth looking for a way to logically group these steps into a structure that will help the reader understand.
> When was the last time your Unix workstation was as useful as a Macintosh?

Some of that discussion has not aged well :)
While it's a good article, I didn't see it covering this aspect, particularly (c).
Just because those things are useful doesn't mean that they wouldn't be more useful/tractable if they'd stuck closer to logic. How do you know that their usefulness isn't a large part due to the closeness in logic and limited where they deviate, rather than the reverse?
IMO the really useful part of pipes is less the operator and more the lazy, streaming, concurrent processing model.

So lazy collections / iterators, and HoFs working on those.

The pipe operator itself is mostly a way to denote the composition in reading order (left to right instead of right to left / inside to outside), which is convenient for readability but not exactly world-breaking.
ffmpeg took a different approach (sort of like a single program/system with many command line options). Some say its easier to use (at least easier than gst-launch)
I'm not a fan of bundling/packing obsession either, but I've come to recognize its necessity, at least at present. If you want to use any external libraries in a reliable way, or don't want to serve massive, incompatible-with-some-browsers JS files, I just don't think there's currently a way around using some sort of bundler (or, alternatively, paying the cost in slowed-down development and/or stacks of compatibility-related annoyances based on the "modern"-ness of any code you write or import). For tiny projects you may not need one, but beyond that the convenience benefits are just too great.

Every time I've tried to avoid using a bundler in development, I've either regretted it (babel/webpack/whatnot has screwed something up in prod that I didn't catch in dev), or ended up shoving the important parts of a bundler into browser plugins that roughly execute the bits of the build phase I care about in the browser when the page loads.
Awesome, seems like what I need! Just requested an invitation with email on ambar.cloud domain
Or use a state monad to distinguish between steps that mutate state and functions that don't, making your order dependencies visible and easy to work with...
because a | b | c is equivalent to the very tradtional c(b(a())) and in FP it was infixed as `.`
> Iterators don't really fully capture what a pipe is though? Theres no parallelism.

Pipes are concurrent, not necessarily parallel. Iterators are concurrent, and can be parallel (https://docs.rs/rayon/0.6.0/rayon/par_iter/index.html).
You can just store the first pipeline results in a file, edit it, then use the file as an input for the second pipeline.
The proofs you produce are probably weaker than those the author wants
I'm curious what will happen when programs for eradicating mosquitoes will be ramp up globally (like releasing genetically engineered one to make them all infertile after few generations).
> if you are going to make a lot of state changes, having them all happen inline does have advantages; you should be made constantly aware of the full horror of what you are doing.

That's perhaps the main issue: crucial and unexpected state change hidden in functions.

Functions should do a single thing and should have explicit names.

We've all encountered functions with innocuous names a la "printSomething" that actually also changed internal state by stealth...
for anyone feeling flattened by modern tech-driven life, this poem is an antidote that will restore your soul
has there been proposals/research on having non linear / branching pipe syntax ?

a |1 b | c | d, |1 e

aka piping a to both b,c,d and e branches ?
We use Social Listening as a fast lane to content ideas
Well, the guy will learn soon enough anyway if they don't already know (whether they're relatives or just share the same name).

Why would it take some people to call them on the other end of the world?
What in that description makes you think of GitHub specifically?
Jetson TX2 vs. AGX Xavier Performance Comparison
StorJ is a incentivized (people get paid to make things available) and IPFS is not. They explain this in the podcast and mention it several times.

IPFS is perfectly resilient as long as the network participants have the interest in keeping the content available.
Show HN: Esy – fast and simple package management for native ReasonML/OCaml
I'd argue that even that can be a small step in the right direction if there were more than 20 variables at the start - at least now you have an upper bound on how much state from the top half of the code can be being used in the bottom half of the code.
Thanks for your reply! Can you please share what plan did you use? Is it 29$/mo? Is it enough for you?

> You can also install software like https://graphiteapp.org/, https://prometheus.io/ or https://www.zabbix.com/ on your own hardware.

Did you try it? What kind of hardware it requires?
Please no. C-style macros are too leaky.
It has, D's uniform functional syntax makes this as easy as auto foo = some_array.filter!(predicate).array.sort.uniq; for the unique elements of the sorted array that satisfy the predicate pred.
(Sorry for the delay in responding - I wrote this ages ago and just found it!)

Thanks for your answer, that's an interesting way to look at it! And certainly no one brain type is 'right' or 'wrong', they just work best in different environments.

I'm not sure about your perception about the prevalence of autism outside of the USA and Europe. This list suggests rates inside the U.S. are higher than basically anywhere else, although diagnosis might be different in other countries: https://www.worldatlas.com/articles/countries-with-the-highe...

I know a fairly large number of people from various Asian countries and none of them display what I'd consider typical autistic traits. I must admit I haven't asked any of them about inner monologues.
I mean the protocol is the more modern version.

Less capable as in "fewer ways to hit yourself in the foot by forcing you to use secure cryptosystems", then sure.

WhatsApp and Wireguard have been using Noise for a couple of years now.
Smalltalk's "method cascading" (the `;` operator) did roughly that. I don't think you're forking an entire sequence of methods though, it just allows performing operations on the same root object e.g.

a foo
; bar
; baz

would sequentially send "foo", "bar" then "baz" to "a", then would return the result of the last call.

The ability to fork iterators (which may be the semantics you're actually interested in) also exists in some languages e.g. Python (itertools.tee) or Rust (some iterators are clonable)
Top Free Android VPN Apps Are Leaking Your Data, Study Finds
You could plug IPFS Cluster's proxy endpoint (:9095) instead of the IPFS daemon API endpoint and get everything you add replicated to a backup peer.
You can read from /dev/null—it just behaves as a zero-length file, immediately returning EOF.

This makes /dev/null a valid source file in many languages, C included.
You're right, that was a silly mistake.
Ask HN: Which is the greatest place on the internet that is not in English?
If I did not know English, I could not enjoy HN. I am wondering which kind of media, webpages, communities or services are absolutely great but they are not in the Anglosphere yet.

Sometimes we get a glimpse in a translated book in Chinese, or a hacker community in Germany, or a service that we only find in Spain.

What else are we missing, HN?

Show me your favorites.
Can't open the link - always get CONNECTION_TIMEOUT
it's not trivial if we are talking about Linux boxes serving as servers let's encrypt has a good chance to not work out of the box, and especially with older boxes. and then there i are other things like needing a http server for obtaining the cert rotating it, distributing it.
and you loose the ability to use a proxy, and so on. with https you are still not protected with them knowi g where you get only what you did there.

it would be great to have the ability to have https but for APT in its current form and for what it is used the cost benefit for adding https is not that compelling to me.
I'm dubious about modifying a virus to escape our immune system - seems like that could come around to bite us in the ass. But they basically identified a receptor unique to cancer cells and what's different about binding to it vs binding to the similar version in healthy cells. Seems like a great drug target. You could even probably make a drug that binds to it and triggers an immune response, get the immune system on side. I'm not an expert in the field by any means, but I'd rather see that than a super virus.
Not really, that was badly written installers in InstallShield and friends.
I hope you get better mate. If there's anything that might help and is doable by a stranger on HN, lmk.