skysight-inc/HackerNews huggingface dataset:
> Well, scheduling is important. I can't connect my new phone to the computer until I've taken it out of the box it came in.

That's not scheduling, that's a data dependency which functional style handles very well. Imperative would be more like deciding you have to unpack the charger and then unpack the phone and then charge the phone, when in fact it's fine to unpack them in either order. http://www.lihaoyi.com/post/WhatsFunctionalProgrammingAllAbo... has an extended example.
For suitably powerful privacy coins, the government shouldn't be able to tell if you used your private key or not. So you claim you lost your private key and spend away. Of course, there has to be an off-ramp into the real world at some point, so all this actually gets you is access to the black market. Opinions may vary on how useful that is, and how much blockchain can succeed if it insists on fighting regulation tooth-and-claw.
Smart contracts vs. traditional contracts
It's not the only way, but an easier one if the scientist just cares about their own ass.
Microsoft Fabric CSS Framework
It would be foolish for me to attempt to quantify what worth "more"; however, it is worth keeping in mind that the railroads we're very heavily subsidized in their time as well.

http://archive.boston.com/ae/books/articles/2011/06/05/colla...

https://mises.org/library/crony-capitalism-and-transcontinen...
Exactly! What good is a keyboard that can’t be used to bludgeon someone to death in case of an emergency :)

If anyone thinks I exaggerate: https://youtu.be/4_qA5OZFJ1I?t=80
But Google can measure a page weight and load time when it's indexing it and use it in its pagerank calculation, it doesn't need to take control of your page to do it.
What's up with this "considered harmful" being used everywhere lately?
How would that better environment look?

So far, we had fails like Squeak and relatively low succeesses like Jupyter and Delphi.

The root of the problem is that humans communicate in extremely ambiguous and convoluted ways which makes programming quite atypical.
Same in Italy.

And it better be good!

It says a lot about the couple's taste.
I think a nice solution for what the author is looking for in a GUI, namely the ability to write a script that controls them, is achieved today by something like AppleScript, which pretty much does exactly that: you can write little scripts that allow you to have basically full control of the application's UI (and in some cases, the parts not visible). So you really have the best of both worlds: a nice, pretty, and simple GUI interface that most people can use, and a scriptable backing that can be queried and manipulated in useful ways for purposes such as automation.

Less related: This is from 1998, I believe, but I guess the general date is obvious from the title itself.
You disprove your own point, this is from 1992
>That way, naive users can use push-button
GUIs, blind users can use Braille terminals, and sophisticated users
can program solutions to intricate problems.

ha! I hope this was tongue in cheek...
I don't know. I think the original idea for Windows was that services are accessible through APIs on a system-wide message bus (COM) and the various GUIs are simply clients for those APIs.

I'd argue that, if that design were held through (and an easy to use universal client for COM had been available) it could have become even more versatile than unix. But of course, that's not what happened...

Then, today, we have a new trend where "GUI-only" functions are actually used deliberately to implement security restrictions or preserve business models.

And then there is the mess that is "web-based" GUIs...
It's based on "Go To Statement Considered Harmful", by Edsger Dijkstra: https://en.wikipedia.org/wiki/Considered_harmful
>In fact, any lossless compression algorithm has the property that the output is (on average) at least as long as the input

I don't think this is true. If it was, lossless compression would be useless in a lot of applications. It's pretty easy to come up with a counter example.

E.g.

(simple huffman code off the top of my head, not optimal)

symbol -> code

"00" -> "0"

"01" -> "10"

"10" -> "110"

"11" -> "111"

If "00" will appear 99.999% of the time, and the other 3 symbols only appear 0.001% of the time, the output will "on average" be slightly more than half the length of the input.
The costs of counting and banking cash are proportional to the amount of cash you take - but the costs of CCTV cameras to point at cash drawers and the driver hours for a single daily armoured car collection are the same regardless of how much money is involved.
> A precision pointing device that didn't require taking your hands off the keyboard would help.

IBM created this for the ThinkPad. I had a Dell D830 with the little mouse between the G/H keys and the left/right buttons just below the spacebar. It was amazing.
In Italy 160 guests is just close family.
I mean, I see it a lot on hackernews.
It's still had a comeback recently

And yes it's 80s/90s newsgroup flamebait. The author concedes GUIs are useful, they just want access to APIs.
And it should be like this, in the early days of GUI it was a mess and in many places still is, but people understood how to use it properly - eg as a "frontend" part of an application "kernel".

So in my view GUI is not harmful, but completely the opposite. It gives you tons, tons of possibilities and improvements. If used sensibely, of course.
This is a perfect 'LOL hn' comment if I ever saw one.
> Why did you chose to store 'size' and 'capacity' in the 'rs_heap' struct instead of at the beginning of the heap-allocated buffer pointed to by 'buffer'?

Why would you store the size and capacity as part of the buffer? It makes the buffer more complex (you need a separate unsized struct or some mess special-casing the first 16 bytes or so), wastes heap size, requires dereferencing before you can even check on size & capacity, and makes SSO harder/more limited.

AFAIK both C++'s std::string and Rust's String store size and capacity on the stack, separate from the buffer.
Rackjure
6 in 10 Americans Think Higher Education Is Moving in the Wrong Direction
Looks like an issue with their upstream, nyi.net:

traceroute to mail.fastmail.com (66.111.4.148), 30 hops max, 60 byte packets

1 192.168.1.1 (192.168.1.1) 2.582 ms 4.760 ms 4.748 ms

2 142.254.XXX.XXX (142.254.XXX.XXX) 14.748 ms 41.677 ms 43.837 ms

3 agg60.vnnzca2401h.socal.rr.com (76.167.27.73) 44.784 ms 47.498 ms 47.498 ms

4 agg11.vnnycajz01r.socal.rr.com (72.129.14.96) 47.489 ms 47.479 ms 47.499 ms

5 agg29.lsancarc01r.socal.rr.com (72.129.13.0) 47.475 ms 47.466 ms 47.452 ms

6 agg10.tustcaft01r.socal.rr.com (66.75.161.48) 47.458 ms 20.444 ms 19.780 ms

7 agg10.lsancarc01r.socal.rr.com (66.75.161.49) 24.220 ms 25.283 ms 25.654 ms

8 agg10.tustcaft01r.socal.rr.com (66.75.161.48) 27.438 ms 29.922 ms 29.924 ms

9 agg10.lsancarc01r.socal.rr.com (66.75.161.49) 32.877 ms 33.666 ms 34.208 ms

10 agg10.tustcaft01r.socal.rr.com (66.75.161.48) 35.399 ms 35.901 ms 36.878 ms

11 agg10.lsancarc01r.socal.rr.com (66.75.161.49) 34.177 ms 34.492 ms 34.462 ms

12 agg10.tustcaft01r.socal.rr.com (66.75.161.48) 31.085 ms 28.907 ms 30.610 ms

13 agg10.lsancarc01r.socal.rr.com (66.75.161.49) 27.499 ms 35.354 ms 36.167 ms

14 agg10.tustcaft01r.socal.rr.com (66.75.161.48) 38.251 ms 39.675 ms 39.303 ms

15 agg10.lsancarc01r.socal.rr.com (66.75.161.49) 36.657 ms 36.652 ms 38.186 ms

16 agg10.tustcaft01r.socal.rr.com (66.75.161.48) 39.633 ms 46.706 ms 45.702 ms

17 agg10.lsancarc01r.socal.rr.com (66.75.161.49) 43.710 ms 34.548 ms 42.508 ms

18 agg10.tustcaft01r.socal.rr.com (66.75.161.48) 42.399 ms 38.360 ms 39.058 ms

19 agg10.lsancarc01r.socal.rr.com (66.75.161.49) 41.678 ms 43.000 ms 44.069 ms

20 agg10.tustcaft01r.socal.rr.com (66.75.161.48) 44.913 ms 45.806 ms 46.209 ms

21 agg10.lsancarc01r.socal.rr.com (66.75.161.49) 51.609 ms 50.484 ms 51.050 ms

22 agg10.tustcaft01r.socal.rr.com (66.75.161.48) 53.087 ms 55.045 ms 39.316 ms

23 agg10.lsancarc01r.socal.rr.com (66.75.161.49) 52.467 ms 52.470 ms 52.450 ms

24 agg10.tustcaft01r.socal.rr.com (66.75.161.48) 53.596 ms 43.254 ms 46.939 ms

25 agg10.lsancarc01r.socal.rr.com (66.75.161.49) 51.514 ms 53.067 ms 54.051 ms

26 agg10.tustcaft01r.socal.rr.com (66.75.161.48) 61.721 ms 61.724 ms 61.715 ms

27 agg10.lsancarc01r.socal.rr.com (66.75.161.49) 54.020 ms 54.011 ms 54.003 ms

28 agg10.tustcaft01r.socal.rr.com (66.75.161.48) 51.628 ms 53.483 ms 53.482 ms

29 agg10.lsancarc01r.socal.rr.com (66.75.161.49) 56.560 ms 57.956 ms 58.392 ms

30 agg10.tustcaft01r.socal.rr.com (66.75.161.48) 57.149 ms 58.921 ms 57.447 ms
Retro Card Trading purely on Eth Chain – no side chain or altcoins required
If I understand it correctly it's actually from 1992.

As for Applescript: how precise can we get with it actually? I think when applications use native toolkits Applescript can figure quite much out on its own, but with custom elements (an Electron application), is this still the case?
>It definitely makes them more automatic, but making these contracts more automatic is basically "meh" on the innovation scale.

I don't know, sufficient automation allows for millions of contracts a second, all automatically generated, many relying on layers and layers of hundreds of other automated contracts being executed in real-time.

That is, the difference could be as drastic as between computation algorithms for pen-and-paper, and the Internet as we know it now. Will it? No idea, but I think writing contract automation off as 'meh' is as shortsighted as thinking the Internet is basically a faster postal service that can't deliver packages.
I remember the days when CLIs had a HELP command built in and accurate enough.
Oh and when people read instruction manuals.

A decent manual beats a "discoverable" GUI almost always.
I use the mullvad VPN service for wireguard. They currently have 44 wireguard servers active around the world.
Seven Ways to Combat Poverty
I don’t want to sound like Apple but you are probably using it wrong. I’ve seen people get used to typing on flat chicklet laptop keyboards and then taking those habits over to the proper old style keyboard.

An IBM keyboard is not meant for a typist that keeps their palms resting on desk while slumping in their chair. It’s meant for you to sit up straight and hover your palms over the keyboard.

If you type like that then it seems effortless and the keys feel light and you’ll never have any wrist issues. Reaching the numpad area is also easy because your hand is already in the air. A proper typing technique is like jiu jitsu—it leverages the weight of your entire hand and arm to assist with the key presses. Your hand is loose and mobile, so nerve compression is less likely. On a chicklet keyboard your fingers are mobile but the palms are “glued” in place. This encourages lots of “flexing” the fingers to reach farther placed keys, instead of just moving your entire hand in the “hover” typist approach. My guess is this creates ideal conditions for nerve compression.

The pain is good thing because it lets you know you’re doing something wrong. Using keyboard with low actuation force is just masking the problem. If you do something wrong with less force you will not feel any pain immediately. Same thing as people using shitload of fluffy pillows instead of fixing their sleeping posture. If you sleep on floor it might be uncomfortable at first but it also forces you into better posture, instead of making it bearable to hold a wrong one.
Top 20 Project Management Software Solutions for Small Business in 2018
Yes the government gives consent here but what we argue is should that consent be withdrawn if deaths occurs or can occur.
This is one of the things that I love in PowerShell. It autocompletes the command from all of the commands available through either scripts or modules on the path, and then it autocompletes parameters (their names, and when they're an enumeration, the value). Discoverability makes life much much easier.
In paper newspapers this is the norm. You can read the front page for free, have to pay to get the rest, and the rest is still filled with ads.

The difference is the tracking. I don’t think ads are really the problem. It’s the tracking that bloats pages and intrudes on privacy, and the tracking doesn’t need to be there because other media have ads without tracking and manage just fine.

There’s a race to the
bottom here. Tracking earns more revenue, so to be competitive you have to do it. Most sites won’t stop tracking until forced to by either the basic infrastructure of the web or legal requirements. I hope GDPR will lead to the disappearance of tracking, but so far most sites seem to pretend tracking is compatible with GDPR.
I still use Atom mostly because of the default interface. Care to list the plugins that you used?
Trackpoint. Still in use on new ThinkPads and some other laptops. IBM/Lenovo even has/had desktop keyboards with it.

https://en.wikipedia.org/wiki/Pointing_stick
Maybe I'm biased because I work on a git GUI, but even if you ignore the discoverability and accessibility argument, I think graphically displaying information is useful.

Think about a kanban application - it's just not something that makes sense as a CLI thing. And yes, you could take exclusive control of and draw to the whole screen and use special characters to draw the board, but at that point you're just making a GUI out of text. Usable via terminal emulator does not necessarily mean CLI tool to me, at least within the context of OP's arguments. A lot of the things OP argues have to do with composition. CLI tools are useful in scripts because you can pass them inputs programmatically access and use their output; in this sense, a tool like vim or lynx doesn't fit OP's definition of a CLI tool, they're more like text-based GUIs.
I'd love to see this included as part of the next macOS / iOS.
AppleScript is great, and I taught it to myself when I was 13. I still use it often. But I'm wanting to move to Linux. So far I haven't found a real replacement. If anybody's interested in working on that together, please get in touch!
I also have a crippling fear of flying but i will fly in 10 days so i did a "test run" with Lorazepam which helped my step-dad who didn't fly for 20 years and is now anxiety free during flights with no medication needed. I was watching flight videos on youtube and found myself giggling in euphoria.
What OP fails to see is that GUIs are 80% of the reason why you see technology all around you. It’s the layer of simplification the vast majority of people need. PCs didn’t catch on until the GUIs were born. GUIs help architects design the same buildings OP lives in. 99% of the stuff in his home were designed and crafted tnx to a variety if GUIs in the process.

Having a contrarian view is fine. But keep things in the correct perspective.
Firefox and Safari each have a 'Reader Mode' which does exactly what you want: presenting a web-page in the absence of any web design.

It's really the ultimate condemnation of modern web design that this feature is so useful.

Edit: won't help the data-consumption though, as I believe it can only be enabled after the page has loaded
Reader Mode, my friend.
I also bought one of those. Goodness, how far from the marketing that was.

Honestly, I'm embarrassed I was taken in by the hubris, a little thought about how practical it would be should have been enough. The later firmware did improve it, but sitting waving hands is so inefficient. Hey ho.
Not everyone uses Apple, and not all GUIs use the system widgets. The latter are usually opaque to such scripting tools, at most you can script clicking to a certain position in a window which can break the script if buttons are moved.
GUIs, on the other hand, are much better about showing a user what options / commands are available.

Except when they're not. Take Blender for example - the GUI is contextually sensitive in the sense that buttons do different things in different circumstances, but they don't inform you why or what you can do to change their action. Consequently options are greyed out seemingly randomly. You can't discover things because you can't know the way they work consistently.

Good GUIs are discoverable. Bad GUIs actively work against discoverability.
Hey, nice work! But it seems that the width of the sticky columns get a little jumpy.
https://webmshare.com/vJg80
When I was 18, I could operate an oven.
I think the perfect engineering is to build two pieces: the data functionality should be built into a CLI tool that could potentially be triggered by a human or other third party software, and then build a UI on top that mainly interacts with the CLI. Essentially this is the MVC pattern we nowadays mainly talk about in a web context.
I am actually really happy to see that Mozilla actually acknowledged decentralization as a possibility. Too many people in the tech industry (and outside) got scared by cryptocurrencies that they now immediately associate decentralization to pyramid schemes and dismiss it immediately, disregarding the possibilities it might open up.

Here I hope that Mozilla's "Dweb" will bring something new to the table. I'll be following.
Maintaining such internal APIs is additional work and since most users prefer clicking in GUIs, companies ditched this approach, because it's simpler and cheaper to create a GUI only tool.
What I'd do to be able to hang out in the Library of Alexandria while it was in it's prime. We've lost more than 95% of the books and records that were kept there, I wonder what secrets they held.
There is a ruby gem for Linux called io_splice that does zero-copy IO. Hasn’t been updated in a while but it doesn’t have any dependencies other than modern Linux and doesn’t mean it won’t work. “Old” code that works still works, novelty, job-securitization and API churn be damned when it doesn’t add value.

https://rubygems.org/gems/io_splice/versions/4.4.0

http://www.bigfastblog.com/zero-copy-transfer-data-faster-in...

EDIT: source to current stable coreutils’ cat http://git.savannah.gnu.org/gitweb/?p=coreutils.git;a=blob_p...
I'm not making any of the arguments; just thought it would be an interesting discussion piece.
Hate phone notches? Google says Android handsets can never have more than two
> I drive less than a mile to a bus stop

At that distance shouldn't you be doing walk and ride?
Yes, but don't call it string library then. Strings should handle strings, and strings are unicode now. Unicode needs to be normalized and needs case-insensitive support.

And it's not easy. I implemented the third of its kind. First there was ICU, which is overly bloated. You don't need 30MB for a simple string libc. Then there is libunistring which has overly slow iterators, so not usable for coreutils. And then there's my safelibc, which is small and fast, but only for wide-chars, not utf-8.

I fixed and updated the musl case-mapping, making it 2x faster, but this is not in yet. And there's not even a properly spec'ed wcscmp/wcsicmp to find strings. glibc is an overall mess. I won't touch that. wcsicmp/wcsfc/wcsnorm are not even in POSIX.
The difference is not all nodes are connected to a single central node, some are connected through 2 or more hops.

One might argue this is the same as the current web where we have proxies, load balancers, etc. but the difference is the intermediate nodes are users.

One could also argue this is the same as tor, but the difference is the technology is more at an application level then at a network level, and additionally that every user is effectively equivalent to someone running an exit node.
Yeah, I swear this is being posted so often it’s becoming something I’m starting to ignore (kind of becoming the boy who cried wolf)

It feels like the more recent versions of these articles are more poorly written. This article, however, was much more reasonable.
That seems like a solvable problem. If there's so many reports as to be swamping them, then just those with multiple violations would be reviewed.
You may want to check out the very nice presentation on WireGuard at Kernel Recipes:
https://www.youtube.com/watch?v=9Rk4doELmwM
While I do think the user base is intellectual, theres really not much conversation.

In the good old day there would be a proper forum with conversations that went for months.
> If I understand it correctly it's actually from 1992.

I think you're right–the 1998 is the date it was forwarded, or something like that.

> As for Applescript: how precise can we get with it actually? I think when applications use native toolkits Applescript can figure quite much out on its own, but with custom elements (an Electron application), is this still the case?

AppleScript can do everything you, the GUI user can do, at least for native applications. There is an API for adding functionality that doesn't map cleanly to a user interface through scripting dictionaries, so from a certain perspective it can actually do more.

With regards to Electron, all bets are off: the application only has this functionality if it writes it itself. This is one of the reasons I generally have a distaste for Electron; it really breaks a lot of nice things that the system provides that are nonobvious if you don't use them but really hurt if you do.
> Oh and when people read instruction manuals. A decent manual beats a "discoverable" GUI almost always.

Sorry, but nope. You can rant about GUIs all you want, but UX research did yield a lot of actual insights about how people interact with systems and learn usage. From a learning standpoint, RTFM is enormously inefficient and error-prone.

You can learn about usage of an application a lot faster if you can use existing knowledge (e.g., leveraging standard UI widgets or menu items) and if the application gives you feedback loops, so you can evaluate what a command did or will do (ideally before it does anything consequential)
troll ?
I don't mind it being used in some (mostly) 'closed off' service, but given how commit messages from git will show up on several locations it seems a bad idea to allow users to use `:art:` in a commit message IMHO.
Why does this need to be included in the kernel directly and not just as a loadable module?
Sure, I'm assuming that (a) you are trying to encode all strings of length at most n and (b) you have the uniform distribution over those strings. This makes sense in the original context of encoding random data.
That is just bad design. You would have the exact same problem with CLI if a command was contextual sensitive.
Territoriality is coded really deep in evolution. Even animals as simple as the fruit fly get aggressive when another fly takes its space.
Blender has a fantastic UI though.
Their status page says

> Weâre experiencing network issues with several providers. Get updates on fastmailstatus.com as the situation progresses.

(including the quirks characters, copied directly).

That implies the outage isn't universal, and some ISPs/locations may not be affected. Is anybody able to access through a particular VPN (or country)? If so, posting that here could help others get access to their inboxes faster.
Another blender example: hidden options revealed by sliding the container (which doesn't scale the contents displayed but instead slides out hidden space to reveal additional controls and options)
I'm not saying that everyone has access to this; my goal was to merely bring up an example of a system that already exists and works reasonably well. I'd really love for every application and system to adopt something like this, because, like you've mentioned, other solutions are generally very brittle.
A friendly guide to colours in data visualisation