fouric

I'm glad I'm not going insane...

I have also noticed this with Sonnet, funnily enough - it's not as strong, but it's still there. But yeah, I haven't seen this with any other model so far (although I mostly use the stronger ones - maybe it's a function of intelligence?).

I don't think it's particularly effective to create a new coding agent when there's existing open-source agents (especially extremely extensible ones like Pi) that already optimize for cache hits, have far larger communities, and work for providers other than Deepseek.

I specifically use multiple different models and providers, so this wouldn't be useful for me.

And it contributes to the problem of each person vibe-coding their own, incompatible, half-baked tool in a space, instead of contributing to a small set of tools and expanding them.

It'd be better to just extend an existing tool.

I'd generally agree about Deepseek being as good as Sonnet - but I have extreme trouble with prompt compliance with V4 Pro in a way that I've never had with Sonnet. I'll tell it "find the bug, but don't fix it" or "please use this tool I just developed" and it'll ignore me a high fraction of the time.

It's bad enough that I'm working on guardrails at the harness level because prompting appears to be useless.

Do you have the same issue?

As someone who loves Lisps, I still have to disagree on the value of the s-expression syntax. I think that sexps are very beautiful, easy to parse, and easy to remember, but I think that overall they're less useful than Algol-like syntaxes (of which I consider most modern languages, including C++, to be in the family of), for one reason:

Visually-heterogeneous syntaxes, for all of their flaws, are easier to read because it's easier for the human brain to pattern-match on distinct features than indistinct ones.

The GP is factually wrong. There's plenty of empirical evidence to indicate that language influences thought, and that syntax is therefore important.

Although, I would point out that while your argument ad absurdum is generally reasonable (the fact that syntax can make the difference between a very good language and an unusable one), whitespace and malbolge also have terrible semantics that contribute to them being unusable.

As a former Lisp enthusiast (and still an enjoyer), I'd actually use my own darling as an example: Lisps have amazing semantics and are generally good languages. Their syntax is highly regular and structured and easy to parse...except that it's brain-hostile, and I'm convinced that it actively makes it harder to read and write - not just adopt, but actually use.

Forget handwriting - I rarely see anything with as much care and effort put into it as this project.

I like to think that I put a lot of ~~craftmanship~~ into my code, but the effort put into every single letter of a roughly fifteen-thousand-word book (to say nothing of the letter at the beginning of the chapters or the illustrations) is on another level.

No-cloning theorem applies to logical qubits too! That "30% of errors" doesn't allow you to read out the logical state. Information is physical.

A lot of the reason why Lispers may be averse to static types is because of the perceived inflexibility it can induce into the system.

This perceived inflexibility is what my comment was getting at - that for primitive type systems available back in the 80's, yes, the types significantly constrained the programs you could write. With today's type systems, however, you have far more flexibility, especially those with "Any" types that allow you to "punch a hole in the type system", so to speak.

When I tried typed Python a few years ago, I found out that, to my surprise, 99% of the code that I naturally wrote could have static types attached (or inferred) without modification because of the flexibility of Python's type system.

I also learned that types are a property of programs, more than just languages. If a program is ill-typed, then having a dynamically-typed language will not save you - it will just crash at runtime. Static types are limiting when either (1) they prevent you from writing/expressing well-typed programs because of the inexpressiveness of the type system or (2) it's burdensome to actually express the type to the compiler.

Modern languages and tools present massive advances in both of those areas. Type systems are massively more expressive, so the "false negative" area of valid programs that can't be expressed is much, much smaller. And, with type inference and more expressive types, not only do you sometimes not have to express the type in your source code at all (when it's inferred), but when you do, it's often easier.

The "Any" type is really what steals the show. I don't think that there's a lot of value in a fully statically-typed Lisp where you can't have dynamic values at all - but I think there's a lot of value in a Lisp with a Python-like type system where you start out static and can use "unknown", "any", and "object" to selectively add dynamic types when needed.

Because, being a Lisper, you probably think like me, I'll give you the idea that really convinced me that types are positive value (as opposed to "only" being small negative value): they enable you to build large, complex, and alive systems.

Types are a force-multiplier for our limited human brains. With types, you can more easily build large systems, you can more easily refactor, you can start with a live REPL and more easily transition your code into source on disk. Types help you design and build things - which is why we use Lisps, after all!

For Common Lispers such as myself, who are vaguely aware of developments in the Scheme space: the most important difference between CRUNCH and Chicken appears to be that, while both compile down to C/object code, CRUNCH is additionally targeting a statically-typed subset of Scheme.

Opinion: this is great. The aversion of Lispers to static types is historical rather than intrinsic and reflects the relative difference in expressiveness between program semantics and type semantics (and runtime vs tooling) for much of computing. Now that types and tools are advancing, static Lisps are feasible, and I love that.

Thanks for the response!

Are there any resources on learning to design simpler layout systems (like flexbox + any other important parts) without having to adjust the design to compensate for older systems (e.g. if you were to try to implement CSS).

Layout is so difficult that it made me quit using Common Lisp and ncurses to build my passion project and become the very thing I swore to destroy (a React developer).

I can't be the only one who wants a simpler layout language than CSS that's designed with two decades of hindsight to provide the maximum simplicity-expressiveness product. Are there any serious projects to engineer something like this, or has everyone given up and either embraced CSS3 (waiting for the LLVM backend) or gone back to plain text?

This is super neat - SBCL is an awesome language implementation, and I've always wanted to do CL development for a "real" game console.

I'm also surprised (in a good way) that Shinmera is working on this - I've seen him a few times before on #lispgames and in the Lisp Discord, and I didn't know that he was into this kind of low-level development. I've looked at the guts of SBCL briefly and was frightened away, so kudos to him.

I wonder if SBCL (+ threading/SDL2) works on the Raspberry Pi now...

I'm currently very slowly making my way through Geometric Algebra for Physicists by Doran and Lasenby. The book is a delight to read, but I'm not a mathematician, and this article is showing me that my small amount of understanding is...not nearly as deep, and especially not nearly as rigorous, as I would like. I should try to re-read with Eric's criticisms in mind.

It's true that any kind of pay-per-use would be a hard, hard sell, though. Who wants to have to think about whether every click is worth the nickel it's going to cost?

I've heard this argument before, but there's a common existence proof to the fact that it's possible: video games. People who play many different kinds of video games (RTS, MOBA, MMO, RPG) get used to making decisions as to whether to buy things many times an hour with barely any cognitive load - their brains just get used to working with smaller units of time and money.

And why shouldn't they? I found sources online that say that a YouTube video earns about $5 per 1k views, or 0.5c per view. If I have to pay half a cent to watch a video, even a short five-minute one, that's almost below the threshold of caring, and even those making median income are probably going to be constrained by the actual time that they have available to watch, rather than the cost of the videos. People will spontaneously spend $20 to go out to eat - after the initial adjustment to a micropayment system, they should have very little trouble spending 60 cents to watch YouTube for five whole hours after work, especially if the micropayment system has common-sense features such as clearly showing your wallet balance over time, how much you've recently spent, and how much longer your balance will last at your current rate of consumption.

Now, to be fair, the fact that it's possible, and that people will quickly get used to it after they spend some time with it, doesn't mean that people will be interested in trying it in the first place, and that's a much harder problem, because subscription services are more lucrative for companies. I think the only way to get micropayments off the ground would be a grassroots movement supported by a bunch of content creators making their stuff available on a micropayment platform. Otherwise, companies that move away from ads (e.g. Google) will just turn to subscription services to lock their users in.

Counter proposal: how about we don't destroy our own planet.

How about we not pollute HN with low-effort, content-less, anti-intellectual, flamebait knee-jerk reactions? Let's leave those on Reddit, please.

My fear for end users is that once an alternative App Store opens or direct side loading is allowed it will reduce users options and harm the users ability to effectivly control privacy.

This is massively misinformed. The majority of privacy controls exist in iOS itself completely independently of the distribution method, and many more unimplemented potentially beneficial privacy controls can also be implemented at that level. This has been true for years.

One of my relatives is in her early 20's and has a large amount of difficulty using Linux (even for relatively simple needs like what you describe above), despite dozens of "support interactions" and assistance. Other relatives are in their 40's and failed to use it as well.

It's not enough for some people to be able to use Linux - if you want to recommend it for general use, it has to be usable for almost everyone.

https://news.ycombinator.com/item?id=39130904

This is not the case for the majority of people or computers.

https://news.ycombinator.com/item?id=39130904

I've tried to get multiple non-family members set up with Linux and have failed, with constant bugs from Linux, and confusion from the family members. Windows is far more reliable and easier for them to use.

This clearly invalidates your point, and supports "Linux would be either painful or more realistically a no go", because it's obviously not enough for some relatives to be able to easily use Linux - most of them need to be able to. The fact that you have more capable-than-normal relatives or more Linux-friendly-than-normal hardware is irrelevant to the fact that most people do not.

This seems like a reasonable take - there's only one problem: you haven't told us how to draw the rest of the owl.

How does one learn how to (1) think in this way (which necessitates not only abstract description but multiple concrete examples) and (2) what workflows and commands are necessary to effectively implement this?

Why would someone put ANYTHING on their resume that is not factually correct?

Tragedy of the commons and negative externalities. If you're applying for a ton of jobs, then lying on your resume comes with potential upsides (you could get a job that you normally wouldn't) with very little personal downside (employers don't really have a way to share which applicants falsified resume data).

Sure, doing this raises the noise level and makes it harder for people who don't lie on their resumes (tragedy of the commons), but from an individual perspective, that's a negative externality that they don't have to care about.

This is classic goal-post moving - you started out by saying that Intellij was faster than VSCode, then after a commentator said that their experience was the opposite, you moved the goal-post to "well it doesn't matter". You should be willing to admit when you're wrong.

Sorry, not even remotely close. I want to see some serious evidence.

Funny that you say "not even remotely close" while providing zero evidence yourself, but then ask other people to present their evidence.

https://benchmarksgame-team.pages.debian.net/benchmarksgame/...

There you go. There's the evidence. No goalpost-moving, please.

For evidence that Javascript can be used to build large, production-quality applications, see coldtea's comment: https://news.ycombinator.com/item?id=37568707

Is there a known method for doing this, or is it just theoretically possible but no actual algorithm?

How might a quantum computer help? I was under the impression that there are only two quantum algorithms that are concretely known to provide exponential speedups for interesting problems relative to known classical state-of-the-art, and neither of them (Shor's and Grover's) appears to be useful for physics simulations. Was I mistaken?

Source?

This is really interesting to me because it implies that shallow breathing for long periods of time is a bad thing.

I previously assumed that it was a good thing, due to interpolation from martial arts training - breathing exercises -> body becomes more efficient at pulling oxygen from the air and using it.

I think I may need to reevaluate my assumptions.

See my below comment, which covers:

As long as it's not regurgitating it wholly

...because (1) we currently have no guarantees that a model won't regurgitate it wholly (or enough that it's infringing according to the law and/or common sense) and (2) because the model itself is either (a) modification and redistribution of the content (in which case it violates those licenses) or (b) some new act not covered by existing copyright law, in which case the authors haven't consented to it because the licenses they've distributed their content under only cover the modification and redistribution cases.

regurgitation is most of what our species does

Sure, there's a continuous spectrum from repeating a single new word ("jank") to a whole book - and one is clearly copyright infringement, and the other isn't - but you still have to acknowledge that partial reproductions of an artistic works can still be owned by the author. A single chapter of Harry Potter is still owned by J.K. Rowling.

But because it's a model doing it and not a person it's intrinsically bad or something

You act like it's somehow not obvious that a model is not a person, and vastly different sets of moral codes and legal rules apply to each.

The macro solution send you down the path of having to memorize context specific commands and say a whole lot of words to get a small effect.

The macros that I'm talking about are exactly the opposite - you say a small number of words to produce a large effect (or, however much effect you programmed into them), e.g. when you define an Emacs function. What macros are you talking about?

btw, small pushback. The way we use tools and programs is not abnormal.

The vast majority of people do not use speech interfaces to tools and programs, so this use is abnormal by definition - abnormal means "outside of the norm" and this is very much outside of the norm.

Your comment shows just how much judgment people have when a user violates a designers UI vision or perceived physical norms.

No, it does not. "Abnormal" is not a judgement or a negative term - it literally just means "several standard deviations from the mean" (for some value of "several") - you can describe someone having "abnormal intelligence" (and the connotation with that phrase is almost universally positive). Don't read negative meaning into other peoples' comments where it doesn't exist.

If a user can't make use of the UI provided, it's not the users fault, that belong squarely on the UI developer.

I'm not assigning fault to the user. You're assuming things here also.

I appreciate your attempt to help, but what works for your body may not work for others - I'm looking for general ergonomic principles backed up by sound scientific evidence.