skysight-inc/HackerNews huggingface dataset:
Things that terrify ICE car drivers about electric vehicles: Range.

Things actual EV drivers rarely worry about: Range.

Things that terrify non-Lisp programmers about Lisp: Parentheses.

Things actual Lisp programmers rarely worry about: Parentheses.
I'm kind of surprised why this is even relevant to you. The designers I know work in Figma. The designer and the engineer collaborate to make sure the design isn't too hard to implement, but other than that the designer shouldn't care about whether developers are using Tailwind, StyleX, Sass, vanilla, or whatever.

I hardly expect a designer to take responsibility for something as transient and idiosyncratic as "oh, but this is hard in Tailwind."
It shadowban all links, it's not ideological, but a mercantile decision (links take you outside).
Design engineers still exist, they just write more JS these days. They are still building UI and design systems and teaching craft & supporting full stack teams. The craft is there, but the tools are different.
Well the west is too busy trying to answer the question “what is a woman” and allowing mass migration into their countries. While Asia is like “there’s men and woman, and we make it hard for you to live in our country and never get citizenship while we out build you in every aspect”
And in 100 years we have gone completely the opposite direction in terms of where we think artificial intelligence lies. Rather than constructing a machine with all the known truths, modern searching for artificial intelligence using machines is mostly sifting through human commentary to create an organized feuilleton machine versus Leibniz's axiomatic approach
> that we can't make them truly understand why something is wrong

There is nothing to understand. Our ancestors, over billions of years, experienced quite a few things. The most important parts transferred from generation to generation by various means. Some parts even got hard coded into our brains firmware. Empathy for example is a fantastic idea. We know that if everyone would live up to those expectations we could create a truly wonderful society. It's not something we've learned or even understand. We just trust our feelings.

It's in err to expect others wired differently to mimic our emotions. The psychopaths developed over billions of years too! When our civilization of abundance fails, like so many before, they will step over the corpses and enjoy robbing some prepper while we won't even be able to string a thought together.

Until that time they will be this weird out of place artifact trying to fit in in a world stacked against them. It's much easier to just learn their logic and apply it only to them. Give them places to fit in. Fewer carrots, more stick.

We keep putting them in charge of the nursery, cry wolf when they ate all the babies and then we kill them. Who's fault is it really?
> This is why I created an abomination that uses go/ast and friends to generate the OpenAPI spec from the code.

This is against "interface first" principle and couples clients of your API to its implementation.

That might be OK if the only consumer of the API is your own application as in that case API is really just an internal implementation detail. But even then - once you have to support multiple versions of your own client it becomes difficult not to break them.
> You get incredibly readable API documentation with protos that isn't muddled with code and business logic.

I mean, ideally (hopefully) in the JSON case there's some class defined in code that they can document in the comments

If it's a shitty shop that's sometimes less likely. Nice thing about protos is that the schemas are somewhere
Strategically increasing the amount of light I'm exposed to was a game changer.

Turns out we're bad at gauging how much light is in our environment. Few would suspect that the amount of lux we're exposed to indoors is often far less than 1% of the lux outside. A typical corporate office has under 500 lux, vs 50k+ midday-if you're at home and haven't put much thought into the lighting situation, the lux could be in the low double digits. You can get a free app "Lux meter" to measure yours now.

We evolved to be outside a lot, and light regulates aspects of our biology. We probably shouldn't stay two orders of magnitude beneath the factory recommended exposure levels for months at a time. Hence clinical or sub-clinical SAD,sleep and mood disturbances etc [see references].

One solution is high wattage LEDs: https://www.benkuhn.net/lux/

I've had several ~250w LEDs over the years (these are huge and actually draw 250w, they aren't 250w equivalent). 250w might be overkill, and 80w is fine for me and a lot more practical. If you get one , be warned that depending on the wattage you'll probably have to build your own stand for it as most fixtures aren't rated for that high wattage.

Related to light amount is of course light timing. This may be more important than getting a steadily high amount of lux during the day. Get lots of light in the morning, and not a lot at night (just low intensity bulbs, maybe just red ones, starting 1-2h after sunset is nice). That helped my sleep a ton. Check out Huberman LAb, he talks about light amount and timing ad nauseam.

[1] Office workers sleep better and are more active with more lighting: https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4031400/

[2] "Day and night light exposure are associated with psychiatric disorders: an objective light study in >85,000 people" https://www.nature.com/articles/s44220-023-00135-8

[3] "Time spent in outdoor light is associated with mood sleep circadian rhythm related outcomes" https://www.ncbi.nlm.nih.gov/pmc/articles/PMC8892387/

...
I doubt anyone would deny the policy actions themselves are clumsy but it's important to remember that a majority of the country believes they are directionally correct. People were desperate to escape the rot of the status quo and chose the high variance option. Michael Moore described it best when he noted that Trump was the human hand grenade that was being tossed in frustration, with a faint hope that things would settle better after the carnage.
> Ulbricht stopped selling them because it wasn't lucrative enough.

While technically accurate, the tone of the Ulbricht quote differs somewhat:

The volume hasn't even been enough to cover server costs and is actually waning at this point. I had high hopes for it, but if we are going to serve an anonymous weapons market, I think it will require more careful thought an planning.
What kind of speeds? When I last contacted them (maybe 3 years ago?) they said they could only guarantee 35Mbps symmetrical, but that most people see more like 80Mbps. That's... not good at all.
I just want the color palette of the Tailwind CSS.
You can usually turn the infotainment screen off completely at night. However, for some manufacturers, this means the screen displays black, but is still powered, ie. the backlight is on, which can be annoing.
Is social media more like cigarettes or junk food?
That's how it is in Vegas presently: CenturyLink has fiber service but it's scattered around unpredictability, and in areas where it's not available it may never be.
Hopefully Google fiber (un)availability doesn't overlap too much, but I expect that it will.
TailwindCSS v4 with new high-performance engine and CSS-first configuration
Ethan Mollick
An army of robot vacuums working tirelessly 24/7 can help.

That is, until they encounter a piece of cat excrement. :)
No. Most people, when they use "REST", do so incorrectly. The article is right, for example, that one of the requirements in the definition of REST was the use of URLs to identify resources:

> REST uses a resource identifier to identify the particular resource involved in an interaction between components.

(And it goes on to cite URLs as an example of a resource identifier in REST as applied to the modern web; note that "REST" is an architectural style to describe the design of systems, the web is an application of that style.)

Many allegedly RESTful APIs simply don't do that, and instead you'll see something like,

{"id": 32, …}

Particularly so when combined with tightly coupled URL construction.

There are other facets of REST that you could compare to most JSON/HTTP APIs and find that they don't obey that facet, either.
what's funny is debating about "what is a woman" vs having to work 6 days a week 6 to 9pm, I know which country I'd rather live in
Where does the Brin-and-Page paper require linear algebra? It mentions "eigenvector" once, in a tangential remark. The "simple iterative algorithm" is how you find the fixed point of any contraction mapping, linear or not. Knowing that it is also an eigenvector is just a distraction -- you aren't going to use Gaussian elimination, not if you know what is good for you.
Why you keep emphasihing the "Western" part? Non-western are any better?
This is actually not that hard to fix.

Getenv() could keep several copies of the value around: one internal copy protected by a mutex, that it never returns, and one copy per thread that it stores in thread local storage. When you call getenv(), it locks the mutex, checks if the current thread's value exists, populates it from the internal copy if not, and returns it. It will also install a new setenv-specific signal handler on this thread and store info about this thread having a copy.

Setenv() will then take the same mutex as getenv(), check if the internal copy is different from the new value; if it is, it will modify the internal copy, modify the local thread's copy if that has one, and then signal each other thread in the process that has a copy in TLS. The setenv signal handler will modify the local copy that thread holds.

It's gonna be slow for a large multi-threaded program, but since setenv() used to corrupt memory for such programs, they probably don't care. And for single-threaded programs, or even for programs that don't access getenv()/setenv() on multiple threads, there should be no extra overhead other than the mutex and the bookkeeping.

The only issues that would remain are programs which send the pointer they get from getenv() to other threads without ensuring locking access, and programs which rely on modifying the pointer from getenv() directly as a way to set an env var, and expect this to be visible across threads. Those are just hopelessly broken and can't use the same API - but aren't more broken then they are today.

Of course, in addition to this complex work to make the old API (mostly) thread safe, it should also offer a new API that simply returns a copy every time, doesn't promise to show modifications to your copy when setenv() gets called (you need to call getenv() again), and puts the onus on you to free that copy explicitly.
Please don't post like this. I actually banned you until I double-checked and saw that you're a legit user.

Your comments have veered too far in the direction of ideological battle and flamewar. That's not what this site is for, and destroys what it is for. Please veer back.

https://news.ycombinator.com/newsguidelines.html
this satisfaction sells. there are companies built on the premise that after the last 1% of effort the sales skyrocket. the marketing narrative of having a complete, high quality product helps to stand out.
It is. One of the biggest points of tension is that we've more or less settled on JSON as an interchange format which is not exactly hypermedia put of the box. That contradiction has severe implications in the application of HATEOS as it exists re JSON APIs.
I'm still a critic in terms of actually using it, but what I find amazing about tailwind is how amenable it is to AI-generated workflows. It seriously works _so good_. Anything can be expressed, and systematically. There's something amazingly useful there.
I assumed Arxiv was peer-reviewed content only, but it looks like that is not the case.

Submission guidelines: https://info.arxiv.org/help/submit/index.html

Moderation process: https://info.arxiv.org/help/moderation/index.html
The performance characteristics won't be great, but it would still be a fun project. In fact one of the early 32-bit RISC processors, PA-RISC, was originally shipped as a set of four large boards covered in discrete 74-series logic. Which actually includes a large ALU chip (without which the design would probably span 8 boards instead...)
This is being talked about in real life as we post on HN: the new administration has a different opinion on this https://www.bbc.com/news/live/cn0y51z7wedt

(I am guessing that there will be a deal floated for Elon to buy TikTok in a few weeks)
This works for products with a very limited scope that are mostly content focused, with a very small design team so everyone can agree to use the very limited toolkit in standards.html. The approach of saying “All ui shall only use these 29 components, anything else is forbidden” is not going to fly in a company with 10s of designers and 100s of engineers.

We tried this style at Airbnb and it turns out forcing all UI changes - from either designers or engineers - to acquire a single exclusive lock on standards.html leads to a fuckton of contention and frustration, and soon people are just going to yolo their own thing totally ignoring the pristine blessed system because the system doesn’t work.

The art of design systems isn’t a single technical approach - it’s finding an optimal workflow so your design engineers can build a UI toolkit that your product teams will actually adopt and contribute to, within the constraints of your existing tech stack & organization.
After playing with it for a couple of minutes, I have to say that it is awesome! Very good UI plus many metrics and factors to play with. Screening based on criteria seems to be a good feature to add. Let me know if you’d like to connect over a meeting for a deeper dive in for my feedback.
> After a year or two of iterating you're back to JSON, checking if fields exist, and re-validating your data.

Every time this has happened to me, it's because of one-sided contract negotiation and dealing with teams where their incentives are not aligned

i.e. they can send whatever shit they want, and we have to interpret it and make it work
Law is the ruling over the living by the dead.
Same here ($65 -> $75); I think it's an "equipment fee." I don't even use the router. My employer covers the cost so I haven't called to complain, but I suspect if you do you can return the router and lose the fee.
Readers might be interested in notepad-next, which is under active development and cross platform: https://github.com/dail8859/NotepadNext
Not working.

Do more? The US is buying pv panels produced on Chinese coal power. And no party is catching China's GHG productions.

Arguing cumulative historicals is playing into propaganda, and per capita? China is doing enough? They're building new coal plants! You can't be serious.
... using... Google... products.
Doesn't this fundamentally misunderstand the Pareto principle? The 80% and 20% of causes in standard examples don't refer to portions of a sequential effort, but rather slices of competing agents/producers/customers in an economic system. Like, 20% of clients account for 80% of sales, that kind of thing.
Exactly, that was my point about then being a word that can be interpreted in two ways, and the following sentence does not error correct this assumption.

If you read it one way, it's almost impossible to not be misdirected, because the following sentence works with both meanings.

If you include the had this would be enough of a clue to correct the incorrect assumption. Although it still might make for slightly bumpy reading.
FYI, it doesn't have horizontal tabs bar.
Limitation reduces available complexity and that’s why tailwind wins. It’s a composable, standardized, and modularized wrapper around a very massive and complex system. That’s a big advancement.
I don't think it's a contractual agreement with X.

The NFL has lots of weird rules, apparently one of them is teams can only create accounts at "approved" social media sites. Probably only a matter of time before it's "approved".
They are probably still making bank on that I bet, my rural area got co-op fiber 2 years ago and its $85 for 250 mbps, which I actually get closer to 350 mbps from, and $125 for full gig symmetrical. And it is rural enough to not even have DSL before now. They have made enough money that they have covered a large chunk of this part of my state which is mostly all rural and have only sped up their area and roll-out of more service.
Yeah, I can replicate work out of a paper quite easily if half or more of the contributors have Chinese, Indian or Russian email addresses.

A lot of small to medium sized companies fighting for mind share also release one script deploy pipelines for their work, which are better than the academic releases.

It's western universities and big tech that releases at best bit rotten code and at worse no code what so ever.
> So if you say REST and mean something other than that, then you're committing to being misunderstood by most people.

Perhaps, but TFA is clearly written in that it is using the actual, real meaning of REST, not the value-drift corruption the laity have wrought. (The upthread comment snips out the surrounding context that brings that clarity.) Which brings us right back to the problem at hand: Potrzebie.
Pray I do not AIter it any further.
Uhhh why is my comment a flamewar?
I love the photo of the information sign "GFiber - Work being performed by ... Permit # ... Phone numbers:"

All the relevant information on one sign.
Seems analogous to me. “20% of the functionality (in a product) is 80% of the work (to implement it)”
While I appreciate that the author put in the time and effort to write this, I have to say that I disagree with pretty much all of this.

Beyond quibbling about specific points, the MVP and the Vertical Slice are functionally similar they totally different in their purpose. Video Games are generally competing for a slice of a large preexisting market. The test is whether it can compete against existing products. A new to the world software start up is trying to serve a need that is currently unserved. The test is whether there is any market at all for this product (PMF). The 80/20 rule is about getting some validation that the thing you are building is worth building in the first place - not that it can be done, but that it should be done.

There aren't a ton of specific examples listed, but the images might insinuate some products that the author has in mind. I would just point out that Magic Leap, Humane were both hardware products that spent >5 years in development. They cam out as completed fully finished products that were complete by any standard. The problem wasn't that these products shipped with missing features, it was that nobody wanted what they were selling (see also the Apple Vision Pro, which is technically phenomenal in terms of design/engineering/manufacturing, but not really very useful). These products did the opposite of the Lean Methodology and show the risk of trying something brand new and not validating the assumptions as quickly as possible.
Again, market cap is not what the company has. It's what the market believes the company should be worth accounting for future earnings.
Isn't this the same as Process Hacker?
Me to ChatGPT:

Assume you are a college instructor for a Freshman Computer Science course.

Your job is to take a pdf file from the internet and teach the topics to you students.

You will do this by writing paragraphs or bullet points about any and all key concepts in the PDF necessary to cover the topic in 2 hours of lectures

The pdf file is at https://arxiv.org/pdf/2501.09223

Build the lecture for me.
But at the same time fiber is even cheaper to rollout than copper lines, and we managed to roll out telephone lines all across the US and to every house without nearly as much trouble. Taking into account inflation it wasn't exactly real cheap to but a telephone line at first, but it was at least available.
...or you could bundle this Notepadjs as an Electron app and subsequently install it via Flatpak (if you're on Linux)

(I'm only half-kidding)
The main benefit of protos is interop between various languages. If you are a single language tech stack, it matters less.

Also, if you use languages outside of Google's primary languages, you're likely not going to get as good of an experience.
> Supported iOS apps and progressive web apps (PWA) as packages that can be shipped via repositories.

iOS apps on f-droid, huh?
The Effect of Dark Mode on Honesty
This is Pretty cool Ali. I always wanted to have a list of people to follow people across all platforms and this can be a good part of that. What are your thoughts on adding more resources beyond just podcasts?
For yourself, sure. But likely not for your users. In fact, I would bet Pareto is not extreme enough in this scenario.

E.g. Excel or git, or their potential eventual successors. Former and latter has largely being the same commands and feature set used by 99% of users since V1. They are now old, storied projects with enhancements and features/improvements that go decades long, and even inspired or spun out new products/projects out of the ideas built within.

For the article itself, Pareto exists as a reminder that work expended is rarely if ever equal to results produced. There are instances where it pays off. But you always pay a price. Make sure you're willing to pay that price.

Sometimes a chair with 3 legs is all you need or care for. That 4th leg might give you more balance in an uneven plane, but I work in a decently flat garage and I'm not paying the premium for that 4th leg.
I wouldn't hold my breath. At my previous house, CenturyLink/quantum site said it was available. I called half a dozen times to get it installed, each time some contractor would show up and tell me it's not available. I was confused because they spent months very visibility installing it throughout the neighborhood. Talking to some of the contractors, it was interesting to hear stories about why it was available in some areas but not others just a few houses down.

Eventually, one of them did figure out how to get me connected.
Does anyone actually use Paxos in real life? And let me ask the same question for all other academic distributed algorithms right away. I recall seeing a study some 10 years ago checking the major cloud providers for Byzantine fault tolerance and finding none of them to exhibit the qualities that the known algorithms would guarantee; apparently they would just rely on timing and hoping things don't get too twisted.
Musk bashes $500B AI project Trump announced, backers don't have the money
For pratical purposes, perhaps this:

Andrew Tridgell and Paul Mackerras, The rsync algorithm, June 1996, https://www.andrew.cmu.edu/course/15-749/READINGS/required/c...
Even then, you could maintain a separate copy of the environment that you control and freely mutate. Basically, during startup, you create a copy of the env you received. Any setenv primitive you expose to users will modify this copy (that you can sync properly yourself). When you want to launch a process, you explicitly provide the internal copy of the env to that process, you don't rely on libc providing its own copy.

Of course, this means you won't see any changes to env vars from libraries you may use that call setenv(), but you also shouldn't need, or want, that in a shell.

I still think having a proper synchronous thread safe setenv()/getenv() in libc is the better choice.
In my part of the industry, a rite of passage is coming up with one's own homegrown data pipeline workflow manager/DAG execution engine.

In the OpenAPI world, the equivalent must be writing one's own OpenAPI spec generator that scans an annotated server codebase, probably bundled with a client codegen tool as well. I know I've written one (mine too was a proper abomination) and it sounds like so have a few others in this thread.