skysight-inc/HackerNews huggingface dataset:
According to the article, the mistake wasn’t that X10 got too far out in front of the team (the initiative to build svc was supposed to be a lone effort), it was Org’s failure to orchestrate a hand-off from X10 to team.
what's option? you mean ctrl?

or alt?
> Although I was on an AI team, I often pushed back against applying AI unless we had a really compelling reason. What is the user problem we are trying to solve? Do we really need an LLM or could a few if statements suffice? Are we sure that natural language is the appropriate interface for this?

This practical approach to AI feels refreshing in a field drowning in buzzwords. I’ve built tools where simple regression models outperformed neural networks, and convincing teams was an uphill battle. It's hard to not get pushback from teams for not going all-in on AI when it seems decisions and budgets are hype-driven.
I've always (well, since Pentium days at least) said you don't actually want your devs using top-end machines, at least for testing and debugging. You want them using the minimum target hardware. That way they'll actually care when the product slow on low end hardware, which will make it usable there and snappy on high end hardware. I've certainly caught a few accidentally-exponential style UI issues which were unnoticeable on a new workstation but very obvious on a slower machine.
Feynman. Von Neumann. Teller. Ulam.

(At least, they all seem pretty non-mystical from what I know of them; I am willing to be corrected by others who know more about their lives and minds.)
Devise bakes in a lot of knowledge about auth. You probably don't need it for a simple app. As your needs grow, when you need things like social logins, Devise makes that easier. If you get really big you probably will have to build out something bespoke anyway. So Devise is sort of for the middle of the journey.
"If I had more time I'd write you a shorter program." :)
This is perhaps what you were hinting at when you said “wouldn’t be ideal”, but Active Record validations on their own are subject to race conditions with concurrent requests. The only truly safe way to ensure integrity of your data is to enforce validations/constraints at the database level.

IME you usually want _both_ the Active Record validations, and the database-level validations, because you get better error messages from the former, and the latter is just a safeguard.
I’m not as inclined to grade Gary Marcus’ predictions leniently as Gary Marcus seems to be.

• 7-10 GPT-4 level models

He only gets to claim this is true if you count a bunch of different versions of the same base model, or if you’re willing to say that some models that outperform GPT-4 on some benchmarks count as being GPT-4 level. I don’t think Marcus was right in spirit, here.

• No massive advance (no GPT-5, or disappointing GPT-5)

Seems too unquantifiable to judge, I would call o1 a massive advance over 4o, but I’m sure Marcus would not.

• Price wars

I guess so? From what I’ve read, the frontier models companies are still profitable, and OpenAI now has a $200/mo commercial model, hardly the action of a company deciding its prices purely to undercut the competition.

• Very little moat for anyone

It still seems like the only companies who have pulled off frontier model capabilities have spent many millions of dollars doing it. I think this might become true next year but I don’t think this can be judged as correct based on what we saw in 2024 alone.

• No robust solution to hallucinations

You only use words like “robust” in a prediction like this so you have room to weasel out of it later when the hallucinations diminish greatly but don’t quite go extinct.

• Modest lasting corporate adoption

My industry is oil and gas. A pretty hidebound and conservative industry. Adoption of LLMs has been massive.

• Modest profits, split 7-10 ways

Define modest.

I score Marcus at 0/7, at best 2/7.
Than? An EV with an LFP battery? Nope. One with an NMC battery? Yes.

We can’t make blanket statements with EVs which was the whole point of my original post.

Edit: from the article:

> Fire crews were on scene within four minutes, and the fire was put out within an hour.

Pretty sure the cybertruck is NMC too, and this is in addition to the fuel canisters and explosives in the vehicle.
The full title is "How AI is unlocking ancient texts — and could rewrite history", and that second part is especially fitting, although unfortunately not mentioned in the article itself, which is full of rather horrifying stories about using AI to "fill in" missing data, which is clearly not true data recovery in any meaningful sense.

I am aware of how advanced algorithms such as those used for flash memory today can "recover" data from imperfect probability distributions naturally created by NAND flash operation, but there seems to a huge gap between those, which are based on well-understood information-theoretic principles, and the AI techniques described here.
You can also make your own functions skippable by default with either the `[[gnu::artificial]]` or (the newer and more generalized) `[[gnu::nodebug]]` in GCC and Clang.
The editor does though, they all know each other. They would know who's not refereeing - and word gets around.
i do have a cloud backup. as i said the cost of that itself is not the issue. the cost of accessing it is. the raid protects against the "dead SSD" failure mode.
My experience is opposite. Getting devise up and running is very easy. Adding OAuth for GitHub, google, and other providers is also very easy. Editing views is pretty straightforward - you can put your forms or whatever you want - just post the form data to devise endpoint and that’s it. All in probably will take 30 minutes to set it up.
Doesn’t that just move the source of bias from the reviewer to the coordinator? Some ‘nobody’ submitting a paper would get a crapshoot reviewer while a recognisable ‘somebody’ gets a well regarded fair reviewer.
I did this on mobile which was challenging. I ended up hugging the left hand wall and taking out enemies as they came into my line of sight.
Japanese dudes are just built different.
Another perspective is that "glue work" is one of the best ways you can generate outsized returns for your effort. Your own efforts scale linearly because you're just one person. Improving everyone's efforts scales multiplicatively, and compounds iteratively.
Why would that be funny if that's statically the most relevant aspect to the problem (not gang related, but urban shootings)? Schools shootings are statistically a very small part of the overall picture, so much so that schools are statistically one of the safest places for children, even more so than at home.
One place that I think there is a big difference in developer experience is in testing. Rails, as described in the article, comes with CI setup and corresponding tests are automatically generated when using rails generators.
Phase 2 China shock is coming: Adam Tooze on Europe, America and manufacturing
Also here with a paywall

https://www.scmp.com/news/china/diplomacy/article/3292636/ph...
>Whether these training set predictive patterns result in the model performing as you might hope on an unseen text depends on the similarity of that text to samples in the training set.

>similarity

yes, except the computer can easily 'see' in more than 3 dimensions with more capability to spot similarities, and can follow lines of prediction (similar to chess) far more than any group of humans can.

that super-human ability to spot similarities and walk latent spaces 'randomly' -yet uncannily - has given rise to emergent phenomena that has mimicked proto-intelligence.

we have no idea what the ideas these tokens have embedded at different layers, and what capabilities can emerge now or at deployment time later, or given a certain prompt.
> The masses don’t give a damn

More important, even people who _do_ give a damn, don't give a damn about everything. And even the things they do give a damn about, they don't give a damn about every time they "do that thing".

I give a damn about music. I have a collection of about 3,000 LPs, a few hundred 12" singles, and over 5,000 CDs. I love to draw the curtains and sit in my dark lounge room, power up my 80's vintage all analogue hifi, and critically listen to albums on vinyl - no distractions, focusing on the music and performance.

But that's only maybe 1% of my music listening time. I spend a lot more time listening to music with my earbuds in while exercising or grocery shopping, or in the car. I spend way more time streaming music around the house while doing chores or cooking or reading. I have playlists of music without vocals that I listen to while doing work I need to be able to concentrate doing. Hell, I have Apple Music streaming right now while reading (and posting to HN.

I _do_ care about music, but you'd need a decent private investigator to find out, it sure as hell isnt obvious to anyone that's not close to me. And even if you tracked my credit card bills you'd see way more streaming subscription spend than vinyl/cd purchases (which are mostly bought for cash at show merch desks these days).

I find most people are passionate about _something_ in the "care about" sense here. I love it when I meet someone new or who I don't know well, and can get into a conversation about "their thing" - whether it's knitting, or building traditional Inuit canoes, or stage lighting for amateur theatre, or ultra light carbon and titanium bicycles, or building a plane, or sailing the north west passage, or setting a land speed record in some very specific class. All things I'm unlikely to ever even consider wanting to do, but which are fascinating to hear about from someone deeply involved in it.

I think (or at least optimistically hope) that "the masses" do give a damn. About _something_. You just need to steer the conversation around a bit to find out what their thing is, and be curious and enthusiastic enough to get them talking about it. Its a wonderful thing when that happens, even if what you end up talking about is the drama in purchasing hand dyed yarn from that one woman in Germany on knitting forums, or the history and current land speed record in the 50cc streamlined motorcycle with gasoline fuel class, or what the recommended shotgun shells are for protection against polar bear attack.
For very simple username/password authentication, what Rails 8 provides is probably sufficient. But the moment you need other auth providers, 2FA, etc., Devise is very much still useful.
"Most people" is not something easy to grasp: can we even know if we belong to this group?

Beside, i'm not sure if this idea of necessarily mediocre majority is actually relevant. Take competitive businesses, sports, or even arts: any edge over the rest can make a big difference.
> Your job is to execute the mission of your company’s leadership.

In a large company, aren't workers incentived to please their immediate manager and whatever higher metrics/appearances they're exposed to.

Neither of these guiding incentives necessarily has much to do with the mission of company leadership.

Isn't the job whatever the incentives say it is?

Maybe the difference between incentives -- and what the author is saying is the job is -- are related to the corporate inefficiency that the author talked about? (For example, an org chart path of imperfectly aligned, imperfectly competent managers means whatever your manager values is "inefficiently" traceable to the mission of company leadership?)
For points 1 and 2:

I recommend and use Cloudinary.
Cloudinary can take care of all that for you!

For point 3:

You can add laoding="lazy" to the image tag, and get lazy loading for free, supported by the browser:

* https://developer.mozilla.org/en-US/docs/Web/Performance/Laz...
> If it were that simple

It is actually that simple. I do that on my GPD Win Mini, which is dual-booting between Linux (CachyOS) and Windows 11. Both boot directly to Steam Big Picture Mode. I've also got Bazzite installed on the same machine, and the user is xperience is identical. Of course, Bazzite has other magic like integrating OS updates into the Steam interface and a bunch of other conveniences, but none of them are really dependent on gamescope.

> everyone would be using Windows on their Steam Deck

There are many reasons to avoid Windows on the Deck, or any gaming machine for that matter - like bloatware, telemetry/spyware etc. And with a gaming optimised Linux distro, you can even get better FPS. There's a lot more to a gaming distro than just tacking on gamescope.

All the other issues you've mentioned are Windows-specific issues, simply running Linux can alleviate all of those. Nothing to do with Gamescope. Same with handling sleep issues - on my GPD Win Mini 2024, running CachyOS and KDE, sleep and resume works perfectly during gaming, without needing gamescope.

Gamescope isn't what is turning the PC into a console, it's Steam Big Picture Mode, which is made better by running it on Linux, which doesn't have all the annoyances of Windows, making for an ideal distraction-free experience.

Don't get me wrong, I still think gamescope is cool - especially for enabling FSR scaling for games which don't support it - but it isn't as essential to the console experience as you make it out to be.
How is the oil and gas industry gaining value from llms?
> Bash: ensure exactly two params are passed, 1st one is a dir, 2nd is a file, enter" than to type the code directly

This seems much simpler than you made it out to be. Why not use ${#FOO[@]} for the number of args.

If you have strict ordering, your program is just as fast to type as it is to ask cursor (imo)

[[ $# == 2 && -d "$1" && -a "$2" ]] || exit 2

alternatively conditionally assigning

[[ $# == 2 && -d "$1" && -a "$2" ]] && PREFIX="$1" && FILE="$2" || exit 2

I'll give you that it is probably faster if you are wanting to write it more correct and be order invariant (not what you asked), but with boiler plate I often just use macros.

I'm curious, what is Cursor's solution? Here's a pretty quick way that leaves some room for expandablity

#!/usr/bin/env bash

declare -ri MAXARGS=2
declare -rA ECODES=(
[GENERAL]=1
[BADARGS]=2
)

FILE=
PREFIX=

fail_with_log() {
echo "$1"
exit ${ECODES[$2]}
}

check_args() {
[[ $# == $MAXARGS ]] \
|| fail_with_log "Wrong number of arguments, expected ${MAXARGS} got $#" "BADARGS"

# We might want to use -f instead of -a
# Check if PREFIX + FILE or FILE + PREFIX
if [[ -d "$1" && -a "$2" ]];
then
PREFIX="$1"
FILE="$2"
elif [[ -a "$1" && -d "$2" ]];
then
FILE="$1"
PREFIX="$2"
else
fail_with_log "Must provide both a file and a directory" "BADARGS"
fi
}

main() {
check_args "$@"
...
}

main "$@" || exit ${ECODES["GENERAL"]}

I mean a bunch of stuff above are superfluous but it doesn't take long to write (can be macro'd) and that little bit adds some flexibility if we want to extend down the line.
There's of course, many ways to write this too. We could use a loop to provide more extensibility or even more conditional assignments. But this feels clearer, even if not very flexible.
It's Never Too Late
There are other aspects of academia in these discussions here, e.g. the stances that default to combative (no citation needed :)

the big part where you surprised me (nicely, I should add) right there is pointing out that what I should not have left implicit was:

Low-brow ">" entertaining

as a metric. At the cost of more words, "entertaining" is quite the moving target. If we make the conceit that "entertainment"="accessible humour" then "Cicero" suggested that we can make our jobs more straightforward.

Finally, sometimes it's the subject matter that is poorly understood.[cheap] humour can even point a laser beam at that cat.

We don't have to blame the language, but it helps!
I imagine that experienced cross-disciplinary designers would concur that all complex design is knowledge building, which is why documenting design decisions is important. You tend to learn this lesson when maintaining projects of nontrivial complexity over a longer period.
As a counter-point (and I know nothing about Gitlab), but GitHub and Shopify are both prominent Rails apps with pretty good security records. GitHub wrote about it last year: https://github.blog/engineering/architecture-optimization/bu...

I think the answer to your question is the same as any large application: pay attention to your supply chain, architect your systems well, if you don’t know how to do things securely go learn before building (or learn as you go, but that has consequences typically).
Competing with women in any arena is at best zero-sum for men.

Do better than women and you get no prestige. Do worse than any woman and you lose a lot of prestige. Both among men, and with women.

That is the basis of the argument for the tipping point theory
As others have mentioned, I’ve not had great performance with shared folders and the SSH extension in VS Code is so damn good. Over time, you forget it’s even running because you open recent projects and it remembers which were local (on host) and which are on the guest and SSH’s in automatically.

I could probably revise my use of Tailscale. My vague recollection is that I had networking issues when my laptop woke up and Tailscale didn’t have the same issues. Probably a debugging skill issue on my part.
> A migration that only happens every couple of decades is guaranteed to be one we never get good at, and flub every time.

Related: we have leap years regularly, and yet people flub February 29 regardless of the predictable occurrences.
I agree with your approach. It’s easy to empathize with innocent people in say, Russia, blocked from a site which has useful information to them. However the thing these “spirit/openness” people miss is that many sites have a narrow purpose which makes no sense to open it up to people across the world. For instance, local government. Nobody in India or Russia needs to see the minutes from some US city council meeting, or get building permit information. Likewise with e-commerce. If I sell chocolate bars and ship to US and Canada, why wouldn’t I turn off all access from overseas? You might say “oh, but what if some friend in $COUNTRY wants to order a treat for someone here?” And the response to that is always “the hypothetical loss from that is minuscule compared to the cost of serving tons of bot traffic as well as possible exploits those bots might do.

(Yes, yes, VPNs and proxies exist and can be used by both good and bad actors to evade this strategy, and those are another set of IPs widely banned for the same reason. It’s a cat and mouse game but you can’t argue with the results)
"Quality" is what we call the difference between what we like and what's objectively successful, not a property of any object. It's the name we give to one of many ways we confuse "is" and "ought."

There's nothing we can say about a thing with "quality" we couldn't also say by tediously listing every single property it has. The only thing that only "quality" can add is information about what the speaker thinks is good.

In other words, it's purely an opinion. If most people don't have strong opinions on most products, which seems true, then quality is null for most pairs of person and product—so "most people don't care about quality."
I thought 2024 was very underwhelming for Rails - not really big advancements besides Kamal and Kamal should not have been part of rails to start with. If rails team wants to work on docker deployment tool, they can - just don’t call it rails feature
Range queries over strings are extremely common. For example, databases like cockroachdb and yuggabytedb use the table name as a prefix which then requires a range query to narrow down queries against a specific table.
Turning Apple notes folder into a website
Ai also works better with more mature frameworks that have a lot of examples/questions/posts on the internet where the API has been mostly the same for a while, like Rails
Sometimes those "glue work" folks start their own startups and make millions
Not hands on with Django (or other Python based frameworks) so pardon the basic question. How do the speed of the generated application compare with the speed of a generated rails application? I know the latter has made some strides recently..
Azor movie review and film summary (2021)
The biggest difference is python vs ruby. Python’s ecosystem is massive, so if you want to pull in any third party libs you have plenty of choices for whatever you may need. Django also has auth and the admin interface built in, both of which are very nice.
> Are companies stupid

It doesn't sound glamorous for product, and they don't get the value of it most of the time.

And if they are deliberately against it - they are stupid indeed.
Are you confusing it with Litestream, the backup solution? https://litestream.io

What they meant was https://github.com/oldmoe/litestack which has a lot of things built on top of sqlite, like job queue and caches. Rails 8 now comes with most of them out of the box.

My SaaS ran on litestack until rails 8 came out, then I switched without problems.
Hey, thank you, I like scrollbars. :)

Oh, and, nice project. Thoroughly agree with the sentiments expressed in the FAQ.
I'm pleasantly surprised to see this improvement:

Tempfile.create(anonymous: true) removes the created temporary file
immediately. So applications don’t need to remove the file.
[Feature #20497]

I use a similar pattern a lot:

file = Tempfile.new.tap(&:unlink)
file << "... some really large data to pipe"
system("md5sum", in: file.tap(&:rewind))

It's a neat trick to leverage the filesystem for large amounts of data (e.g. "psql \copy" generation), without littering tempfiles everywhere. Once the last fd disappears, the filesystem releases the data; so you don't have to "trap" signals and add cleanup routines. (Hint: you can also use these unlinked-tempfiles for command output, e.g. huge grep output, etc.)

On Linux systems, `open(..., O_TMPFILE)` is typically used, which provides additional safety. The created file is initially unnamed (no race condition between `open` and `unlink`).

When I needed safety, my non-portable solution was to use Ruby's syscall feature. (Btw, I love that you can do this.)

require "fcntl"

SYS_OPEN = 2
O_TMPFILE = 0x00410000
O_RDWR = Fcntl::O_RDWR

def tmpfile
mode = O_RDWR | O_TMPFILE
fd = syscall(SYS_OPEN, "/dev/shm", mode, 0644)
IO.for_fd(fd)
end

But... Another pleasant surprise from the PR (https://bugs.ruby-lang.org/issues/20497).

Linux 3.11 has O_TMPFILE to create an unnamed file.
The current implementation uses it.

Excellent to see :)
Makes the PR even better!
I love this idea. You could generate a 3d world like that so that you can zoom in and out combining the objects like pins in a map.

You could also run the drawing by an image generator and get a livingroom both like and unlike your own.
A single-purpose state machine not failing to do the single thing it was created to do does not make for the clever retort you think it makes.

"AGI": emphasis on "G" for "General". The LLMs are not failing to do generalized tasks, and that they are nondeterministic is not a bug. Just don't use them for calculating sales tax. You wouldn't hire a human to calculate sales tax in their head, so why do you make this a requirement in order to call an LLM "AGI"?

I wonder when the goalposts will stop moving from "We have superhuman intelligences which are able to rather reliably converse in many languages, do generalized tasks and automate operations we thought were impossible to automate 3 years ago" (and by the way, this is what we have TODAY), all the way to "It's not AGI unless it's an omnipotent god that knows how to turn water into wine and calculate the applicable sales tax of that operation".
Gotta say, this comment is spot on. I had a small peek under the covers when another of the major severity issues surfaced and the conclusion reached is that the software is fragile as f*k. I'll be migrating as soon as I have some spare cycles. Still no conclusion as to whether Rails, Ruby or GitLab is the major contributor, but the result is awefull.