MurphyA/hacker-news huggingface dataset:
by afzal_ali | 2025-09-08 08:07:30+00:00
Location: Lahore, Pakistan Remote: Yes

Willing to relocate: Yes

Technologies: Ruby on Rails | React js | Next Js | Typescript | PHP Laravel | MySQL | Psql | AWS | AI Integrations

Résumé/CV: https://drive.google.com/file/d/1Q6IQrVH3llpEqX0CRt_YzN08_Jf...

Email: afzalali2728@gmail.com
by gf000 | 2025-09-08 08:07:38+00:00
I tried to translate the article to Rust, but seems that the article's gotcha in Haskell is not necessarily an issue in Rust if we return `dyn OurTrait`, so now I'm even more confused. If anyone could take a look what I'm missing that would be welcome:

------------

Say, you want to write a simple language interpreter.

You have an `Expr` enum (sum type), with say, a `Constant(f64)` and a `BinaryPlus(Expression, Expression)`.

You can easily add a new function expecting an `Expr` indeed, but if you were to add a new variant to the `Expr` enum, you would have to go through the code and change every use site.

You can solve the issue by simply making a `struct Constant` and a `struct BinaryPlus`. Now you can just define a new trait for both of them, and you can use that `dyn trait` in your code -- you can add new functions and also new types without code change at use site!

So what's the issue?

In Haskell, a logic like

```

func example(runtime_val: f64) -> Expr {

if (runtime_val is someRuntimeCheck()) return Constant(..) else return BinaryPlus(.., ..)

}

```

can't compile in itself as `Expr` is a type class (=trait). Basically, in this mode Haskell awaits a concrete implementation (we actually get the exact same behavior with `impl Expr` in Rust), but here is my confusion: this can be circumvented in Rust with dyn traits..

Here is my (very ugly due to just hacking something together while pleasing the borrow checker) code showing it in Rust: https://play.rust-lang.org/?version=stable&mode=debug&editio...
by rthrfrd | 2025-09-08 08:07:39+00:00
> I think one of my personal core values is that curiosity should never be left unsatiated if ant all possible!

I don't disagree: I just posited that there are other ways to satisfy it, and that there is an opportunity cost to the path you've chosen to satisfy it that you don't seem very aware of, because your curiosity and desire to be correct are tightly coupled - but that doesn't actually have to be the case. It has its pros and cons.

Now I'm more of an "it's the journey not the destination" guy, so accelerating the journey doesn't appeal to me as much as it used to, because for me its where I get the most value. That change in my perspective is what motivated me to comment.

But anyway, you clearly enjoy it and do great work, so all the best with it!
by Someone | 2025-09-08 08:07:43+00:00
> And of course there is Forth. Which always felt like it was just around the corner from some kind of breakthrough but it never really happened.

Forth, (I think even more so than lisp), is fragmented, because its philosophy is not that you write “a forth program”, but that you write “a forth” that does what you need it to do. Don’t like the sign MOD chose to compute ‘-3124 modulo -17’? Don’t add a new one, but change yours. Need better approximations for integer goniometric functions? Change them to work in half-degrees, etc.

That makes sharing code difficult and that, in turn, makes it hard to write large programs.

Nowadays, I guess a ‘solution’ to that problem would be to run zillions of forths as microservices in a single process, but I don’t think that’s practical (could be fun, though. In the limit, one could give each forth a VM page of RAM or maybe even less to work in. Imagine a forth whose sole goal is to maintain and edit a string, with words for string indexing, search, replace, duplication, etc. that runs together with millions of other forths in a single process.
by mpweiher | 2025-09-08 08:07:50+00:00
Hmmm...the problems you recount are exactly the problems of putting (way too much) logic into the controller...and not enough logic into the model...which is exactly what MVC recommends you not do, and which is exactly what I criticized about your approach...and which is exactly the critique you seem unwilling to accept.

¯\_(ツ)_/¯

What gives?

Put all the logic in the model. If you want authentication, put that in an "authenticated model" that wraps your model. Don't put it in the controller.

> Controller controls the boundary between the system and the user.

Nope. That is Apple-MVC. Aka Massive-View-Controller. It is not MVC.

The model API is the boundary between the model and the rest of the system.

https://blog.metaobject.com/2015/04/model-widget-controller-...
by touristtam | 2025-09-08 08:08:39+00:00
> Nothing in the current AI world is as predictable as, say, the medicine you can buy or you get prescribed.

Do you know there are approve drugs that have been put in the market for treating one ailment and that have proven to have effect on another or have been shown to have unwanted side effect, and therefore have been shifted? The whole drugs _market_ is full of them and all that is needed is to have enough trial to prove desired effect...

The LLM output is yours to decide if it is relevant to your work or not, but it seems that your experience is consistently subpar with what others have reported.
by pj_mukh | 2025-09-08 08:08:41+00:00
Or more likely it’ll look like the e-commerce adoption plots with a giant pop in the late 90s and then a 20 year slog of consistent growth [1]

Pretty much exactly what the S-curve looks like.

[1]: https://www.marketplacepulse.com/stats/us-e-commerce-growth-...
by exDM69 | 2025-09-08 08:09:09+00:00
Not for multi-channel SDF at least. Texture compression works terribly badly with "uncorrelated" RGB values as they work in chroma/luminance rather than RGB. For uncorrelated values like normal maps, there are texture compression formats specifically for that (RGTC).

However, your typical MSDF font texture has three uncorrelated color channels and afaik there isn't a texture compression format with three uncorrelated channels.
by mr_mitm | 2025-09-08 08:09:21+00:00
Rule S101 [1] is not in the default settings. If you choose to enable it, you have the possibility of disabling it for your tests like so:

[tool.ruff.lint.per-file-ignores] "tests/*" = ["S101"]

(Besides, this was about formatting, not linting, but I realize it's related.)

[1] https://docs.astral.sh/ruff/rules/
by moshib | 2025-09-08 08:10:06+00:00
I can imagine a different attack vector: A malicious actor doing laptop repairs can absolutely replace the hinge sensor and install software on it. They could draw in people by offering cheaper prices, then steal their info or use it to setup more complex scams.

The counterpoint to this is that car body shops can also plant recording devices in your car. This is true, but the signal-to-noise ratio in terms of stealing valuable data is much lower. I don't have data to back this up, but I assume way more people use their laptops for online purchases and accessing their bank account than doing the same with phone calls in the car.
by benterix | 2025-09-08 08:10:24+00:00
Yeah. I worked in places where using LLMs actually made sense but in very limited scenarios (the results were then checked by humans anyway). But there are many places when using LLMs is actually hurting the business, especially if this is a business-to-customer offering and end users are seeing GenAI content. After the initial fascination, I guess many businesses realized that.
by jnsaff2 | 2025-09-08 08:10:47+00:00
The absolute worst experience I had with a Fenix watch (I think the 5x) was that when it could not read my HR from the wrist due to sweat or whatever, which happened often, it would log whatever the last reading was even though it could be wildly incorrect. This completely destroyed my trust in them. Having had experience in aviation I would really expect unreliable readings to be marked as such and rather not display anything than showing incorrect readings.
by praptak | 2025-09-08 08:11:04+00:00
Yeah, it is not entirely obvious. You need to prove that if you fix a number x from range [0,1] then the point at "x * length(Hn)" converges to a point in 2D, for every x, as n goes to infinity (Hn = nth Hilbert curve).

The limit for x is the mapping from x to a point in 2D.

The proof is by observing that the subsequent "jumps" are exponentially smaller.
by blagie | 2025-09-08 08:11:45+00:00
Well, no. It doesn't. The comparison is to the A1000.

Toss in a 5060 Ti into the compare table, and we're in an entirely different playing field.

There are reasons to buy the workstation NVidia cards over the consumer ones, but those mostly go away when looking at something like the new Intel. Unless one is in an exceptionally power-constrained environment, yet has room for a full-sized card (not SFF or laptop), I can't see a time the B50 would even be in the running against a 5060 Ti, 4060 Ti, or even 3060 Ti.
by ThatPlayer | 2025-09-08 08:13:37+00:00
I'd say that's a more recent development though because of how long it took for DisplayPort 2 products to make it to market. On both my RTX 4000 series GPU, and gaming 1440p240hz OLED monitor, HDMI 2.1 (~42 Gigabit) is the higher bandwidth port over its DisplayPort 1.4 (~26 Gigabit). So I use the HDMI ports. 26 Gigabit isn't enough for 1440p240z at 10-bit HDR colour. You can do it with DSC, but that comes with its own issues.

Only now are DisplayPort 2 monitors coming out
by gentooflux | 2025-09-08 08:13:49+00:00
There's a big difference between a "prototype" (or a POC, or a spike, or whatever your company calls it), and an "MVP" (minimum viable product). An insecure product is not viable. A product which cannot be extended or maintained without being almost competitively rewritten is not viable.

MVP means just enough engineered code to solve a problem, rough around the edges and lacking features sure, but not built by someone who has literally no idea what they were doing.

Prototypes of physical products are never put into production and sold to consumers. Unfortunately software prototypes "run", and are sold at that point. Then they begin to scale, and the inherent flaws in their design are amplified. The same thing used to happen with MS Access apps; the same thing still happens with "low code" solutions.

The engineers cost just as much after the prototype phase, but if you don't hire them to build your MVP then you never have one.
by jsherwin011 | 2025-09-08 08:14:14+00:00
Governments worldwide are designing regulatory frameworks to attract entrepreneurs — but Dubai’s Free Zones are among the few that offer 100% foreign ownership, zero corporate tax, and fast-track setup.

This post breaks down how Dubai has positioned itself as a startup hub through legal innovation and global talent incentives.

Useful for digital nomads, remote-first teams, and founders considering MENA expansion. Would love feedback or perspectives from anyone who's built globally - https://www.aaconsultancy.ae/dubai/benefits-of-starting-a-bu...
by anthk | 2025-09-08 08:14:14+00:00
Chimera Linux did some changes on their distro because of that.

EDIT: Ah, they were mentioned, of course.

On some malloc replacements, telescope -a gopher/gemini client- used to be a bit crashy until I used jemalloc on some platforms (with LD_PRELOAD).

Also, the performance rendering pages with tons of links improved a lot.
by benterix | 2025-09-08 08:14:38+00:00
The truth is we have no idea. Personally I'm 100% sure the future will look nothing like what Altman is saying, but I'm a logical person so I have to admit there exist a minuscule probability these GenAI CEO's vision will come true. More rationally, I'd expect something like Meta with Metaverse - enormously missing the mark but still useful for many people. The actual usage will be a function of utility and price.
by sensanaty | 2025-09-08 08:15:22+00:00
Very anecdotally after recently having gone through the interview loop for the last 3 months (and finally landing something last week, yay), there was barely any talk about AI in any of my interviews, both from startups and from larger companies. There was 1 or 2 startups that had some trite things like "AI Native Engineer" for the role, but when I asked my interviewers what that even meant, they basically told me they had no idea and it was something management was pushing to attract people interested in building AI features.

I've done somewhere around 60 or 70 interviews the last 3 months and in every single one I asked "What role do you see LLMs serving in the day-to-day work at $COMPANY, and in the products you're building? And what are your personal thoughts on LLMs and how useful you've found them?". I was pleasantly surprised that nearly everyone had pretty level-headed views about the topic, mostly along the lines of "There's definite potential, it's very useful in some specific tasks, but it's not an all-intelligent panacea like it's being sold to everyone". This included the VP of Engineering at a very large, influential and successful company in the Netherlands who was extremely wary of LLMs. If I had to put a very non-scientific number on the views I encountered, I'd say roughly 80% of companies/teams I talked to were very neutral and balanced on AI, around 10% were fanatics about AI, and the remaining 10% were extremely anti-AI and didn't want anyone on their teams touching them for any of the work.

Caveats of course that this was entirely anecdotal to my experience in recent interviews, and this was all for companies in the Netherlands (both remote roles & local), but I think the tide is starting to turn slowly and people are sobering up a bit from all the incessant, endless hype regarding LLMs (AI is too broad a word with too many actually useful things and it's a shame it's been conquered by the recent LLM hype). You wouldn't think so reading through HN, but then again if you look through recent YC batches like 99% of them mention AI/LLMs in some capacity even when it makes no sense.
Ask HN: Why no inference directly from flash/SSD?
by myrmidon | 2025-09-08 08:15:39+00:00
My understanding is that current LLMs require a lot of space for pre-computed weights (that are constant at inference-time).

Why is it currently not feasible to just keep those in flash memory (fast PCIe SSD Raid or somesuch), and only use RAM for intermediate values/results?

Even modest success on this front seems very attractive to me, because Flash storage appears much cheaper and easier to scale than GPU memory right now.

Are there any efforts in this direction? Is this a flawed approach for some reason, or am I fundamentally misunderstanding things?
by CalRobert | 2025-09-08 08:15:59+00:00
Similarly, Ireland has seen a massive drop in road deaths, but one problem is that a lot of that improvement came from removing vulnerable road users - the kids biking and walking to school, etc are now much more likely to be in a car. (The US is similar - biking or walking to primary school was once the norm). Similarly you’d have zero drownings if you threw sharks in every pool. I do wish we could acknowledge that a lot of the improvement in road “safety” was a result of people just removing themselves from places where cars are.
by Rainbooow | 2025-09-08 08:16:01+00:00
Why so much comments about the bubble aspect?

Sure, there is an AI bubble. But 13B valuation for a startup that is the best positioned to have access to most EU entreprise needs of AI, this does not feel overvalued to me. Mistral does not even need to produce leading models, they just need to produce good enough models that do not lag too much behind the top ones.
by wink | 2025-09-08 08:16:26+00:00
Even cities with decent public transport have neighborhoods that aren't great for this.

I live in Munich and yet going by car is often the fastest, and only during rush hour it's worse. I generally use my bike though, which is so-so. If was 5min by foot from the subway station (and not 15) it would change drastically.

Also I mean it's not terrible, but 30-45 minutes to get somewhere by public transport is the norm. 5min to the bus stop, bus to the subway, subway then is quick. And by car this is often faster, also more reliable, and no walking in the rain.
by adastra22 | 2025-09-08 08:16:53+00:00
Thank you. Now I understand the article. And the problem identified for type classes isn’t an issue in Rust. You’d return a ‘dyn Trait’ and be done. It means the object would have to be heap allocated, but that is already a given because you are wanting to define a function that can work with any type including future defined types. I guess Haskell doesn’t support the equivalent of trait objects for type classes?

I’m not trying to prove that rust is better or something. People who do that are annoying. It’s just weird to me that this is being presented as a fundamental and largely unsolved challenge when there is a simple solution at the heart of a widely deployed and well known language, which in turn stole it from elsewhere.
by rcxdude | 2025-09-08 08:18:12+00:00
I recently saw one with a 'national speed limit' (i.e. 60mph) sign, and right below it: 'not suitable for motor vehicles' (an advisory sign, so no legal weight behind it). It's the default for anything considered a road, and generally unless proven otherwise the government is reasonably happy to let people use their judgement on lower-traffic areas.
by vidarh | 2025-09-08 08:18:42+00:00
In every LLM app you have available that can set temperature.

You can try a template like this:

Turing machine transition table: q₀, 0 → q₀, 0, R q₀, 1 → q₁, 1, R q₀, B → q₀, B, L q₁, 0 → q₁, 0, R q₁, 1 → q₀, 1, R q₁, B → q₁, B, L Current state: [STATE] Current symbol: [SYMBOL] What is the next transition? Format: NEW_STATE|WRITE_SYMBOL|DIRECTION

You might have to tweak it depending on the given model you seek, but given you set temperature to 0, once you've tweaked it so it works on that model for all 6 combinations of state and symbol, it will continue working.

Repeat it, and provide a loop with the IO as indicated by the output.

If you struggle with the notion that an LLM can handle a lookup table from 6 combinations of states and symbols to 6 tuples, you're looking for excuses to disagree and/or don't understand how simple a UTM is.

The above is a sufficient definition for someone who understands a UTM to figure out how to execute the machine step by step.
by Karrot_Kream | 2025-09-08 08:19:10+00:00
Huh I guess I'm lucky I never faced this, we've always used Debian or RHEL containers where I've worked. Every time I toyed with using a minimalist distro I found debugging to be much more difficult and ended up abandoning the idea.

Once the container OS forks and runs your binary, I'm curious why does it matter? Is it because people run interpreted code (like Python or Node) and use runtimes that link musl libc? If you deploy JVM or Go apps this will probably not be a factor.
by Solocle | 2025-09-08 08:19:32+00:00
See, the openness is one reason I'd lean towards Intel ARC. They literally provide programming manuals for Alchemist, which you could use to implement your own card driver. Far more complete and less whack than dealing with AMD's AtomBIOS.

As someone who has toyed with OS development, including a working NVMe driver, that's not to be underestimated. I mean, it's an absurd idea, graphics is insanely complex. But documentation makes it theoretically possible... a simple framebuffer and 2d acceleration for each screen might be genuinely doable.

https://www.x.org/docs/intel/ACM/
by isaacremuant | 2025-09-08 08:19:34+00:00
It's not that crazy when people seem to cheer for a nanny state at every turn. Specially if said nanny state bombards them with propaganda about all the dangers they'll face if they just don't "comply".

1984 references may have seen farfetched but after the suppression of rights using covid as an excuse people have little to no recourse to claim control back. Apple was always famous for their walled garden and tight control, but we have Google becoming like apple (can't install things in your device unless you go to them with your private details), ID to track your movements because "protect the children" (effectively blocking news even), chat control (very similar to installing a camera in your home and recording all your conversations).

Corps and governments are relying on each other to strengthen their control and it's not a surprise.
by litongjava | 2025-09-08 08:19:37+00:00
The AI-powered personalized animated learning platform *Study11.ai* is now live! Enter a learning topic (e.g., Law of Conservation of Momentum ), and the system will automatically generate 1⃣ Scene-based teaching scripts 2⃣ Single-file H5 animations (SVG effects + subtitles + voice) 3⃣ Personalized learning path recommendations

Powered by *Qwen3-Coder*, creating a closed-loop experience from question → animation → learning path.

Examples:

* Law of Conservation of Momentum: [preview.study11.ai/preview/547805514723590144](https://preview.study11.ai/preview/547805514723590144) * What is SVG: [preview.study11.ai/preview/549231403875368960](https://preview.study11.ai/preview/549231403875368960)

Try it now [study11.ai](https://www.study11.ai/) Preview demos [preview.study11.ai](https://preview.study11.ai/) Open-source backend [github.com/litongjava/study11-backend](https://github.com/litongjava/study11-backend)
Show HN: GitHub trends newsletter by star growth (email, RSS, and more)
by mustaphah | 2025-09-08 08:20:33+00:00
Github's trending page is annoying, repeatedly surfacing well-known old projects (Django, Bootstrap, etc.).

Great repos, sure, but not fresh discoveries. That kinda defeats the purpose of "trending."

I built a newsletter featuring fresh trends using star growth analytics. Updates are delivered via

- email (weekly),

- RSS feed (twice daily),

- and GitHub inbox notification (weekly).

Github: https://github.com/mhadidg/gh-trends

Check out the logic and my exploration building it: https://hadid.dev/posts/github-trends

All thoughts and comments are welcome.
by aleph_minus_one | 2025-09-08 08:21:07+00:00
Some (sometimes) desirable source code formatting cannot be deduced from the abstract syntax tree alone:

Consider the following (pseudo-)code example:

bar.glob = 1; bar.plu.a1 = 21; bar.plu.coza = fol;

Should this code formatted this way? Or should it be formatted

bar.glob = 1; bar.plu.a1 = 21; bar.plu.coza = fol;

to emphasize that three assignments are done?

Or should this code be formatted

bar.glob = 1; bar.plu .a1 = 21; bar.plu .coza = fol;

to bring make the "depth" of the structure variables more tabular so that you can immediately see by the tabular shape which "depth" a member variable has?

We can go even further like

bar.glob = 1; bar.plu.a1 = 21; bar.plu.coza = fol;

which emphasizes that the author considers it to be very important that the reader can easily grasp the magnitudes of the numbers involved (which is why in Excel or LibreOffice Calc, numbers are right-aligned by default). Or combining this with making the depth "tabular":

bar.glob = 1; bar.plu .a1 = 21; bar.plu .coza = fol;

Each of these formattings emphasizes different aspects of the code that the author wants to emphasize. This information cannot be deduced from some abstract syntax tree alone. Rather, this needs additional information by the programmer in which sense the structure behind the code intended by the programmer is to be "interpreted".
by blagie | 2025-09-08 08:21:53+00:00
Four of these together should, in the abstract, let you run 200GB models, which is where things get very, very interesting.

The biggest Deepseek V2 models would just fit, as would some of the giant Meta open source models. Those have rather pleasant performance.

In theory, how feasible is that?

I feel like the software stack might be like a Jenga tower. And PCIe limitations might hit pretty hard.