HNHacker News
TopNewBestAskShowJobs

noodletheworld

444 karma · joined December 14, 2024

submissionscomments
noodletheworld··on A 10x Faster TypeScript
Thanks for chiming in with these details, but I would just like to say:

> It will not conflict with other applications that do the same thing.

It is possible not to conflict with existing parallel deployments, but depending on your IPC mechanism, it is by no means assured when you're not forking and are instead launching an external process.

For example, it could by default bind a specific default port. This would work in the 'naive' situation where the client doesn't specify a port and no parallel instances are running. ...but if two instances are running, they'll both try to use the same port. Arbitrary applications can connect to the same port. Maybe you want to share a single compiler service instance between client apps in some cases?

Not conflicting is not a property of parallel binary deployment and communication via IPC by default.

IPC is, by definition intended to be accessible by other processes.

Jupyter kernels for example are launched with a specified port and a secret by cli argument if I recall correctly.

However, you'd have to rely on that mechanism being built into the typescript compiler service.

...ie. it's a bit complicated right?

Worth it for the speedup? I mean, sure. Obviously there is a reason people don't embed postgres. ...but they don't try to ship a copy of it along side their apps either (usually).

noodletheworld··on A 10x Faster TypeScript
Go is quite difficult to embed in other applications due to the runtime.

What do you see as the future for use cases where the typescript compiler is embedded in other projects? (Eg. Deno, Jupyter kernels, etc.)

There’s some talk of an inter process api, but vague hand waving here about technical details. What’s the vision?

In TS7 will you be able to embed the compiler? Or is that not supported?

noodletheworld··on Simple Explanation of LLMs
While I appreciate the pictures, really at the end of the day all you have is a glossary and slightly more detailed arbitrary hand waving.

What specific architecture is used to build a basic model?

Why is that specific combination of basic building blocks used?

Why does it work when other similar ones don’t?

I generally approve of simplifications, but these LLM simplifications are too vague and broad to be useful or meaningful.

Here my challenge: take that article and write an LLM.

No?

How about an article on raytracing?

Anyone can do a raytracer in a weekend.

Why is building an LLM miles of explanation of concepts and nothing concrete you can actually build?

Where’s my “LLM in a weekend” that covers the theory and how to actually implement one?

The distinction between this and something like https://github.com/rasbt/LLMs-from-scratch is stark.

My hot take is, if you haven’t built one, you don’t actually understand how they work, you just have a kind of vague kind-of-heard of it understanding, which is not the same thing.

…maybe that’s harsh, and unfair. I’ll take it, maybe it is; but I’ve seen a lot of LLM explanations that conveniently stop before they get to the hard part of “and how do you actually do it?”, and another one? Eh.

noodletheworld··on Hallucinations in code are the least dangerous form of LLM mistakes
If you want to use LLMs for code, use them.

If you don't, don't.

However, this 'lets move past hallucinations' discourse is just disingenuous.

The OP is conflating hallucinations, which are a fact, and undisputed failure mode of LLMs that no one has any solution for.

...and people not spending enough time and effort learning to use the tools.

I don't like it. It feels bad. It feels like a rage bait piece, cast out of frustration that the OP doesn't have an answer for hallucinations, because there isn't one.

> Hallucinated methods are such a tiny roadblock that when people complain about them I assume they’ve spent minimal time learning how to effectively use these systems—they dropped them at the first hurdle.

People aren't stupid.

If they use a tool and it sucks, they'll stop using it and say "this sucks".

If people are saying "this sucks" about AI, it's because the LLM tool they're using sucks, not because they're idiots, or there's a grand 'anti-AI' conspiracy.

People are lazy; if the tool is good (eg. cursor), people will use it.

If they use it, and the first thing it does is hallucinate some BS (eg. intellij full line completion), then you'll get people uninstalling it and leaving reviews like "blah blah hallucination blah blah. This sucks".

Which is literally what is happening. Right. Now.

To be fair 'blah blah hallucinations suck' is a common 'anti-AI' trope that gets rolled out.

...but that's because it is a real problem

Pretending 'hallucinations are fine, people are the problem' is... it's just disingenuous and embarrassing from someone of this caliber.

noodletheworld··on 400 reasons to not use Microsoft Azure
… I was scrolling back through the “400 reasons not to use azure” in the OP and off the top of my head I’ve seen a dozen of them personally.

You decide if that’s more or less stable than AWS.

I’d say the evidence is pretty empirical, but hey, all I can say is my experience was utterly unambiguous.

You can argue a lot of things, but hundreds of azure fails in a big giant list is probably one of the tougher ones to go “no, this is fine compared to AWS!” about, imo.

noodletheworld··on 400 reasons to not use Microsoft Azure
My experience has certainly been that AWS is both a) more stable, and b) has more migration resources and guides than the reverse.

It was easier to go to AWS than to Azure; and I've done both in the past ~4 years. Migrating to AWS was just technical work. Migrating to azure was 'fight unexpected bugs and the fact it doesn't actually work in surprising situations'.

The only reason to go to azure was that Microsoft waved a big fat $$$ discount to use their services.

Migrating to AWS was a breeze.

noodletheworld··on PanGui – A cross-platform UI library with a razor sharp focus on performance
Did something new happen? Can you actually use it now somehow?

This was announced (and discussed with no interest a year ago, previously on https://news.ycombinator.com/item?id=39997562 and /r/unity3d)

noodletheworld··on Why Clojure?
In what way is clojure.spec similar to python's type hints? O_o
noodletheworld··on Why Clojure?
I don't think spec with solve issues you are having about dynamic types.

Spec is about asserting structure at domain boundaries; once you're inside a context, it will not do anything.

i.e. If you're connecting stuff together and you want to make sure the state is correct as you pass between contexts -> great!

If you're writing stuff and internally you miss having a strong type system... uh... I don't think it's really going to help you.

noodletheworld··on A year of uv: pros, cons, and should you migrate
> becoming the One True Package Manager for a very popular programming language is an extremely valuable thing

For companies. Which is why when random people start acting like it’s important, you have to wonder why it’s important to them.

For example, being a corporate shill. Or so deep in coolaid you can’t allow alternative opinions? Hm?

It’s called an echo chamber.

noodletheworld··on A year of uv: pros, cons, and should you migrate
So what?

If someone doesn’t want to use it, or doesn’t like it, or is, quite reasonably skeptical that “this time it’ll be different!” … let them be.

If it’s good, it’ll stand on its own despite the criticism.

If it can’t survive with some people disliking and criticising it is, it deserves to die.

Right? Live and let live. We don’t have to all agree all the time about everything.

uv is great. So use it if you want to.

And if you don’t, that’s okay too.

noodletheworld··on Show HN: Cot: a Rust web framework for lazy developers
Lots of “Rails but for X” projects exist in various states, for various languages, but have failed to gain traction and stand abandoned.

…like, a lot.

I thiiiink, fundamentally, it’s a harder-than-it-looks problem space and if you come out with something that’s rough and broken, it never gains enough critical mass for it to become self sustaining.

What’s the “pitch”? It’s can’t be “Django but for rust but it’s kind of not ready yet”, bluntly.

So it needs to have some outstanding feature or accumulation of features that let it stand out from the other 30 rust web frameworks. Is there something here?

You really need to call out the “why another rust web framework” in more than just terms of ambition, imo.

noodletheworld··on JetBrains Fleet drops support for Kotlin Multiplatform
> Many of my colleagues try them out for an hour or two and then jump ship back to VSCode just because the initial "wtf is going on" factor is so high =/

Really?

I mean, the UIs are basically the same now. I have them open side by side on my desktop right now and they're both:

- black boxes with a panel on the left of icons, then a tree of files, then a tabbed pane of open files.

- clicking on the icons on the left opens some obscure subwindow depending on you magically knowing what the icon means.

The only meaningful difference is that in vscode there's a command palette at the top where you can type in random stuff and get a list of actions, and in intellij you have to 'know' that the shortcut for that is 'press shift 3 times' instead of 'shift control p'

...but I mean, thats it; they're otherwise pretty much identical, practically.

Honestly, anyone who opens intellij and then goes back to vscode because its too different is a numpty.

Things work differently, and people don't like different things, and if they go back because it was different or the shortcuts are different, that's fair. It is disruptive.

...but, because the 'wtf is going on' factor is too high? Realllllllly? What does that even mean?

Come on. They're not that different. If clicking on 'run' on the top right instead of on the left bar is too 'wtf', you really haven't made a real effort to try using the other IDE.

(The same goes for old school intellij users who try vscode and then run away. Give it a decent shot before you walk away because it's too hard if the only hard thing is your keyboard shortcut muscle memory... vscode is pretty great)

You only really see the deep differences when you use them extensively for things like refactoring and debugging.

noodletheworld··on No AI December Reflections
Zero memory of chat conversations resonates to me.

At a practical level, this is a good reason to run your own AI plugin, even if it just a wrapper around some api.

You can log your requests and the responses, and then use a similarity score to periodically see what sorts of things you’re asking.

I may even update mine to hassle me and be like “you’re asking this a lot, maybe you should remember it…”

(If, you can be bothered, rather just reaching for copilot)

noodletheworld··on VSCode’s SSH agent is bananas
Well, I’m not going to go into the arguments about using or not; but if you are serious about the switch put something like key promoter on to learn the new shortcuts.

Most of the inertia that stops people changing is just muscle memory. Once you fix that, it’s fine.

Also, if you write plugins, check out the plugin guide. Maintaining IntelliJ plugins has driven me away; once you start writing vscode plugins you’ll find it a good reason to stay.

noodletheworld··on Nvidia open-source nanite: continuous level of detail (LOD) mesh library
Yeah nah.

In this context it reads as a verb (nvidia has open sourced nanite) not a noun (this is an open source version of nanite).

“Entity open-source project” is not an ambiguous statement.

It would need to be “Entity’s open source nanite clone” imo.

As it stands the title is pretty misleading.

noodletheworld··on Two Programming-with-AI Approaches
> modularisation is an approach to software construction that I generally tend to avoid - as a human writing code I just find it confusing and high overhead

How baffling.

Anyone who avoids modularisation or considers it 'overhead' has never worked on a large system; or, has only worked on small over-engineered projects.

In large projects, it is physically impossible to 'be across' everything that's happening in the code.

The only, and I do mean only way to work effectively in a code base like this is to become familiar with a small part of it, clearly identify the boundaries of 'this part' and make sure that your changes happen only with that context where you:

- understand the side effects

- understand the domain

- can work effectively.

That is what modularisation is.

It is not 'making an NPM package for lpad'; the rough size of 'code you can keep track of' is very obvious to most people; when the code gets bigger than that you need to break it up into modules with clearly defined boundaries.

You then learn the boundaries.

The boundaries are smaller than the code.

You can therefore work effectively by understanding a subset of the code (my module + the boundaries of the modules I interact with) which is strictly < (my module + the content of the modules I interact with).

...

Amazingly, the same thing applies to LLMs that applies to people!

For small projects, you can just go in and do whatever you like and it'll be fine; for larger ones, you have to split it into smaller parts and do each part independently.

Absolutely right... but, surely not surprising to anyone?

...

Here's a pro-tip for you LLM work:

You can easily pick the size to use for modules based on the volume of code inside it.

Compare the size and complexity of the API for interacting with the module (class, crate, whatever) with the implementation details. I use 'lines of code + documentation + examples for the LLM to use it' as my vague metric.

If you're doing an 'lpad' and the implementation is <= the size of the API, don't bother to make it a module. You're wasting your time.

When the implementation gets ~10x the size of the API, split it.

It ain't rocket science. LLMs are good at writing glue code from well defined APIs.

noodletheworld··on DeepSeek-R1
> which is effectively what this model is doing.

That isn't what it's doing and it's not what distillation is.

The smaller models are distillations, they use the same architecture they were using before.

The compute required for Llama-3.1-8B and DeepSeek-R1-Distill-Llama-8B are identical.

In general I agree that this is a rapidly advancing space, but specifically:

> the Llama 8B model trained on R1 outputs (DeepSeek-R1-Distill-Llama-8B), according to these benchmarks, is stronger than Claude 3.5 Sonnet

My point is that the words 'according to these benchmarks' is key here, because it's enormously unlikely (and this upheld by the reviews of people testing these distilled models), that:

> the Llama 8B model trained on R1 outputs (DeepSeek-R1-Distill-Llama-8B) is stronger than Claude 3.5 Sonnet

So, if you have two things:

1) Benchmark scores

2) A model that clearly is not actually that enormously better from the distillation process.

Clearly, clearly, one of those two things is wrong.

Either:

1) The benchmarks are meaningless.

2) People are somehow too stupid to be able to evalulate the 8B models and they really are as good as Claude sonnet.

...

Which of those seems more likely?

Perhaps I'm biased, or wrong, because I don't care about the benchmark scores, but my experience playing with these distilled models is that they're good, but they're not as good as sonnet; and that should come as absolutely no surprise to anyone.

noodletheworld··on DeepSeek-R1
> according to these benchmarks

Come onnnnnn, when someone releases something and claims it’s “infinite speed up” or “better than the best despite being 1/10th the size!” do your skepticism alarm bells not ring at all?

You can’t wave a magic wand and make an 8b model that good.

I’ll eat my hat if it turns out the 8b model is anything more than slightly better than the current crop of 8b models.

You cannot, no matter hoowwwwww much people want it to. be. true, take more data, the same architecture and suddenly you have a sonnet class 8b model.

> like an insane transfer of capabilities to a relatively tiny model

It certainly does.

…but it probably reflects the meaninglessness of the benchmarks, not how good the model is.

noodletheworld··on Rhai: An embedded scripting language for Rust
I've worked with moai (1) reasonably extensively, and the lua in it is not easy to use and sucks.

Specifically, a project that is composed entirely of lua with no other dependencies is indeed very easy to build and maintain. I agree.

However, my $0.02 would be that if you plan to have a large project with many 3rd party dependencies, then cmake, visual studio, C++, lua and the time spent jumping between them and maintaining those dependencies in a custom build toolchain will cost you more time and effort than the benefits that lua offers (2).

...and you do, indeed, need to do that, because c++ lacks a centralized package ecosystem and unified build tooling; and as operating systems change, existing builds stop working.

So, yes, you may consider my answer to be 'rust'; but the actual answer is 'not C++ and not cmake'.

That all said, lua is a more mature better system than this is currently, with good resources online and an active community. In cases where a small dependency tree can be maintained, it's still the best choice I'm aware of.

I'm simply pointing out that there are reasons you would pick it over lua, and I think they're quite compelling for cases where the future dependency graph of your project is unknown / unknown.

[1] - https://github.com/moai/moai-dev

[2] - ...and yes, I'm aware that moai is especially egregious in this regard. I get it.

noodletheworld··on Thoughts on a Month with Devin
It stands for Monte Carlo search tree.

Ie. Better outputs from models, not external tooling and prompt engineering.

https://github.com/zz1358m/MCTS-AHD-master

noodletheworld··on Thoughts on a month with Devin
Those “how I feel about Devin after using it” comments at the bottom are damning, when you compare them to the user testimonials of people using cursor.

Seems to me that agents just aren’t the answer people want them to be, just a hype wave obscuring real progress in other areas (eg. MCST) because they’re easy to implement.

…but really, if things are easy to implement, at this point, you have to ask why they haven’t been done yet.

Probably, it seems, because it’s harder to implement in a way that’s useful than it superficially appears…

Ie. If the smart folk working on Devin can only do something of this level, anyone working on agentic systems should be worried, because it’s unlikely you can do better, without better underlying models.

noodletheworld··on LLM based agents as Dungeon Masters
Alas, I was desperately keen to read transcripts of actual gameplay and all we got was user surveys?

Was there a structured combat system as sort of this or was it a talking only kind of thing? Who knows?

Trying to get empirical evidence that an LLM can even remotely plausibly work as a DM with no social aspect and (as far as I can tell, reading the paper) no programmed system of stats, rolls, combat etc. seems impressive.

…but was it that? Or just a DnD themed chatGPT conversation? Or a text adventure with an LLM describing each “room”?

Did the LLM actually have agency to make decisions and perform tasks, or was it not an agent at all, just a conversation?

Without a transcript, all you can really say for sure is yeah, I agree; more research is needed.

noodletheworld··on Phi 4 available on Ollama
The ollama application has zero value; it’s just an easy to use front end to their model hosting which is both what this is and why they’re important.

Only having one model host (hugging face) is bad for obvious reasons (and good in others, yes, but still)

Ollama offering an alternative as a model host seems quite reasonable and quite well implemented.

The frontend really is nothing; it’s just llama.cpp in a go wrapper. It has no value and it’s not really interesting, it’s simple stable technology that is perfectly fine to rely on and be totally unexcited or interested in, technically.

…but, they do a lot more than that; and I think it’s a little unfair to imply that trivial piece of their stack is all they do.

noodletheworld··on Mistakes engineers make in large established codebases
> people like to use new language features and frameworks.

Have of the point of this article is that people need to suck it up and not use new frameworks sometimes...

There are times for coding in a way you, personally, find pleasing; and there are times when:

> So you should know how to work in the “legacy mess” because that’s what your company actually does. Good engineering or not, it’s your job.

A quote from the 'big ball of mud':

> Sometimes it’s just easier to throw a system away, and start over.

It is easier, but it's also a) not your decision and b) enormously disruptive and expensive.

How do you tell if you're in the 'naive and enthusiastic but misguided' camp, or in the 'understand the costs and benefits and it's worth a rewrite' camp?

Maybe the takeaway from the OP's post really should be this one:

> If you work at a big tech company and don’t think this is true, maybe you’re right, but I’ll only take that opinion seriously if you’re deeply familiar with the large established codebase you think isn’t providing value.

^ because this is the heart of it.

If you don't understand, or haven't bothered to understand, or haven't spent the time understanding what is already there, then you are not qualified to make large scale decisions about changing it.

noodletheworld··on What Happens to Relicensed Open Source Projects and Their Forks?
> It is still too early to understand the ultimate success or failure of these projects — both the original and the fork.

Mm. This is more “here are some projects and their forks” than “what happens to…”

Ie. TLDR; they’re both going fine in all cases, so far.

Guess we wait and see eh?

noodletheworld··on That's not an abstraction, that's a layer of indirection
> examples from past and present experience spring immediately to mind

Examples of what?

Picking the wrong abstraction? Regretting your mistakes?

I can certainly think of many examples of that.

How you unwrapped an abstraction and made things better by removing it?

I have dozens of battle stories.

Choosing not to use an abstraction because it was indirection?

Which is what the article says to do?

I’m skeptical.

I suspect you’ll find most examples of that are extremely open to debate.

After all, you didn't use the abstraction so you don’t know if it was good or not, and you can only speculate that the decision you made was actually a good one.

So, sharing that experience with others would be armchair architecture wouldn't it?

That’s why this article is arrogant; because it says to make decisions based on gut feel without actually justifying it.

“Is this truly simplifying the system?”

Well, is it?

It’s an enormously difficult question to answer.

Did it simplify the system after doing it is a much easier one, and again that should be the advice to people;

Not: magically do the right thing somehow.

Rather: here is how to undo a mistake.

…because fixing things is a more important skill and (always) magically doing the right thing from the start is impossible; so it’s meaningless advice.

That’s the problem with universal advice; it’s impossible to apply.

noodletheworld··on That's not an abstraction, that's a layer of indirection
Pretty easy to give generic advice without examples.

“Write more tests, but not too many”

“Use good abstractions where appropriate?”

“The next time you reach for an abstraction, ask yourself: Is this truly simplifying the system? Or is it just another layer of indirection?”

It’s easy to create a strawman here (the FactoryAdaptorMapper or whatever) but in reality this kind of generic advice doesn’t help anyone.

Of course people want to use good abstractions.

That’s not the problem.

The problem is being able to tell the difference between generic arbitrary advice (like this post) and how your specific code base needs to use abstractions.

…and bluntly, the only way to know, is to either a) get experience in the code base or b) read the code that others have left there before you.

If it’s a new project, and you’re not familiar with the domain you’ll do it wrong.

Every. Single. Time.

So, picking “good” abstractions is a fools game.

You’ll pick the wrong ones. You’ll have to refactor.

That’s the skill; the advice to take away; how to peel back the wrong abstraction and replace it with your next best guess at a good one. How to read what’s there and understand what the smart folk before did and why.

…so, I find this kind of article sort of arrogant.

Oh, you want to be a great programmer?

Just program good code. Use good abstractions. Don’t leave any technical debt. Job done!

…a few concrete examples would go a long way here…

noodletheworld··on Go should sometimes be a no-go
Im going to go out a limb here and say: if you’re going to respond to this with “lol Java” or “but you’ll like go if you try it for long enough”, you’re doing yourself and your community a disservice.

Responding to detailed critique with trite offhand dismissal just comes off as a massive Kool Aid Drinker. Don’t be that guy!

Anyway, here my take!

Go! It is beyond frustrating that the core team has walked back on a number of stubborn decision that they were wrong about and that they appear to have made in a stubborn opinionated way based on good intentions and a deep failure to listen to people who really do know what they’re talking about.

…until it becomes overwhelming apparent that they were wrong; buuut, I still use it, and I don’t dislike it that much and maybe taking a long time to get to a good position isn’t a bad thing?

It is frustrating; but what do you want? There’s a good package system now. Some of the missing tools are there now. Generics. That’s good right? Why is that a bad thing?

Frustrating? Ok. But bad? Bad enough to not use go?

How is having good things now a reason not to use them?

Also, when you look at other kitchen-sync languages that are eager to embrace new things, there’s a bloated complexity that comes with it. That’s also frustrating and draining.

You can’t have everything.

A lot of people use go and it’s fine.

If you’re building a big complicated ERP system, maybe Java is a better choice for you. It’s a good choice for some people. Java is also a great programming language and it has a massive, excellent third party ecosystem.

…

If go makes you sad, don’t use it.

Some of the critique is probably fair, but it’s still a great language with an excellent set of tools around it (not debugging, or c ffi, but static binaries and cross compiling :)

The critique of the “go way” and the go core team is probably unfair; it can feel frustrating. I get frustrated. …but you get a pile of shiny crap when you design by committee. These people are doing a lot of work and it’s going… pretty ok, I think?

Strong, opinionated maintainers are a good thing.

← PreviousPage 8 of 8