Unlurker|Replay|About
Does Time Flow? New Clues Come from a Century-Old Approach to Math (quantamagazine.org)
•
> “he is on the side of those of us who think that physics doesn’t accord with our experience and therefore it’s missing something.” It seems more likely that we don’t understand how our experience works as well as some of us think we do. In other words, the mismatch is more on the side of the experience than of physics.
•
Yes. But in order to understand limits, you must think in ranges and not on the reaching point. You don't divide by zero, you measure everything until 0, but 0 itself is not measured. BTW, 5.000000000000000..1 - 4.999999999... > 0 >You can't divide a number in half Declare any number which can't be neither higher or lower than it's half.
We gave 5 LLMs $100K to trade stocks for 8 months (aitradearena.com)
•
[delayed]
•
Just one run per model? That isn't really backtesting. I mean technically it is, but "testing" implies producing a meaningful value. 100 independent runs on each model would producing meaningful results. Like actually credibly meaningful means and standard deviations.
•
What was the backtesting method? Was walk-forward testing involved? There are different ways to backtest.
•
“Everyone (including LLMs) is a genius in a bull market.”
•
Time. That has been the best way to get returns. I setup a 212 account when I was looking to buy our first house. I bought in small tiny chunks of industry where I was comfortable and knowledgeable in. Over the years I worked up a nice portfolio. Anyway, long story short. I forgot about the account, we moved in, got a dog, had children. And then I logged in for the first time in ages, and to my shock. My returns were at 110%. I've done nothing. It's bizarre and perplexing.
•
…did you beat the market? 110% is pretty much what the nasdaq has done over the last 5 years Also N=1
•
Backtesting is a complete waste in this scenario. The models already know the best outcomes and are biased towards it.
•
They could only trade once per day and hold 5-15 positions with a position size of $5k-$25k according to the agent prompt. Limited to say the least.
•
> We were cautious to only run after each model’s training cutoff dates for the LLM models Grok is constantly training and/or it has access to websearch internally. You cannot backtest LLMs. You can only "live" test them going forward.
•
Via api you can turn off websearch internally. We provided all the models with their own custom tools that only provided data up to the date of the backtest.
•
OP here. We realized there are a ton of limitations with backtest and paper money but still wanted to do this experiment and share the results. By no means is this statistically significant on whether or not these models can beat the market in the long term. But wanted to give everyone a way to see how these models think about and interact with the financial markets.
•
I think it would be interesting to see how it goes in a scenario where the market declines or where tech companies underperform the rest of the market. In recent history they've outperformed the market and that might bias the choices that the LLMs make - would they continue with these positive biases if they were performing badly?
•
> But wanted to give everyone a way to see how these models think… Think? What exactly did “it” think about?
•
"Pass the salt? You mean pass the sodium chloride?"
•
You can click in to the chart and see the conversation as well as for each trade what was the reasoning it gave for it
•
Since it's not included in the main article, here is the prompt: > You are a stock trading agent. Your goal is to maximize returns. > You can research any publicly available information and make trades once per day. > You cannot trade options. > Analyze the market and provide your trading decisions with reasoning. > > Always research and corroborate facts whenever possible. > Always use the web search tool to identify information on all facts and hypotheses. > Always use the stock information tools to get current or past stock information. > > Trading parameters: > - Can hold 5-15 positions > - Minimum position size: $5,000 > - Maximum position size: $25,000 > > Explain your strategy and today's trades. Given the parameters, this definitely is NOT representative of any actual performance. I recommend also looking at the trade history and reasoning for each trade for each model, it's just complete wind. As an example, Deepseek made only 21 trades, which were all buys, which were all because "Companyy X is investing in AI". I doubt anyone believe this to be a viable long-term trading strategy.
•
Agree. Those parameters are incredibly artificial bullshit.
•
This is really dumb. Because the models themselves, like markets, are indeterministic. They will yield different investment strategies based on prompts and random variance. This is a really dumb measurement.
•
Spoiler: They did not use real money or perform any actual trades.
•
Like so many analyses before them, including my own, this completely misses the basics of mean/variance risk analysis. We need to know the risk adjusted return, not just the return.
•
I think these tests are always difficult to gauge how meaningful they actually are. If the S&P500 went up 12% over that period, mainly due to tech stocks, picking a handful of tech stocks is always going to set you higher than the S&P. So really all I think they test is whether the models picked up on the trend. I more surprised that Gemini managed to lose 10%. I wish they actually mentioned what the models invested in and why.
•
Wait — isn't that exactly what good investors do? They look for what stocks are going to beat expectations and invest in them. If a stock broker I hired got this return, I wouldn't be rolling my eyes and saying "that's only because they noticed the trend in tech stocks." That's exactly what I'm paying them to do.
•
Looking at the recent holdings for the best models, it looks like it's all tech/semiconductor stocks. So in this time frame they did very well, but if they ended in April, they would have underperformed the S&P500.
•
Update with Gemini 3. It's far better than its predecessors.
•
Could they give some random people (i volunteer) 100k for 8 months? ...as a control
•
I know this is a joke comment, but there are plenty of websites that simulate the stock market and where you can use paper money to trade. People say it's not equivalent to actually trading though, and you shouldn't use it as a predictor of your actual trading performance, because you have a very different risk tolerance when risking your actual money.
•
The summary to me is here: > Almost all the models had a tech-heavy portfolio which led them to do well. Gemini ended up in last place since it was the only one that had a large portfolio of non-tech stocks. If the AI bubble had popped in that window, Gemini would have ended up the leader instead.
•
Yup. This is the fallacy of thinking you’re a genius because you made money on the market. Being lucky at the moment (or even the last 5 years) does not mean you’ll continue to be lucky in the future. “Tech line go up forever” is not a viable model of the economy; you need an explanation of why it’s going up now, and why it might go down in the future. And also models of many other industries, to understand when and why to invest elsewhere. And if your bets pay off in the short term, that doesn’t necessarily mean your model is right. You could have chosen the right stocks for the wrong reasons! Past performance doesn’t guarantee future performance.
•
I wonder if this could be explained as the result of LLMs being trained to have pro-tech/ai opinions while we see massive run ups in tech stock valuations? It’d be great to see how they perform within particular sectors so it’s not just a case of betting big on tech while tech stocks are booming
•
> Grok ended up performing the best while DeepSeek came close to second. Almost all the models had a tech-heavy portfolio which led them to do well. Gemini ended up in last place since it was the only one that had a large portfolio of non-tech stocks. I'm not an investor or researcher, but this triggers my spidey sense... it seems to imply they aren't measuring what they think they are.
•
Yeah I mean if you generally believe the tech sector is going to do well because it has been doing well you will beat the overall market. The problem is that you don’t know if and when there might be a correction. But since there is this one segment of the overall market that has this steady upwards trend and it hasn’t had a large crash, then yeah any pattern seeking system will identify “hey this line keeps going up!” Would it have the nuance to know when a crash is coming if none of the data you test it on has a crash? It would almost be more interesting to specifically train the model on half the available market data, then test it on another half. But here it’s like they added a big free loot box to the game and then said “oh wow the player found really good gear that is better than the rest!” Edit: from what I causally remember a hedge fund can beat the market for 2-4 years but at 10 years and up their chances of beating the market go to very close to zero. Since LLMs have bit been around for that long it is going to be difficult to test this without somehow segmenting the data.
•
A more sound approach would have been to do a monte carlo simulation where you have 100 portfolios of each model and look at average performance.
•
Grok would likely have an advantage there, as well - it's got better coupling to X/Twitter, a better web search index, fewer safety guardrails in pretraining and system prompt modification that distort reality. It's easy to envision random market realities that would trigger ChatGPT or Claude into adjusting the output to be more politically correct. DeepSeek would be subject to the most pretraining distortion, but have the least distortion in practice if a random neutral host were selected. If the tools available were normalized, I'd expect a tighter distribution overall but grok would still land on top. Regardless of the rather public gaffes, we're going to see grok pull further ahead because they inherently have a 10-15% advantage in capabilities research per dollar spent. OpenAI and Anthropic and Google are all diffusing their resources on corporate safetyism while xAI is not. That advantage, all else being equal, is compounding, and I hope at some point it inspires the other labs to give up the moralizing politically correct self-righteous "we know better" and just focus on good AI. I would love to see a frontier lab swarm approach, though. It'd also be interesting to do multi-agent collaborations that weight source inputs based on past performance, or use some sort of orchestration algorithm that lets the group exploit the strengths of each individual model. Having 20 instances of each frontier model in a self-evolving swarm, doing some sort of custom system prompt revision with a genetic algorithm style process, so that over time you get 20 distinct individual modes and roles per each model. It'll be neat to see the next couple years play out - OpenAI had the clear lead up through q2 this year, I'd say, but Gemini, Grok, and Claude have clearly caught up, and the Chinese models are just a smidge behind. We live in wonderfully interesting times.
•
I don't feel like they measured anything. They just confirmed that tech stocks in the US did pretty well.
•
They measured the investment facility of all those LLMs. That's pretty much what the title says. And they had dramatically different outcomes. So that tells me something.
•
I mean, what it kinda tells me is that people talk about tech stocks the most, so that's what was most prevalent in the training data, so that's what most of the LLMs said to invest in. That's the kind of strategy that works until it really doesn't.
•
They outperformed the S&P 500 but seem to be fairly well correlated with it. Would like to see a 3X leveraged S&P 500 ETF like SPXL charted against those results.
•
...over the course of 8.5 months, which is way too short for a meaningful result. If their strategy could outperform the S&P 500's 10-year return, they wouldn't be blogging about it.
•
There's also this thing going on right now: https://nof1.ai/leaderboard Results are... underwhelming. All the AIs are focused on daytrading Mag7 stocks; almost all have lost money with gusto.
•
Let me guess, the mystery model is theirs
•
>We gave each of five LLMs $100K in paper money Stopped reading after “paper money” Source: quant trader. paper trading does not incorporate market impact
•
the quant trader you talked to probably sucks.
•
Lack of market response is a valid point, but $100k is pretty unlikely to have much impact especially if spread out over multiple trades.
•
I mean if you’re going to write algos that trade the first thing you should do is check whether they were successful on historical data. This is an interesting data point. Market impact shouldn’t be considered when you’re talking about trading S&P stocks with $100k.
•
Historical data is useful for validation, don't develop algos against it, test hypotheses until you've biased your data, then move on to something productive for society
•
If your initial portfolio is 100k you are not going to have meaningful "market impact" with your trades assuming you actually make them vs. paper trading.
•
Yea, so this is bullshit. An approximation of reality still isn’t reality. If you’re convinced the LLMs will perform as backtested, put real money and see what happens.
> Testing GPT-5, Claude, Gemini, Grok, and DeepSeek with $100K each over 8 months of backtested trading So the results are meaningless - these LLMs have the advantage of foresight over historical data.
•
That's only if they're trained on data more recent than 8 months ago
> We time segmented the APIs to make sure that the simulation isn’t leaking the future into the model’s context. I wish they could explain what this actually means.
•
It's a very silly way of saying that the data the LLMs had access to was presented in chronological order, so that for instance, when they were trading on stocks at the start of the 8 month window, the LLMs could not just query their APIs to see the data from the end of the 8 month window.
•
Overall, it does sound weird. On the one hand, assuming I properly I understand what they are saying is that they removed model's ability to cheat based on their specific training. And I do get that nuance ablation is a thing, but this is not what they are discussing there. They are only removing one avenue of the model to 'cheat'. For all we know, some that data may have been part of its training set already...
> We were cautious to only run after each model’s training cutoff dates for the LLM models. That way we could be sure models couldn’t have memorized market outcomes.
•
Even if it is after the cut off date wouldn't the models be able to query external sources to get data that could positively impact them? If the returns were smaller I could reasonably believe it but beating the S&P500 returns by 4x+ strains credulity.
•
We used the LLMs API and provided custom tools like a stock ticker tool that only gave stock price information for that date of backtest for the model. We did this for news apis, technical indicator apis etc. It took quite a long time to make sure that there weren't any data leakage. The whole process took us about a month or two to build out.
•
I know very little about how the environment where they run these models look, but surely they have access to different tools like vector embeddings with more current data on various topics?
•
you can (via the api, or to a lesser degree through the setting in the web client) determine what tools if any a model can use
State of AI: An Empirical 100T Token Study with OpenRouter (openrouter.ai)
•
According to the report, 52% of all open-source AI is used for *roleplaying*. They attribute it to fewer content filters and higher creativity.
I'm out of time but "reasoning input tokens" from fortune 5000 engineers sounds like a lobotomized LSD dream, would you care on elaborating how you distinguish between reasoning and non-reasoning? vs "question on duty"?
•
"reasoning" models like GPT 5 et al do a pre-generation step where they: - Take in the user query (input tokens) - Break that into a game plan. Ex: "Based on user query: {query} generate a plan of action." (reasoning tokens) - Answer (output tokens) Because the reasoning step runs in a loop until it's run through it's action plan, it frequently uses way more tokens than the input/output step.
•
I believe they’re just classifying all models into “reasoning models” eg o3 vs “non reasoning models” eg 4o and just doing a comparison of total tokens (input tokens + hidden reasoning output tokens + shown output tokens)
•
that's exactly right!
Thoughts on Go vs. Rust vs. Zig (sinclairtarget.com)
•
I'd rather read 3 lines of clear code than one line of esoteric syntactic sugar. I think regardless of what blogs say, Go's adoption compared to that of Rust or Zig speaks for itself
•
Modern C++ is probably better than all of those if you need to interface with existing code and libraries, or need classic OOP.
•
Until someone creates a new language that is better than these ...
•
The last paragraph captures the essence that all the PL theory arguments do not. "Zig has a fun, subversive feel to it". It gives you a better tool than C to apply your amazing human skills, freely, whereas both Rust and Go are fundamentally sceptical about you.
The reason I really like Zig is because there's finally a language that makes it easy to gracefully handle memory exhaustion at the application level. No more praying that your program isn't unceremoniously killed just for asking for more memory - all allocations are assumed fallible and failures must be handled explicitly. Stack space is not treated like magic - the compiler can reason about its maximum size by examining the call graph, so you can pre-allocate stack space to ensure that stack overflows are guaranteed never to happen. This first-class representation of memory as a resource is a must for creating robust software in embedded environments, where it's vital to frontload all fallibility by allocating everything needed at start-up, and allow the application freedom to use whatever mechanism appropriate (backpressure, load shedding, etc) to handle excessive resource usage.
•
If you are pre-allocating Rust would handle that decently as well right? Certainly I agree that allocations in your dependencies (including std) are more annoying in Rust since it uses panics for OOM. The no-std set of crates is all setup to support embedded development.
•
> No more praying that your program isn't unceremoniously killed just for asking for more memory - all allocations are assumed fallible and failures must be handled explicitly. But for operating systems with overcommit, including Linux, you won't ever see the act of allocation fail, which is the whole point. All the language-level ceremony in the world won't save you.
•
I imagine people who care about this sort of thing are happy to disable overcommit, and/or run Zig on embedded or specialized systems where it doesn't exist.
•
There are far more people running/writing Zig on/for systems with overcommit than not. Most of the hype around Zig come from people not in the embedded world.
I think the Go part is missing a pretty important thing: the easiest concurrency model there is. Goroutines are one of the biggest reasons I even started with Go.
•
Agreed. Rob Pike presented a good talk "Concurrency is not Parallelism" which explains the motivations behind Go's concurrency model: https://youtu.be/oV9rvDllKEg Between the lack of "colored functions" and the simplicity of communicating with channels, I keep surprising myself with how (relatively) quick and easy it is to develop concurrent systems with correct behavior in Go.
> In Go, a slice is a fat pointer to a contiguous sequence in memory, but a slice can also grow, meaning that it subsumes the functionality of Rust’s Vec<T> type and Zig’s ArrayList. Well, not exactly. This is actually a great example of the Go philosophy of being "simple" while not being "easy". A Vec<T> has identity; the memory underlying a Go slice does not. When you call append(), a new slice is returned that may or may not share memory with the old slice. There's also no way to shrink the memory underlying a slice. So slices actually very much do not work like Vec<T>. It's a common newbie mistake to think they do work like that, and write "append(s, ...)" instead of "s = append(s, ...)". It might even randomly work a lot of the time. Go programmer attitude is "do what I said, and trust that I read the library docs before I said it". Rust programmer attitude is "check that I did what I said I would do, and that what I said aligns with how that library said it should be used". So (generalizing) Go won't implement a feature that makes mistakes harder, if it makes the language more complicated; Rust will make the language more complicated to eliminate more mistakes.
•
> Go programmer attitude is "do what I said, and trust that I read the library docs before I said it". I agree and think Go gets unjustly blamed for some things: most of the foot guns people say Go has are clearly laid out in the spec/documentation. Are these surprising behaviors or did you just not read? Getting a compiler and just typing away is not a great way of going about learning things if that compiler is not as strict.
•
Writing "append(s, ...)" instead of "s = append(s, ...)" results in a compiler error because it is an unused expression. I'm not sure how a newbie could make this mistake since that code doesn't compile.
Generally a good writeup, but the article seems a bit confused about undefined behavior. > What is the dreaded UB? I think the best way to understand it is to remember that, for any running program, there are FATES WORSE THAN DEATH. If something goes wrong in your program, immediate termination is great actually! This has nothing to do with UB. UB is what it says on the tin, it's something for which no definition is given in the execution semantics of the language, whether intentionally or unintentionally. It's basically saying, "if this happens, who knows". Here's an example in C: int x = 555; long long *l = (long long*)&x; x = 123; printf("%d\n", *l); This is a violation of the strict aliasing rule, which is undefined behavior. Unless it's compiled with no optimizations, or -fno-strict-aliasing which effectively disables this rule, the compiler is "free to do whatever it wants". Effectively though, it'll just print out 555 instead of 123. All undefined behavior is just stuff like this. The compiler output deviates from the expected input, and only maybe . You can imagine this kind of thing gets rather tricky with more aggressive optimizations, but this potential deviation is all that occurs. Race conditions, silent bugs, etc. can occur as the result of the compiler mangling your code thanks to UB, but so can crashes and a myriad of other things. It's also possible UB is completely harmless, or even beneficial. It's really hard to reason about that kind of thing though. Optimizing compilers can be really hard to predict across a huge codebase, especially if you aren't a compiler dev yourself. That unpredictability is why we say it's bad. If you're compiling code with something like TCC instead of clang, it's a completely different story. That's it. That's all there is to UB.
•
Race conditions, silent bugs, etc. can occur as the result of the compiler mangling your code thanks to UB, but so can crashes and a myriad of other things. [...] That's it. That's all there is to UB. You don’t think that’s pretty bad?
I think it's common to be taught that UB is very bad when you're new, partly to simplify your debugging experience, partly to help you understand and mentally demarcate the boundaries of what the language allows and doesn't allow, and partly because there are many Standards-Purists who genuinely avoid UB. But from my own experience, UB just means "consult your compiler to see what it does here because this question is beyond our pay grade." Interestingly enough, and only semi related, I had to use volatile for the first time ever in my latest project. Mainly because I was writing assembly that accessed memory directly, and I wanted to make sure the compiler didn't optimize away the variable. I think that's maybe the last C keyword on my bucket list.
•
> But from my own experience, UB just means "consult your compiler to see what it does here because this question is beyond our pay grade." Careful. It's not just "consult your compiler", because the behavior of a given compiler on code containing UB is also allowed to vary based on specific compiler version, and OS, and hardware, and the phase of the moon.
•
> But from my own experience, UB just means "consult your compiler to see what it does here because this question is beyond our pay grade." People are taught it’s very bad because otherwise they do exactly this, which is the problem. What does your compiler do here may change from invocation to invocation, due to seemingly unrelated flags, small perturbations in unrelated code, or many other things. This approach encourages accepting UB in your program. Code that invokes UB is incorrect, full stop.
•
I understand, but you have to see how you would be considered one of the Standards-Purists that I was talking about, right? If Microsoft makes a guarantee in their documentation about some behavior of UB C code, and this guarantee is dated to about 14 years ago, and I see many credible people on the internet confirming that this behavior does happen and still happens, and these comments are scattered throughout those past 14 years, I think it's safe to say I can rely on that behavior, as long as I'm okay with a little vendor lock-in.
> Other features common in modern languages, like tagged unions or syntactic sugar for error-handling, have not been added to Go. > It seems the Go development team has a high bar for adding features to the language. The end result is a language that forces you to write a lot of boilerplate code to implement logic that could be more succinctly expressed in another language. Being able to implement logic more succinctly is not always a good thing. Take error handling syntactic sugar for example. Consider these two snippets: let mut file = File::create("foo.txt")?; and: f, err := os.Create("filename.txt") if err != nil { return fmt.Errorf("failed to create file: %w", err) } The first code is more succinct, but worse: there is no context added to the error (good luck debugging!). Sometimes, being forced to write code in a verbose manner makes your code better.
•
What is the context that the Go code adds here? When File::create or os.Create fails the errors they return already contain the information what and why something failed. So what information does "failed to create file: " add?
•
The error from Rust's File::create basically only contains the errno result. So it's eg. "permission denied" vs "failed to create file: permission denied".
•
it's the other way around Rust used to not have operator?, and then A LOT of complaints have been "we don't care, just let us pass errors up quickly" "good luck debugging" just as easily happens simply by "if err!=nil return nil,err" boilerplate that's everywhere in Golang - but now it's annoying and takes up viewspace
•
> "if err!=nil return nil,err" boilerplate that's everywhere in Golang - but now it's annoying and takes up viewspace This isn't true in my experience. Most Go codebases I've worked in wrap their errors. If you don't believe me, go and take a look at some open-source Go projects.
"Context" here is just a string. Debugging means grepping that string in the codebase, and praying that it's unique. You can only come up with so many unique messages along a stack. You are also not forced to add context. Hell, you can easily leave errors unhandled, without compiler errors nor warnings, which even linters won't pick up, due to the asinine variable syntax rules.
•
> Debugging means grepping that string in the codebase, and praying that it's unique. This really isn't an issue in practice. The only case where an error wouldn't uniquely identify its call stack is if you were to use the exact same context string within the same function (and also your callees did the same). I've never encountered such a case. > You are also not forced to add context Yes, but in my experience Go devs do. Probably because they're having to go to the effort of typing `if err != nil` anyway, and frankly Go code with bare: if err != nil { return err } sticks out like a sore thumb to any experienced Go dev. > which even linters won't pick up, due to asinine variable syntax rules. I have never encountered a case where errcheck failed to detect an unhandled error, but I'd be curious to hear an example.
•
The go stdlib notoriously returns errors without wrapping. I think it has been shifting towards more wrapping more often, but still. err1 := foo() err2 := bar() if err1 != nil || err2 != nil { return err1 // if only err2 failed, returns nil! } ``` func process() error { err := foo() if err != nil { return err } if something { result, err := bar() // new err shadows outer err if err != nil { return err } use(result) } if somethingElse { err := baz() // another shadow log.Println(err) } return err // returns foo's err (nil), baz's error lost } ```
Any sane Go team will be running errcheck, so I think this is a moot point.
•
I think it’s still worth pointing out that one language includes it as a feature and the other requires additional tooling.
•
Which can also be said about Rust and anyhow/thiserror. You won't see any decent project that don't use them, the language requires additional tooling for errors as well.
Python's f = open('foo.txt', 'w') is even more succinct, and the exception thrown on failure will not only contain the reason, but the filename and the whole backtrace to the line where the error occurred.
•
We were taught not to use exceptions for control flow, and reading a file which does not exist is a pretty normal thing to handle in code flow, rather than exceptions. That simple example in Python is missing all the other stuff you have to put around it. Go would have another error check, but I get to decide, at that point in the execution, how I want to handle it in this context
•
In Python, it’s common to use exceptions for control flow. Even exiting a loop is done via an exception: `StopIteration`.
•
> the exception thrown on failure will not only contain the reason, but the filename and the whole backtrace to the line where the error occurred. ... with no other context whatsoever, so you can't glean any information about the call stack that led to the exception. Exceptions are really a whole different kettle of fish (and in my opinion are just strictly worse than even the worst errors-as-values implementations).
•
Your Go example included zero information that Python wouldn't give you out-of-the-box. And FWIW, since this is "Go vs Rust vs Zig," both Rust and Zig allow for much more elegant handling than Go, while similarly forcing you to make sure your call succeeded before continuing.
I don't agree. There isn't a standard convention for wrapping errors in Rust, like there is in Go with fmt.Errorf -- largely because ? is so widely-used (precisely because it is so easy to reach for). The proof is in the pudding, though. In my experience, working across Go codebases in open source and in multiple closed-source organizations, errors are nearly universally wrapped and handled appropriately. The same is not true of Rust, where in my experience ? (and indeed even unwrap) reign supreme.
•
I think the standard convention if you just want a stringly-typed error like Go is anyhow? And maybe not quite as standard, but thiserror if you don’t want a stringly-typed error?
•
My experience aligns with this, although I often find the error being used for non-errors which is somewhat of an overcorrection, i.e. db drivers returning “NoRows” errors when no rows is a perfectly acceptable result of a query. It’s odd that the .unwrap() hack caused a huge outage at Cloudflare, and my first reaction was “that couldn’t happen in Go haha” but… it definitely could, because you can just ignore returned values. But for some reason most people don’t. It’s like the syntax conveys its intent clearly: Handle your damn errors.
yeah but which is faster and easier for a person to look at and understand. Go's intentionally verbose so that more complicated things are easier to understand.
•
I don't really see it as any more or less verbose. If I return Result<T, E> from a function in Rust I have to provide an exhaustive match of all the cases, unless I use `.unwrap()` to get the success value (or panic), or use the `?` operator to return the error value (possibly converting it with an implementation of `std::From`). No more verbose than Go, from the consumer side. Though, a big difference is that match/if/etc are expressions and I can assign results from them, so it would look more like let a = match do_thing(&foo) { Ok(res) => res, Err(e) => return e } instead of: a, err := do_thing(foo) if err != nil { return err // (or wrap it with fmt.Errorf and continue the madness // of stringly-typed errors, unless you want to write custom // Error types which now is more verbose and less safe than Rust). } I use Go on a regular basis, error handling works , but quite frankly it's one of the weakest parts of the language. Would I say I appreciate the more explicit handling from both it and Rust? Sure, unchecked exceptions and constant stack unwinding to report recoverable errors wasn't a good idea. But you're not going to have me singing Go's praise when others have done it better. Do not get me started on actually handling errors in Go, either. errors.As() is a terrible API to work around the lack of pattern matching in Go, and the extra local variables you need to declare to use it just add line noise.
let mut file = File::create("foo.txt").context("failed to create file")?; Of all the things I find hard to understand in Rust, this isn't one of them.
•
Important to note that .context() is something from `anyhow`, not part of the stdlib.
Anecdotally, as a result of the traits that made it hard to learn for humans, Rust is actually a great language for LLM. Out of all languages I do development in the past few months: Go, Rust, Python, Typescript; Rust is the one that LLM has the least churn/problems in terms of producing correct and functional code given a problem of similar complexity. I think this outside factor will eventually win more usage for Rust.
•
Yeah that's an interesting point, it feels like it should be even better than it is now (I might be ignorant of the quality of the best coding agents atm). Like rust seems particularly well suited for an agent based workflow, in that in theory an agent with a task could keep `cargo check`-ing it's solutions, maybe pulling from docs.rs or source for imported modules, and get to a solution that works with some confidence (assuming the requirements were well defined/possible etc etc). I've had a mixed bag of an experience trying this with various rust one off projects. It's definitely gotten me some prototype things working, but the evolving development of rust and crates in the ecosystem means there's always some patchwork to get things to actually compile. Anecdotally I've found that once I learned more about the problem/library/project I'll end up scrapping or rewriting a lot of the LLM code. It seems pretty hard to tailor/sandbox the context and workflow of an agent to the extent that's needed. I think the Bun acquisition by Anthropic could shift things too. Wouldn't be surprised if the majority of code generated/requested by users of LLM's is JS/TS, and Anthropic potentially being able to push for agentic integration with the Bun runtime itself could be a huge boon for Bun, and maybe Zig (which Bun is written in) as a result? Like it'd be one thing for an agent to run cargo check, it'd be another for the agent to monitor garbage collection/memory use while code is running to diagnose potential problems/improvements devs might not even notice until later. I feel like I know a lot of devs who would never touch any of the langs in this article (thinking about memory? too scary!) and would love to continue writing JS code until they die lol
> In Rust, creating a mutable global variable is so hard that there are long forum discussions on how to do it. In Zig, you can just create one, no problem. Well, no, creating a mutable global variable is trivial in Rust, it just requires either `unsafe` or using a smart pointer that provides synchronization. That's because Rust programs are re-entrant by default, because Rust provides compile-time thread-safety. If you don't care about statically-enforced thread-safety, then it's as easy in Rust as it is in Zig or C. The difference is that, unlike Zig or C, Rust gives you the tools to enforce more guarantees about your code's possible runtime behavior.
•
That seems unusual. I would assume trivial means the default approach works for most cases. Perhaps mutable global variables are not a common use case. Unsafe might make it easier, but it’s not obvious and probably undesired. I don’t know Rust, but I’ve heard pockets of unsafe code in a code base can make it hard to trust in Rust’s guarantees. The compromise feels like the language didn’t actually solve anything.
•
The default approach is to use a container that enforces synchronization. If you need manual control, you are able to do that, you just need to explicitly opt into the responsibility that comes with it. If you use unsafe to opt out of guarantees that the compiler provides against data races, it’s no different than doing the exact same thing in a language that doesn’t protect against data races.
•
> I would assume trivial means the default approach works for most cases. Perhaps mutable global variables are not a common use case. Unsafe might make it easier, but it’s not obvious and probably undesired. I'm a Rust fan, and I would generally agree with this. It isn't difficult, but trivial isn't quite right either. And no, global vars aren't terribly common in Rust, and when used, are typically done via LazyLock to prevent data races on intialization. > I don’t know Rust, but I’ve heard pockets of unsafe code in a code base can make it hard to trust in Rust’s guarantees. The compromise feels like the language didn’t actually solve anything. Not true at all. First, if you aren't writing device drivers/kernels or something very low level there is a high probability your program will have zero unsafe usages in it. Even if you do, you now have an effective comment that tells you where to look if you ever get suspicious behavior. The typical Rust paradigm is to let low level crates (libraries) do the unsafe stuff for you, test it thoroughly (Miri, fuzzing, etc.), and then the community builds on these crates with their safe programs. In contrast, C/C++ programs have every statement in an "unsafe block". In Rust, you know where UB can or cannot happen.
•
> Even if you do, you now have an effective comment that tells you where to look if you ever get suspicious behavior. By the time suspicious behavior happens, isn’t it kind of a critical inflection point? For example, the news about react and next that came out. Once the code is deployed, re-deploying (especially with a systems language that quite possibly lives on an air-gapped system with a lot of rigor about updates) means you might as well have used C, the dollar cost is the same.
•
Are you with a straight face saying that occasionally having a safety bug in limited unsafe areas of Rust is functionally the same as having written the entire program in an unsafe language like C?
•
Outside of single-initialization/lazy-initialization (which are provided via safe and trivial standard library APIs: https://doc.rust-lang.org/std/sync/struct.LazyLock.html ) almost no Rust code uses global mutable variables. It's exceedingly rare to see any sort of global mutable state, and it's one of the lovely things about reading Rust code in the wild when you've spent too much of your life staring at C code whose programmers seemed to have a phobia of function arguments.
so does the rust compiler check for race conditions between threads at compile time? if so then i can see the allure of rust over c, some of those sync issues are devilish. and what about situations where you might have two variables closely related that need to be locked as a pair whenever accessed.
•
In rust, there are two kinds of references, exclusive (&mut) and shared(&). Rustc guarantees you that if you provide an exclusive reference, no other thread will have that. If your thread has an exclusive reference, then it can mutate the contents of the memory. Rustc also guarantees that you won't end up with a dropped reference inside of your threads, so you will always have allocated memory. Because rust guarantees you won't have multiple exclusive (and thus mutable refs), you won't have a specific class of race conditions. Sometimes however, these programs are very strict, and you need to relax these guarantees. To handle those cases, there are structures that can give you the same shared/exclusive references and borrowing rules (ie single exclusive, many shared refs) but at runtime. Meaning that you have an object, which you can reference (borrow) in multiple locations, however, if you have an active shared reference, you can't get an exclusive reference as the program will (by design) panic, and if you have an active exclusive reference, you can't get any more references. This however isn't sufficient for multithreaded applications. That is sufficient when you have lots of pieces of memory referencing the same object in a single thread. For multi-threaded programs, we have RwLocks. https://doc.rust-lang.org/std/cell/index.html
It entirely prevents race conditions due to the borrow checker and safe constructs like Mutexes. Logical race conditions and deadlocks can still happen.
•
Rust's specific claims are that safe Rust is free from data races, but not free from general race conditions, including deadlocks.
ah i see, thanks. i have no idea what rust code looks like but from the article it sounds like a language where you have a lot of metadata about the intended usage of a variable so the compiler can safety check. thats its trick.
•
That's a fairly accurate idea of it. Some folks complain about Rust's syntax looking too complex, but I've found that the most significant differences between Rust and C/C++ syntax are all related to that metadata (variable types, return types, lifetimes) and that it's not only useful for the compiler, but helps me to understand what sort of data libraries and functions expect and return without having to read through the entire library or function to figure that out myself. Which obviously makes code reuse easier and faster. And similarly allows me to reason much more easily about my own code.
•
The only thing I really found weird syntactically when learning it was the single quote for lifetimes because it looks like it’s an unmatched character literal. Other than that it’s a pretty normal curly-braces language, & comes from C++, generic constraints look like plenty of other languages. Of course the borrow checker and when you use lifetimes can be complex to learn, especially if you’re coming from GC-land, just the language syntax isn’t really that weird.
I will never understand people bashing other languages for their syntax and readability and then saying that they prefer Rust. Async Rust is the ugliest and least readable language I've ever seen and I've done a lot of heavily templated C++
•
> Async Rust is the ugliest and least readable language I've ever seen and I've done a lot of heavily templated C++ No, this is a wild claim that shows you've either never written async Rust or never written heavily templated C++. Feel free to give code examples if you want to suggest otherwise.
I love this take - partly because I agree with it - but mostly because I think that this is the right way to compare PLs (and to present the results). It is honest in the way it ascribes strengths and weaknesses, helping to guide, refine, justify the choice of language outside of job pressures. I am sad that it does not mention Raku ( https://raku.org ) ... because in my mind there is a kind of continuum: C - Zig - C++ - Rust - Go ... OK for low level, but what about the scriptier end - Julia - R - Python - Lua - JavaScript - PHP - Raku - WL?
•
what's WL?
I pretty new to Rust and I’m wondering why global mutables are hard? At first glance you can just use static variable of a type supporting interior mutability - RefCell, Mutex, etc…
•
> I pretty new to Rust and I’m wondering why global mutables are hard? They're not. fn main() { unsafe { COUNTER += 1; println!("COUNTER = {}", COUNTER); } unsafe { COUNTER += 10; println!("COUNTER = {}", COUNTER); } } Global mutable variables are as easy in Rust as in any other language. Unlike other languages, Rust also provides better things that you can use instead.
> For Go, I wouldn't say that the choice to avoid generics was either intentional or minimalist by nature. From what I recall, they were just struggling for a long time with a difficult decision, which trade-offs to make. Indeed, in 2009 Russ Cox laid out clearly the problem they had [1], summed up thus: > The generic dilemma is this: do you want slow programmers, slow compilers and bloated binaries, or slow execution times? My understanding is that they were eventually able to come up with something clever under the hood to mitigate that dilemma to their satisfaction. [1] https://research.swtch.com/generic
•
Ironically, the latest research by Google has now conclusively shown that Rust programmers aren't really any "slower" or less productive than Go programmers. That's especially true once you account for the entire software lifecycle, including production support and maintenance.
•
I’m not sure there’s anything clever that resolved the issues, they just settled on slow execution times by accepting a dynamic dispatch on generics.
I really hate the anti-RAII sentiments and arguments. I remember the Zig community lead going off about RAII before and making claims like "linux would never do this" ( https://github.com/torvalds/linux/blob/master/include/linux/cleanup.h ). There are bad cases of RAII APIs for sure, but it's not all bad. Andrew posted himself a while back about feeling bad for go devs who never get to debug by seeing 0xaa memory segments, and sure I get it, but you can't make over-extended claims about non-initialization when you're implicitly initializing with the magic value, that's a bit of a false equivalence - and sure, maybe you don't always want a zero scrub instead, I'm not sold on Go's mantra of making zero values always be useful, I've seen really bad code come as a result of people doing backflips to try to make that true - a constructor API is a better pattern as soon as there's a challenge, the "rule" only fits when it's easy, don't force it. Back to RAII though, or what people think of when they hear RAII. Scope based or automatic cleanup is good. I hate working with Go's mutex's in complex programs after spending life in the better world. People make mistakes and people get clever and the outcome is almost always bad in the long run - bugs that "should never get written/shipped" do come up, and it's awful. I think Zig's errdefer is a cool extension on the defer pattern, but defer patterns are strictly worse than scope based automation for key tasks. I do buy an argument that sometimes you want to deviate from scope based controls, and primitives offering both is reasonable, but the default case for a ton of code should be optimized for avoiding human effort and human error. In the end I feel similarly about allocation. I appreciate Zig trying to push for a different world, and that's an extremely valuable experiment to be doing. I've fought allocation in Go programs (and Java, etc), and had fights with C++ that was "accidentally" churning too much (classic hashmap string spam, hi ninja, hi GN), but I don't feel like the right trade-off anywhere is "always do all the legwork" vs. "never do all the legwork". I wish Rust was closer to the optimal path, and it's decently ergonomic a lot of the time, but when you really want control I sometimes want something more like Zig. When I spend too much time in Zig I get a bit bored of the ceremony too. I feel like the next innovation we need is some sanity around the real useful value that is global and thread state. Far too much toxic hot air is spilled over these, and there are bad outcomes from mis/overuse, but innovation could spend far more time on _sanely implicit context_ that reduces programmer effort without being excessively hidden, and allowing for local specialization that is easy and obvious. I imagine it looks somewhere between the rust and zig solutions, but I don't know exactly where it should land. It's a horrible set of layer violations that the purists don't like, because we base a lot of ABI decisions on history, but I'd still like to see more work here. So RAII isn't the big evil monster, and we need to stop talking about RAII, globals, etc, in these ways. We need to evaluate what's good, what's bad, and try out new arrangements maximize good and minimize bad.
•
> So RAII isn't the big evil monster, and we need to stop talking about RAII, globals, etc, in these ways. I disagree and place RAII as the dividing line on programming language complexity and is THE "Big Evil Monster(tm)". Once your compiled language gains RAII, a cascading and interlocking set of language features now need to accrete around it to make it ... not excruciatingly painful. This practically defines the difference between a "large" language (Rust or C++) and a "small" language (C, Zig, C3, etc.). For me, the next programming language innovation is getting the garbage collected/managed memory languages to finally quit ceding so much of the performance programming language space to the compiled languages. A managed runtime doesn't have to be so stupidly slow. It doesn't have to be so stupidly non-deterministic. It doesn't have to have a pathetic FFI that is super complex. I see the "strong typing everywhere" as the first step along this path. Fil-C might become an interesting existence proof in this space. I view having to pull out any of C, Zig, C++, Rust, etc. as a higher-level programming language failure. There will always be a need for something like them at the bottom, but I really want their scope to be super small. I don't want to operate at their level if I can avoid them. And I say all this as someone who has slung more than 100KLoC of Zig code lately. For a concrete example, let's look at Ghostty which was written in Zig. There is no strong performance reason to be in Zig (except that implementations in every other programming language other than Rust seem to be so much slower). There is no strong memory reason to be in Zig (except that implementations in every other programming language other than Rust chewed up vast amounts of it). And, yet, a relatively new, unstable, low-level programming language was chosen to greenfield Ghostty. And all the other useful terminal emulators seem to be using Rust. Every adherent of managed memory languages should take it as a personal insult that people are choosing to write modern terminal emulators in Rust and Zig.
•
Have you tried Swift? It has the sort of pragmatic-but-safe-by-default approach you’re talking about.
For a lot of stuff what I really want is golang but with better generics and result/error/enum handling like rust.
•
Me too. There’s a huge market for a natively compiled language with GC that has a better type system than Go. The options I’ve seen so far are: OCaml, D, Swift, Nim, Crystal, but none of them have seen to be able to capture a significant market.
I cautiously agree, with the caveat that while I thought I would really like Rust's error handling, it has been painful in practice. I'm sure I'm holding it wrong, but so far I have tried: * thiserror: I spend ridiculous and unpredictable amounts of time debugging macro expansions * manually implementing `Error`, `From`, etc traits: I spend ridiculous though predictable amounts of time implementing traits (maybe LLMs fix this?) * anyhow: this gets things done, but I'm told not to expose these errors in my public API Beyond these concerns, I also don't love enums for errors because it means adding any new error type will be a breaking change. I don't love the idea of committing to that, but maybe I'm overthinking? And when I ask these questions to various Rust people, I often get conflicting answers and no one seems to be able to speak with the authority of canon on the subject. Maybe some of these questions have been answered in the Rust Book since I last read it? By contrast, I just wrap Go errors with `fmt.Errorf("opening file `%s`: %w", filePath, err)` and handle any special error cases with `errors.As()` and similar and move on with life. It maybe doesn't feel _elegant_, but it lets me get stuff done.
•
I personally like the flexibility it provides. You can go from very granular with an error type per function and an enum variant per error case, or very coarse with an error type for a whole module that holds a string. Use thiserror to make error types in libraries, and anyhow in programs to handle them.
I thought the recent error proposal was quite interesting even if it didn't go through: https://github.com/golang/go/issues/71528 My hope is they will see these repeated pain points and find something that fits the error/result/enum issues people have. (Generics will be harder, I think)
•
Didn't they say they're not accepting any new proposals for error handling? I kinda got used to it eventually, but I'll never ever consider not having enums a good thing.
Rust is hard in that it gives you a ton of rope to hang yourself with, and some people are just hell bent on hanging themselves. I find Rust quite easy most of the time. I enjoy the hell out of it and generally write Rust not too different than i'd have written my Go programs (i use less channels in Rust though) . But i do think my comment about rope is true. Some people just can't seem to help themselves.
•
I feel like it is the opposite, Go gives you a ton of rope to hang yourself with and hopefully you will notice that you did: error handing is essentially optional, there are no sum types and no exhaustiveness checks, the stdlib does things like assume filepaths are valid strings, if you forget to assign something it just becomes zero regardless of whether it’s semantically reasonable for your program to do that, no nullability checking enforcement for pointers, etc. Rust OTOH is obsessively precise about enforcing these sort of things. Of course Rust has a lot of features and compiles slower.
The rope in my example is complexity. Ie choosing to use "all teh features" when you don't need or perhaps even want to. Eg sometimes a simple clone is fine. Sometimes you don't need to opt for every generic and performance minded feature Rust offers - which are numerous. Though, i think my statement is missing something. I moved from Go to Rust because i found that Rust gave me better tooling to encapsulate and reuse logic. Eg Iterators are more complex under the hood, but my observed complexity was lower in Rust compared to Go by way of better, more generalized code reuse. So in this example i actually found Go to be more complex. So maybe a more elaborated phrase would be something like Rust gives you more visible rope to hang yourself with.. but that doesn't sound as nice. I still like my original phrase heh.
•
I would love to see a language that is to C what Rust is to C++. Something a more average human brain like mine can understand. Keep the no-gc memory safety things, but simplify everything else a thousand times. Not saying that should replace Rust. Both could exist side by side like C and C++.
Countdown until the AI bubble bursts (pop-the-bubble.xyz)
Well this is quite the cute little paradox. Bubble pops? The AI was right! AI works! Doubters were wrong, everybody should be throwing their money back in! That wasn't a bubble that was Future Earnings. Bubble doesn't pop? AI fails and it's a scam & a bubble! Why are we all still pouring money into this bubble? Someone in the comments, in response, moves the goalposts on AI. Heavy dose of /s, of course.
•
Why sarcasm? It is an interesting paradox.
•
It just needs to pop at a different time than predicted.
I guess I wonder what people think the AI bubble is. Are you worried about the high valuations of the big AI companies (OpenAI, Nvidia, etc)? Then sure, that will correct over time. There will likely be 1-2 big winners. But if you're talking about AI in general... right now is the least amount of money companies will be spending on AI ever. It will only go up. This isn't crypto.
•
But if the value add of AI fails to materialize like the current valuations are based on (as in the % of GDP impacted), then you’re going to see investors losing money on the investments.
> This isn't crypto. Bitcoin is at $92k.
•
Sure, but crypto companies aren’t as in vogue anymore. AI companies will someday just be called companies, much like how tech companies are just companies.
the date has been changing for years now. one day someone will actually define what bubble we are waiting to burst and then will poke it to burst and many will say “hey, see I was right all along” ;)
•
And now we’ll be able to say Gemini was right
I see, there's hope yet. I didn't read that close, gotta skim with all this ~value~ generation I mean, I got the gist it might change... but I assumed this is a flat page, made once. For the lulz. Entirely missed the relevant FAQ! edit: I'll actually check this again to see what the robot(s) think, others have good a suggestion: more, compare sentiment beyond Gemini.
•
Yeah it would be better to have that it is AI generated at the top of the page. I also think comparisons would be hilarious
Django 6 (docs.djangoproject.com)
•
> Background Tasks. Amazing. If this means no more management of Celery workers, then I am so happy! So nice to have this directly built _into_ Django, especially for very simple task scheduling.
One thing Django has going for it is that the "batteries included" nature of it is perfect for AI code generation. You can get a working site with the usual featuers (admin panel, logins, forgot reset/password flow, etc) with minimal code thanks to the richness of the ecosystem, and because of the minimal code it's relatively easy for the AI to keep iterating on it since it's small enough to be understandable in context.
•
I have tried both Django and Rails for this, and honestly, very surprisingly, Rails did much better, at least with Claude Code. This is for a rewrite of an old .net application. Claude nailed it almost perfectly with Rails, but struggled with Django. YMMV.
•
Ruby and Rails are even better candidates. CSP, Background workers, and many other features that Django still lacks have been standard offerings for sometimes 10+ years!
•
CSP is literally in this release, and background workers are intentionally not part of Django because you usually want to offload tasks to other nodes so your CPU can keep serving HTTP requests. Edit: Background tasks for light work are also included in this release.
•
And because Django is so popular in open source projects and it has been around for such a long time, there's tons of code out there for AI to train on.
I think the logic can be applied to humans as well as AI: Sure, the AI _can_ code integrations, but it now has to maintain them, and might be tempted to modify them when it doesn't need to (leaky abstractions), adding cognitive load (in LLM parlance: "context pollution") and leading to worse results. Batteries-included = AI and humans write less code, get more "headspace"/"free context" to focus on what "really matters". As a very very heavy LLM user, I also notice that projects tend to be much easier for LLMs (and humans alike) to work on when they use opinionated well-established frameworks. Nonetheless, I'm positive in a couple of years we'll have found a way for LLMs to be equally good, if not better, with other frameworks. I think we'll find mechanisms to have LLMs learn libraries and projects on the fly much better. I can imagine crazy scenarios where LLMs train smaller LLMs on project parts or libraries so they don't get context pollution but also don't need a full-retraining (or incredibly pricey inference). I can also think of a system in line with Anthropic's view of skills, where LLMs very intelligently switch their knowledge on or off. The technology isn't there yet, but we're moving FAST! Love this era!!
•
Maybe if they could learn how to switch their intelligence on, that would help more?
Can someone remind me how we ended up in the SPA era and why exactly? Was it about not seeing the loading spinner? Or there were more reasons to it?
•
Google Maps. Gmail. OWA. There were suddenly pages that let you do things without a white flash between clicks. It's ALL about the refreshes. Everything else came after.
Because the web was made to render documents, but users want apps. CSS in part is so confusing because its original incarnations pulled heavily from traditional print media layout terms. Everything since then was an attempt to leverage JS to turn documents into applications. Why? Ask any user.
•
I don't think blaming this mess on users makes much sense. Smartphones on the other hand...
I had similar thoughts, but how does one use an RDBMS without making use of FKs? Do they put all in one huuuge table, that has all the columns and is super sparse? Or some other fever dream of bad design?
•
As long as you don't give a shit about data integrity, you don't need foreign keys.
Aside from the usual separation of tech stacks for different teams, the big thing for me is lack of any sort of type hinting or safety in templates at least in the big frameworks such as Django, Rails etc. I would much rather work with a separate build process that utilizes typescript than deal with the errors that come out of incorrectly reading formless data and making typos within templates.
•
Is that really such a big problem? These days you can type annotate what you pass to the rendering function for templates and then you know what type you have in the template. If you have a minimum of testing, heck even manual testing will do, I don't think too many mistakes make it to staging, let alone production. I would think it well worth to be able to opt out of the JS ecosystem.
- Strict team separation (frontend versus backend) - Moving all state-managament out of the backend and onto the frontend, in a supposedly easier to manage system - Page refreshes are indeed jarring to users and more prone to leading to sudden context losses - Desktop applications did not behave like web apps: they are "SPA"s in their own sense, without jarring refreshes or code that gets "yanked" out of execution. Since the OS has been increasingly abstracted under the browser, and the average computer user has moved more and more towards web apps[1], it stands to reason that the behavior of web apps should become more like that of desktop apps (i.e. "SPA"s)[2] (Not saying I agree with these, merely pointing them out) [1] These things are not entirely independent. It can be argued that the same powers that be (big corps) that pushed SPAs onto users are also pushing the "browser as OS" concept. [2] I know you can get desktop-like behavior from non-SPAs, but it is definitely not as easy to do it or at least to _learn it_ now. My actual opinion: I think it's a little bit of everything, with a big part of it coming from the fact that the web was the easiest way to build something that you could share with people effortlessly. Sharing desktop apps wasn't particularly easy (different targets, java was never truly run everywhere, etc.), but to share a webapp app you just put it online very quickly and have someone else point their browser to a URL -- often all they'll do is click a link! And in general it is definitely easier to build an SPA (from the frontender's perspective) than something else. This creates a chain: If I can create and share easily -> I am motivated to do things easily -> I learn the specific technology that is easiest -> the market is flooded with people who know this technology better than everything else -> the market must now hire from this pool to get the cheapest workers (or those who cost less to acquire due to quicker hiring processes) -> new devs know that they need to learn this technology to get hired -> the cycle continues So, TL;DR: Much lower barrier to entry + quick feedback loops P.S (and on topic): I am an extremely satisfied django developer, and very very very rarely touch frontend. Django is A-M-A-Z-I-N-G.
•
These days with 90% of SPAs being broken piles of browser standard breaking stuff, I find a page refresh or page load to be a soothing experience. They are like checkpoints in the process of using a website. Points to which I can go back using my browser's back button, and I can trust, that my browser keeps track of them. In contrast, when I see an SPA, I need to worry about the whole site going to shit, because I blocked some third-party unwanted script, and then I need to fear not being able to go back properly, and having to re-do everything. Now that is a jarring experience.
•
Not being able to new tab to a new instance of the app is terrible. Even super complex SPAs like Facebook let me for the most part right click new tab to create a new instance while preserving the old one.
•
I feel you. It's definitely a tradeoff. SPAs do tend to be more buggy but I can't deny that, when done right, they also tend to be better. Unfortunately, there's _more_ people, building _more_ stuff, so there's _more_ terrible stuff out there. The amount of new apps (and new developers, especially ones with quite limited skills) is immense compared to something like ten years ago. This means that there's just more room for things to be poorly-built.
Show of hands for backend web services development - Who uses Django, Rails, or similar full-featured frameworks? Who uses micro-frameworks like Flask? Who uses enterprise Java, Jetty, Dot Net, etc.? Who uses an entirely Javascript stack? Who uses a non-traditional language that has become more web-servicey, like Go, Rust, or Swift? Who uses something so wildly untraditional that it's barely mentioned? OkCupid using C++, etc.? Who uses an entirely custom framework (in any language)? Would really love to see a break down of who is using what, how people feel about their tech stack, etc.?
•
I've done several custom frameworks for solo projects in Java & Go, all based on server generated content, inspired by Seaside but more RESTy. Also used Flask and similar libraries for back ends. Did one project in Rails, which was a pretty bad experience in comparison, and killed any motivation to look into Django. Also did plenty of Spring in Java professionally, unfortunately.
•
In a company that uses a traditional web framework like Django to actually build the frontend and backend, not just as only for implementing the APIs, I would even consider doing parts of frontend work again, making everything responsive and so on. That's what I do for a not-yet-startup project.
A Cozy Mk IV light aircraft crashed after 3D-printed part was weakened by heat (bbc.com)
•
They included everything but the 3D printed material. If it was PLA, no surprise (and no excuse). Even ABS might not stand up to the temperatures at that location. I hate it when a news report tells you everything except details that might make a difference going forward.
•
I just watched a fun video of a guy bringing a 1978 Datsun 280Z up to date. He kept the existing engine but upgraded it with modern electronic ignition and computer control. As part of all that, he fabricated various parts in plastic by 3D printing, but then had the final versions made elsewhere in metal -- some by a CNC shop you send CAD files to, and one by a manual machinist in Switzerland with his own Youtube channel. The latter has to be case hardened, which the machinist did. The 3D printed plastic parts were very useful to prove out the parts' shapes. https://www.youtube.com/watch?v=jZ38C-M3tyk -- engine upgrade https://www.youtube.com/watch?v=D2bxsEyYdo0 -- My Mechanics making the part
•
Are those class 8 bolts holding a plastic (PLA? PETG?) part in place? I guess the original part would have been some sort of metal?
There’s a massive difference between the thermal properties of the materials you listed.
•
Yes, that's why I listed them. And even then: none of those first three are (safely) usable for this application. PEEK or ULTEM or something better than that.
I've almost made that exact same mistake (but not on a critical part). I had a bunch of identical rolls with CF loaded filament of different base materials and just looking at the filament you really couldn't tell.
•
Right...I have loaded the wrong material before. It didn't take long before I noticed. PLA is super liquid at ABS temps :) (Not to mention that in my case ABS bed temps would melt the bottom of the PLA)
Also, strictly as a combo 3D-printing and engine enthusiast: Never with a GUN to my head would I install 3D printed parts in a CAR engine, let alone in an aircraft engine. This is spectacularly poor judgement on the part of the owner.
•
FWIW, I wouldn't hesitate to install a 3D printed air-filter housing in my car, if I had printed it myself out of e.g. PAHT or sourced it from a trusty vendor. It's not rocket science, just engineering.
> The fabrication technology doesn't matter. The qualification process, on the other hand ... Well, yes, but... In this case the fabrication technology and the lack of qualification process likely go hand in hand. They wouldn't have a qualification process unless they were manufacturing enough of these that plastic 3d printing wouldn't be cost effective. The shortcut is the point.
•
You can 3D print metal (additive manufacturing). You still have to test it, however.
If you carve a wooden part with "the right shape" for an engineering application that the part lacks the physical properties that allow it to perform under load stress ... then yes, that's vibe carving. Looks good - falls apart in practice, and a junior can't tell the difference as they "look the same" to the inexperienced eye. From practical experience, you cannot just replace a tyre on a car with any old bit of wood - you really need to use hard wearing mulga (or equivilant) as an emergency skid. (And replace that as soon as possible)
•
What you're describing is more like someone who doesn't know computer science principles hacking on code, manually. Part of the definition of "vibe coding" is that AI agents (of questionable quality) did the actual work.
The lesson here is that one should never attempt analogies on HN, because people can't just relax and try to see the point of the analogy. They are compelled to fixate on the fact that an analogy is different from the thing it is being compared to. I see multiple examples of it in this thread.
•
I feel like Hacker News commenters love to make analogies more than average people in your average space, though. You can't come across a biology/health topic on here without someone chiming in with "it's like if X was code and it had this bug" or "it's like this body part is the Y of the computer." Analogies can be useful sometimes, but people also shouldn't feel like they need to see everything through the lens of their primary domain, because it usually results in losing nuances.
•
On the other hand, if you are communicating with a bunch of people who share that primary domain, it can be a useful way of making a point. (unless that primary domain tends to attract a lot of people who tend to the hyper-literal /s)
The RAM shortage comes for us all (jeffgeerling.com)
Yes, DDR3 is the lowest CAS latency and lasts ALOT longer. Just like SSDs from 2010 have 100.000 writes per bit instead of below 10.000. CPUs might even follow the same durability pattern but that remains to be seen. Keep your old machines alive and backed up!
•
> Yes, DDR3 is the lowest CAS latency and lasts ALOT longer. DDR5 is more reliable. Where are you getting this info that DDR3 lasts longer? DDR5 runs at lower voltages, uses modern processes, and has on-die ECC. This is already showing up in reduced failure rates for DDR5 fleets: https://ieeexplore.ieee.org/document/11068349 The other comment already covered why comparing CAS latency is misleading. CAS latency is measured in clock cycles. Multiply by the length of a clock cycle to get the CAS delay.
I know this is mostly paranoid thinking on my behalf, but it almost feels like this is a conscious effort to attempt to destroy "personal" computing. I've been a huge advocate for local, open, generative AI as the best resistance to massive take-over by large corporations controlling all of this content creation. But even as it is (or "was" I should say), running decent models at home is prohibitively expensive for most people. Micron has already decided to just eliminate the Crucial brand (as mentioned in the post). It feels like if this continues, once our nice home PCs start to break, we won't be able to repair them. The extreme version of this is that even dumb terminals (which still require some ram) will be as expensive as laptops today. In this world, our entire computing experience is connecting a dumb terminal to a ChatGPT interface where the only way we can interact with anything is through "agents" and prompts. In this world, OpenAI is not overvalued, and there is no bubble because the large LLM companies become computing . But again, I think this is mostly a dystopian sci-fi fiction... but it does sit a bit too close to the realm of possible for my tastes.
•
That "dumb terminals" still need to run a modern web browser (likely Chrome) on a modern OS (likely Windows), these aren't exactly efficient with the available computing sources, so you could give up a lot of resources before you would actually trade it of for computing ability. Also resources have been risen exponentially for the last decades.
The first "proper" "modern" computer I had, initially came with 8 megabytes of RAM. It's not a lot, but it's enough for a dumb terminal.
•
A dumb terminal doesn't even need a tenth of that.
yeaaahhh.. these fabs don't just have a button that says "punch out a top of the line nvidia GPU"
•
You're right. I'm throwing away the napkin.
And then spend the next five years building the actual fab around it? Like what’s the plan here.
•
No you're right. My math is very off.
Sure - once you have dozens of engineers and 5 years under your belt you'll be good to go! This will get you started: https://youtu.be/B2482h_TNwg Keep in mind that every wafer makes multiple trips around the fab, and on each trip it visits multiple machines. Broadly, one trip lays down one layer, and you may need 80-100 layers (although I guess DRAM will be fewer). Each layer must be aligned to nanometer precision with previous layers, otherwise the wafer is junk. Then as others have said, once you finish the wafer, you still need to slice it, test the dies, and then package them. Plus all the other stuff.... You'll need billions in investment, not millions - good luck!
•
Thank you. This is going to be way harder than I thought.
Yes. You need 16nm or better for DDR5.
•
ASML cannot be avoided for 7nm and better due to EUV.
I think you are vastly underestimating how a modern fab works. The average cost is 10 billion and takes a about 10 years to build. They are very complex and even the slightest issue can ruin yields. There is a reason why there are so few.
•
Yeah you're right. I was way off.
Haha, the amount of downvotes of your very true comment just proves how many web developers are there on HN.
•
One even responded to an earlier comment of mine that we shouldn't be optimizing software for low-end machines because that would be going against technological progress...
I found web browser tabs eating too much memory when you only have 16GB
•
With that much RAM, you could fit multiple OSes entirely into memory. That is simply a lot.
Why are 38 percent of Stanford students saying they're disabled? (reason.com)
•
Ok, so we are raising a bunch of cheaters and liars. Great. When the get to the workforce, then what? When I was in a position to hire, I made the decision to not interview anyone who went to Elon. The school did not in the early 2000s use a standard grammar book and at least according to my kid's papers, the profs had little to say about poor grammar, rambling sentences, poor logic, etc. Great. Since the work was about writing and speaking, grammar and logic were important. Fast forward to today, and I guess I'd have to make a decision about not interviewing kids from top-tier schools.
•
I got 1.5 extra test time. I would have never graduated otherwise. I didn't use it my senior year though. To this day, I read slower than most, I have to reread things when others don't need to. Intelligence and having learning disabilities are not corollated as this article suggests.
Okay, RFK Jr.
•
A swing and a miss. Note the geographic specificity and give it another go?
Did anyone else actually enjoy dorm life? I was a freshman some years ago, so maybe it’s generational, but it was a very fond time. I guess it’s probably high variance. My roomate was a great dude. I can easily see how it could go the other way.
•
I had a bad roommate who when I asked the people in the house to turn the music down he would tell them to turn it up, and he constantly had annoying guests in our tiny room. Fuck Patrick you know who you are..
> Another big accommodation request is extra time on tests. Maybe the real problem is we are testing people on how fast they can do something not if they can do something. In general, being good at academics require you to think carefully not quickly. I suspect there is a correlation between people who think things through and people who do well in school.
•
Caltech had timed exams (2-3 hours) and infinite time exams, at the discretion of the professor. The students hated the infinite time ones, because nobody knew how much time other students spent on the test so one felt obliged to spend inordinate amounts of time on it. Besides, if you couldn't solve the exam problems in 2 hours, you simply didn't know the material.
But where is that level of speed distinction important? I just don't know anywhere where being 10% faster translates into much actual real value. If you can write a function in five minutes and it takes this other person 5.5 minutes -- do you really view that as the key difference in ability? Even in time constrained situations, compute/processing speed is almost never the issue.
•
In this context, time constraints are measured in hours and are very informative regarding the student’s capacity to prioritise, plan and carry out their work under pressure. It is actually very informative when one person can
•
I mean.. if you can finish a task for a client in a day, and someone else needs two days, isn't that a huge difference? Or to turn it around, if someone does 10%, 20%, 50% more in the same time period, isn't that significant? I mean.. we are comparing students abilities here, and doing stuff fast is one of those abilities. Even potato peelers in a restaurant are valued more if they're faster, why not programmers too? Or DMV workers?
•
I don't think test speed is correlated with that. Like anything i had to do in a test when i was taking my CS degree is maybe 5% if not less of the portion of my real job tasks. Even if i was triple as fast at taking those tests, i think that would be a neglibile increase in on the job speed.
I can not think of a single test I have ever taken where I could be limited by handwriting speed. Most of the time on tests is spent thinking, not writing.
•
When I was a student in the United States in the 1990s, I took many, many tests in which handwriting speed limited me. It was purely a physical problem. When I was able to type, there was no issue. To be clear, I am speaking of tests in the humanities and social sciences, for which students must write short essays. Later, when I was a professor in the United States, I saw some of my students grappling with the same problem. I don't think that my students and I are extraordinary. Other people were, and are, limited by slow handwriting when they are required to handwrite their exams. You could try to identify these people and give them extra time. But the better move would be to stop requiring students to handwrite essays under a time constraint.
•
I had a test once where we had to do RSA by hand (with 4 digit numbers), no calculators allowed. There was a lot of handwriting on scrap pieces of paper. Do humanities have to do handwritten essay tests in the modern world. I had to do those in middle school/high school. No idea if that is still a thing.
•
> scrap pieces of paper The exams I took were done in blue books where you were required to show your work.
In a high stakes, challenging environment, every human weakness possible becomes a huge, career impeding liability. Very few people are truly all-around talented. If you are a Stanford level scientist, it doesn't take a lot of anxiety to make it difficult to compete with other Stanford level scientists who don't have any anxiety. Without accommodations, you could still be a very successful scientist after going to a slightly less competitive university. Rising disability rates are not limited to the Ivy League. A close friend of mine is faculty at a medium sized university and specializes in disability accommodations. She is also deaf. Despite being very bright and articulate, she had a tough time in university, especially lecture-heavy undergrad. In my eyes, most of the students she deals with are "young and disorganized" rather than crippled. Their experience of university is wildly different from hers. Being diagnosed doesn't immediately mean you should be accommodated. The majority of student cases receive extra time on exams and/or attendance exemptions. But the sheer volume of these cases take away a lot of badly needed time and funding for students who are talented, but are also blind or wheelchair bound. Accommodating this can require many months of planning to arrange appropriate lab materials, electronic equipment, or textbooks. As the article mentions, a deeply distorted idea of normal is being advanced by the DSM (changing ADHD criteria) as well as social media (enjoying doodling, wearing headphones a lot, putting water on the toothbrush before toothpaste. These and many other everyday things are suggested signs of ADHD/autism/OCD/whatever). This is a huge problem of its own. Though it is closely related to over-prescribing education accommodations, it is still distinct. Unfortunately, psychological-education assessments are not particularly sensitive. They aren't good at catching pretenders and cannot distinguish between a 19 year old who genuinely cannot develop time management skills despite years of effort & support, and one who is still developing them fully. Especially after moving out and moving to a new area with new (sub)cultures. Occasionally, she sees documents saying "achievement is consistent with intelligence", a polite way of saying that a student isn't very smart, and poor grades are not related to any recognized learning disability. Really and truly, not everyone needs to get an undergrad degree.
•
> putting water on the toothbrush before toothpaste Wat? I had no idea I had a disability!
Sort of like having any kind of strong interest in any kind of niche topic apparently now magically teleports you onto the autism spectrum. No, that's not how that works . . .
•
Don't forget being observant of things that many people in our distracted (attention economy) society tend to miss/ignore. I had a friend's wife gas-light him into thinking he is on the spectrum and that many of his friends from college are as well... A well established and respected engineering school in the US. I'm not saying there aren't people there who would most likely fall onto it, but being detail oriented or interested in science and engineering enough to get credentialed in it being a signifier of autism was just sheer lunacy. It really is frustrating how fast our society devalues and dilutes the meaning of any word these days.
•
If his friends are engineers that's, uh, believable. It depends on the kind of engineer of course, but they are certainly like that. The question is if they're high-functioning or not.
Fair enough. I formerly went through large schools' reported numbers, which isn't the most straightforward thing to find. UT Austin has 4,299 registered Spring of 2025, which is 12.9% of a 55k student population. Ohio has 5,724 of a total of 66,901, so 8%. FSU is ~5,000 of ~55,000: 10%. These are all much higher than the article's claim but definitely lower than the NCES survey. https://disability.utexas.edu/statistics/ https://irp.osu.edu/sites/default/files/documents/2025/01/2024-25-statistical-summary.pdf https://dsst.fsu.edu/oas
•
This cites an NCES study which doesn't appears to be locked down to approved researchers, but it provides a national number: > In 2019-20, 8% of students registered as having a disability with their institution. This rate was 10% at non-profit institutions, 7% at for-profit institutions, and 7% of students at public institutions. https://pnpi.org/wp-content/uploads/2025/05/StudentswithDisabilities_FactSheet_Apr25.pdf
Some fairly simple examples where accommodations make the test more fair: * You have a disability that hinders your ability to type on a keyboard, so you need extra time to type the essay based exam through vocal transcription. * You broke your dominant hand (accidents happen) so even though you know all of the material, you just can't write fast enough within normal "reasonable" time limits. * You are blind, you need some way to be able to read the questions in the test. People who can see normally shouldn't need those accommodations. I don't think those are cases where you are lowering the bar. Not by more than you are allowing the test taker a fairer chance, anyway. The problem is when you get into the gray area where it's not clear than an accommodation should be given.
•
Those are all great examples where I agree that an accommodation seems uncontroversial. But to quote the article linked in the parent comment: > The increase is driven by more young people getting diagnosed with conditions such as ADHD, anxiety, and depression, and by universities making the process of getting accommodations easier. These disabilities are more complex for multiple reasons. One is the classification criteria. A broken hand or blindness is fairly discrete, anxiety is not. All people experience some anxiety; some experience very little, some people a great deal, and everything in between. The line between regular anxiety and clinical anxiety is inherently fuzzy. Further, a clinical anxiety diagnosis is usually made on the basis of patient questionnaires and interviews where a patient self-reports their symptoms. This is fine in the context of medicine, but if patients have an incentive to game these interviews (like more test time), it is pretty trvial to game a GAD-7 questionnaire for the desired outcome. There are no objective biomarkers we can use to make a clinical anxiety diagnosis. Another is the scope of accommodation. The above examples have an accommodation narrowly tailored to the disability in a way that maintains fairness. Blind users get a braille test that is of no use to other students anyway. A student with a broken hand might get more time on an eassy test, but presumably would receive no extra time on a multiple choice test and their accommodation is for a period of months, not indefinite.
The braille example you give makes absolutely perfect sense. The blind student is being evaluated same as the other students and the accommodation given to the blind student (a Braille version of the test) would be of no use to the other students. But extra test time is fundamentally different, as it would be of value to anyone taking the test. If getting the problems in Braille helps the student demonstrate their ability to do Calculus, we give them the test in Braille. If getting 30 minutes of extra time helps all students demonstrate their ability to do calculus, why don't we just give it to all students then?
•
> But extra test time is fundamentally different, as it would be of value to anyone taking the test. That depends on how the test is designed. Some tests have more material than anyone can hope to finish. Extra time is always valuable in such a test. However that type of test is generally bad because it more measures speed then skill. Most tests are designed so the average person is able to finish all the questions. In those tests more time for the average person is not helpful. They have already done it. Sure they could maybe redo all the questions, but there is very diminishing returns. If the extra 30 minutes improves someone who needs the accomedation's score by 50%, and increases the average student's score by 2% or even not at all, clearly the same thing isn't going on. So i would disagree that extra time helps everyone. Just think about it - when was the last time you had a final exam where literally every person handed in the exam at the last moment. When i was in school, the vast majority of people handed in their exam before the time limit. > why don't we just give it to all students then? I actually think we should. Requiring people to get special accomedations biases the system to people comfortable with doing that. We should just let everyone get the time they need.
The reason is because employers are insanely brutal in the job market due to an oversupply of qualified talent. We have more people than we have positions available to work for quality wages. This is why everything is so extreme. Students need to be in the top X percent in order to get a job that leads to a decent quality of life in the US. The problem is that every student knows this and is now competing against one another for these advantages. It’s like stack ranking within companies that always fire the bottom 20%. Everyone will do whatever they can to be in the top 80% and it continues to get worse every year. Job conditions are not improving every year - they are continually getting worse and that’s due to the issue that we just don’t have enough jobs. This country doesn’t build anything anymore and we are concentrating all the wealth and power into the hands of a few. This leaves the top 1% getting richer every year and the bottom 99% fighting over a smaller piece of the pie every year.
•
> This country doesn’t build anything anymore and we are concentrating all the wealth and power into the hands of a few. This leaves the top 1% getting richer every year and the bottom 99% fighting over a smaller piece of the pie every year. Wouldn't say this is an accurate description of the US economy. https://realtimeinequality.org/?id=wealth&wealthend=03012023&wealthfreq=monthly&wealthgroups=Middle%2040%25&wealthgroups=Top%2010%25&wealthgroups=Top%201%25&wealthgroups=Top%200.1%25&wealthgroups=Top%200.01%25&wealthgroups=Bottom%2050%25&wealthstart=01011976&wealthtype=wealth&wealthunit=Adults&wealthy=share
You say it is infeasible for standardized tests, but why? Is it that much harder to give 50 students and extra hour than to give 5 students an extra hour? Or just design the tests so that there is ample time to complete them without extra time. But putting aside standardized tests, in the context of this discussion about Stanford, I think these accommodations are being used for ordinary tests given for classes, so Stanford (or any other school) has full control to do whatever they want.
•
But how do you differentiate students who are able to finish the test (correctly) in an hour from those needing 2 hours for the same task? In real life, you're rarely given unlimited time for your tasks, and workers who can do more in less time are considered better than the ones who always need deadine extensions, so why not grade that too?
•
I'm also fine if a teacher or organization decides that thinking speed is an important criteria to evaluate, in which case I think the same time limits should apply to everyone. Or I'm fine if a teacher or organization deciding they just want to evaluate competency at the underlying material, in which case I think a very generous time limit should be given. Here the time limit is not meant to constrain the test taker, but is just an logistical artifact that eventually teachers and students need to go home. The test should be designed so that any competent taker can complete well in advance of the time limit.
Why is it a poor proxy? Someone who really understands the concepts and has the aptitude for it will get answers more quickly than someone who is shakier on it. The person who groks it less may be able to get to the answer, but needs to spend more time working through the problem. They're less good at calculus and should get a lower grade! Maybe they shouldn't fail Calc 101, but may deserve a B or (the horror) a C. Maybe that person will never get an A is calculus and that should be ok. Joel Spolsky explained this well about what makes a good programmer[1]. "If the basic concepts aren’t so easy that you don’t even have to think about them, you’re not going to get the big concepts." [1] https://www.joelonsoftware.com/2006/10/25/the-guerrilla-guide-to-interviewing-version-30/
•
> Someone who really understands the concepts and has the aptitude for it will get answers more quickly than someone who is shakier on it That seems like a big assumption that i don't believe is true in general. I think its true at an individual level, as you learn more about a subject you will become faster at it. I don't think its true when comparing between different people. Especially if you throw learning disabilities into the mix which is often just code for strong in one area and weak in another, e.g. smart but slow.
> Also if a test is time constrained it's easier to mark. Give a failing student 8 hours and they'll write 30 pages of nonsense. Sure that makes sense to me, but I don't see why this would not also apply to ADHD students or any other group. And of course, there needs to be some time limit. All I am saying is, instead of having a group that gets one hour and another group that gets two hours, just give everyone two hours. I meant "constrained" not in the sense of having a limit at all, but in the sense that often tests are designed in such a way that it is very common that takers are unable to finish in the allotted time. If this constraint serves some purpose (i.e. speed is considered to be desirable) then I don't see why that purpose doesn't apply to everyone.
•
> All I am saying is, instead of having a group that gets one hour and another group that gets two hours, just give everyone two hours. This means that someone fully abled can think about and solve problems for 1h and 50 minutes, and use 10 minutes to physically write/type the answers, and someone with a disability (eg. missing a hand, using a prosthetic) only gets eg. one hour to solve the problems and one hour to write/type the answers due to the disablity making them write/type more slowly. Same for eg. someone blind, while with proper eyesight, you might read a question in 30 seconds, someone blind reading braille might need multiple minutes to read the same text. With unlimited time this would not be a problem, but since speed is graded too (since it's important), this causes differences in grades.
•
Those examples seem like reasonable, narrowly tailored accomodations to me. But the article linked in the parent comment says: > The increase is driven by more young people getting diagnosed with conditions such as ADHD, anxiety, and depression, and by universities making the process of getting accommodations easier. I think these disabilities are more complex than the broken hand and blindness examples for reasons I commented on elsewhere in this thread. In your example, a student with depression or clinical anxiety presumably only need the same 10 minutes to write/type the answers as all the other students. Which means the extra time is added for them to "think about and solve problems." That seems fundamentally different to me than the broken hand example.
>ADHD sometimes comes with hyper focus, which if it manifest in the right way can help you in university. "Hyperfocus" is a clinical term for focus that is excessive enough to be an impairment. People often conflate it with the term "Special interest" used for Autism, but it's completely different, it refers to the inability to pull focus away from something despite wanting and needing to. It is, definitionally, without benefit. If there's a benefit, it's not hyperfocus. Which makes sense, if you think about it. ADHD is characterized by poor ability to direct attention. People know about it causing a lack of attention to things that need attention, but it can also cause attention to things that don't need it.
•
yes I don't mean "special interest" and I'm aware that people with ADHD don't really have any way to direct it and that it can easily lead to them neglecting everything from them self, over work to social relationships so it will help more then it hurts in university but it still can matter before, even if it's just a parent mistaking a hyper focus on some science topic with a special interest in it and then exposing you to more science related stuff earlier one in life
I went to university at a time that Adderall was commonplace, and am now old enough to see how it turned out for the individuals. At college, it was common for students to illicitly purchase Adderall to use as a stimulate to cram for a test/paper etc. It was likewise common for students to abuse these drugs by taking pills at a faster than prescribed pace to work for 48 hours straight amongst other habits. In the workplace, I saw the same folks struggle to work consistently without abusive dosages of such drugs. A close friend eventually went into in-patient care for psychosis due to his interaction with Adderall. Like any drug, the effect wears off - Cognitive Behavioral Therapy matches prescription drugs at treating ADHD after 5 years. As I recall, the standard dosages of Adderall cease to be effective after 7-10 years due to changes in tolerance. Individuals trying to maintain the same therapeutic effect will either escalate their usage beyond "safe" levels or revert to their unmedicated habits.
•
Adderall does not have any long-term tolerance. If you're developing tolerance to it, you have a magnesium deficiency and should take magnesium threonate. (And then remember to drink water, exercise and get enough sleep.)
•
I prefer to cycle between addictions of modafinil and caffeine, you shouldn't chronically use 1 drug forever
Lmao, imagine saying this kind of slop to someone with diabetes. “Cognitive behavioral therapy matches insulin after 5 years” (because they die - so they’re no longer counted)
•
The results seem pretty clear that CBT can be quite effective in helping with ADHD. Unlike insulin, which cannot be produced with any sort of therapy, it does seem that ADHD can be significantly improved. I'm sorry though that the facts seem to bother you so much. https://pubmed.ncbi.nlm.nih.gov/22480189/ https://pubmed.ncbi.nlm.nih.gov/28413900/ https://pubmed.ncbi.nlm.nih.gov/32036811/
But adderall and vyvanse aren’t the same drug at all. You cannot directly compare dosages. 50mg of vyvanse is roughly equivalent to 20mg of adderall. As a prodrug, Vyvanse must be processed by the liver for it to function.
•
Indeed. That's why I'm underscoring that my Vyvanse dosage (20mg) is only midly higher than my Adderall dose was a few years ago (15mg).
Given the current pace of changes and levels of uncertainty about the labor market 5-10 years from now, this may actually be the most useful skill-set the university is teaching students today.
•
Counterpoint: https://en.wikipedia.org/wiki/Elizabeth_Holmes
This isn't about Trump, it's about a lack of morality among students at one of the (formerly) most prestigious universities in the US.
•
It’s all connected. We are in an era where cheating is applauded and shame is non existent. Trump is not the sole cause of it but he is a contributor.
I don't know about Stanford students' actual disability, so I can't say much to that. I went to shitty high school and decent middle school in relatively poor middle class neighborhood. Now, I live in a wealthy school district. The way parents in the two different neighborhood treat "learning disability" is mind blowing. In my current school district, IEP (Individual Education Program) is assigned to students that need help, and parents are actively and explicitly ask for it, even if the kids are borderline. Please note that, this doesn't take away resource for regular kids, in fact, classrooms with IEP student get more teachers so everyone in that class benefits. IEP students are also assigned to regular classroom so they are not treated differently and their identities aren't top secret. Mind you, the parents here can easily afford additional help if needed. In other neighborhood, a long time family friend with two young children, the older one doesn't talk in school, period. Their speech is clearly behind. The parents refuse to have the kids assign IEP and insist that as long as the child is not disruptive, there is no reason to do so. Why the parents don't want to get help, because they feel the older child will get labelled and bullied and treated differently. The older child hates school and they are only in kindergarten. Teachers don't know what to do with the child.
•
> Please note that, this doesn't take away resource for regular kids, in fact, classrooms with IEP student get more teachers so everyone in that class benefits. There is a limited amount of money in the school system. When resources are assigned to one place they are taken away from somewhere else. The kids in the class without IEP students are getting boned by this policy.
Have you tried Adderall? It gives extreme competitive edge. Just to get legal and easy access to performance-enhancing drugs in elite educational (aka competitive) setting it makes sense to get "disability". And given how loosely these conditions are defined, it's not even cheating in the true sense of the word.
•
My third time sharing this link in this post because it's just so relevant. A Slate Star Codex classic: https://slatestarcodex.com/2017/12/28/adderall-risks-much-more-than-you-wanted-to-know/
Steriods will give you a massive physical advantage too. If you're not doing something with a governing body and get them prescribed you're golden.
•
If you have enough your own testosterone then doing TRT is more harm than good. But once you get older and don’t anymore - TRT is golden.
This is actually another growing problem: TRT clinics will prescribe testosterone to virtually anyone who requests it. Among new TRT patients, a large number of them didn't even have bloodwork drawn before receiving their first prescription. Many of the TRT clinics also hide the fact that going on TRT results in testicular atrophy and lifelong dependence. The forums and Reddits are full of people who decided that injecting testosterone every couple days for the rest of their life isn't all it's cracked up to be are realizing that it's not so simple for everyone to get off of it, even with all the HCG, SERMs, and PCT in the world.
•
TRT is one of those things which requires precise and active management. But it also increases quality of life and well-being so much for 45yo and beyond that it’s insane not to use it. (And same thing with HRT for women). Your choice is to die chronically ill, weak and depressed for decades, or feeling great and enjoying your later years.
> Have you tried Adderall? It gives extreme competitive edge. Before readers rush out to acquire Adderall, note that "trying" it does not give an accurate picture of what it's like to take it long-term. It has a high discontinuation rate because people read comments like this online or borrow a dose from their friend and think they're going to be running around like Bradley Cooper in Limitless for the rest of their career. A new patient who tries Adderall will feel a sense of euphoria, energy, and motivation that is temporary. This effect does not last. This is why the Reddit ADHD forums are full of people posting "I just took my first dose and I'm so happy I could cry" followed a few weeks later by "Why did my Adderall stop working?". The focus part is still mostly working, but no drug is going to make you feel happy, energized, and euphoric for very long. > Just to get legal and easy access to performance-enhancing drugs in elite educational (aka competitive) setting it makes sense to get "disability". You're confusing two different things. Registering with the school's disability office is orthogonal to getting a prescription for anything.
•
Everything can be abused or used incorrectly. If you drink too much water you remove salts from your body and get sick. With Adderall (or Vyvanse) good protocol is to get small dose, like 5-10mg early morning once every one or two weeks. Then you’ll get boost when really needed and feel uplifting for few more days. Taking it every day is insane, ADHD or not.
•
Abusing adderall can obviously go wrong, but if you do it right you take it once every month or so and have minimal long term effects. Stanford students arent using it for the euphoria, theyre using it so they can study all night without getting distracted. Its also not a miracle drug, you have to be in the right mindset for it to work and a lot of the people who use it dont understand that.
This doesn't seem like a conclusion that's supported by the available evidence. We have examples of homogeneous cultures that are high trust, and ones that are low trust. We have examples of diverse cultures that are low trust, but none that I'm aware of that maintain high trust over time. The best fitting hypothesis would be that homogeneity is necessary but not in itself sufficient for a high trust culture to be built.
•
Diversity is relative. The difference between Irish and English ancestry created low trust in the mid-1800s USA but is fairly irrelevant today. Trust grew over time.
That's one theory. Counter theory: for all of human existence people have shared resources and traded among each other. Yes, for truly scarce resources trade breaks down. So is "good housing" a scarce resource on Stanford's campus? Or is their default resource allocation schema too anti-human so it's turning something that should be a simple trade and negotiation problem into a knife-fight?
•
America is rooted in capitalism, so the resource allocation schema of scarce goods (e.g. nice homes to raise families in) is indeed a knife-fight.
Both are culpable.
•
Should we not bring up to doctors our issues or worries?
 Top