aozgaa

Another solution to the pipeline example, this time making use of a subprogram for the frequency/accumulation:

    < README.md \
      tr -c '[:alpha:]' '\n' \
    | tr '[:upper:]' '[:lower:]' \
    | awk '
        NF {
          if (!($0 in count)) order[++n] = $0
          count[$0]++
        }
        END {
          for (i = 1; i <= n; i++) {
            print count[order[i]], order[i]
          }
        }
    '

If you don't allow `awk` in your "pure bash" then ofc this is not satisfactory. But it has the upside that the associative arrays are pretty explicit data structures (for the ordering and counts, respectively).

the point is to do a stable sort on (word, line number) lexicographically, then when we do "uniq" we can take the first line number.

In contrast to the "we need a frequency table" idea in the article, this solution trades off memory by transferring all the line numbers in the stream. This is very much in the spirit of the infamous McIlroy/Knuth "bakeoff"[1] -- tradeoff some efficiency (via extra book-keeping or sorts) in return for composability.

Agreed, very neat.

[1] https://homepages.cwi.nl/~storm/teaching/reader/BentleyEtAl8...

> If you've made a mistake once you're likely to make it again, so leave a note.

In my experience the comments behave as a form of prompt injection. The llm makes a conceptual mistake, writes it in a comment, and now subsequent agents make the same mistake!

IME yes that’s basically it. Other features haven’t really been significant value add for me. Some of the keybindings are different in minor ways. It has some mouse support but I have found that it doesn’t work well with certain apps/selections (eg: less).

It’s fine.

When running many agents something like the “idle/working workstreams” gutter is honestly helpful though.

The “10 principles” are about 1/3 of the way down the very repetitive, haphazardly organized page (interspersing test results, methodology, and yes, those principles).

Seems like slop.

> kiss goodbye to any notion of being able comprehend existing code that's not written by you (until llms arrived).

In my experience it takes a while (<=3 months) for folks to become proficient when they see an alien dialect of c++. That may sound totally unacceptable to you (fair). Cpp is also a “big tent” language in that it is genuinely multi-paradigm.

I think LLM’s might help, but sometime they hurt too (confidently/persuasively wrong analyses). The gain is large for small/trivial contributions. For changes that require genuine understanding, I’m not sure (large error bars personally as to whether the sign is even positive).

In general, it seems HN does not like to read llm-generated articles. I ran into this myself when using an llm to edit some stuff I wrote.

At the time, I found this a bit irritating, but with a few weeks time I see the merit. The informational content tends to fall into “derivative” territory when LLM’s write stuff. And people are here for novelty and some socialization.

Also LLM prose seems optimized for engagement rather than concise communication. Takes longer to sift through linguistic boilerplate to get to the point. (The quoted bit being a case in point)

I'm not sure about whether this is a bottlenecking step in applications, but even so, is it interesting to ask which parts of this are gpu-friendly? That is, is there a (sparse) matrix representation which is used in gpu's? And does it make sense to carry through the dag/tree construction as a sort of "prep" step (on cpu or gpu)?

The initial plain/dense algorithm looks pretty straightforward, but not sure about the tree construction.

This feels like a data scraping honeypot...

It's possible the image you uploaded contains geographic coordinates.

EDIT: this is exactly what happened with my image upload, for example

> Honestly this is way more appealing than fighting mergerfs when you just want explicit disk placement. Doctor + prune for orphaned symlinks is exactly what you'd need to keep things sane over time.

That's the hope!

> Saw it's written in Zig, how's that been for this kind of systems tooling?

Zig has been pretty fine. It could have just as well been done in C/C++ but as a hobby thing I value (a) fast compilation (rules out building stuff in C++ without jumping through hoops like avoiding STL altogether) and (b) slightly less foot guns than C.

The source code itself is largely written with LLM's (alternating between a couple models/providers) and has a bit of cruft as a result. I've had to intervene on occasion/babysit small diffs to maintain some structural coherence; I think this pretty par for the course. But I think having inline unit tests and instant compilation helps the models a lot. The line noise from `defer file.close();` or whatever seems pretty minor.

Zig has pretty easy build/distribution since the resulting executable has a dependency on just libc. I haven't really looked into packaging yet but imagine it will be pretty straightforward.

My one gripe would be that the stdlib behavior is a bit rough around the edges. I ran into an issue where a dir was open(2)'d with `O_PATH` by default, which then makes basically all operations on it fail with `EBADF`. And the zig stdlib convention is to panic on `EBADF`. Which took a bit or reading zulip+ziggit to understand is a deliberate-ish convention.

All this to say, it's pretty reasonable and the language mostly gets out of the way, and let me make direct libc/syscalls where I want.

NFS -- very slow reads, much slow than `cp /nfs/path/to/file.txt ~/file.txt`. I generally suspect these have to do with some pathological behavior in the app reading the file (eg: doing a 1-byte read when linearly scanning through the file). diagnose with simple `iotop`, timing the application doing the reads vs cp, and looking at some plethora or random networking tools (eg: tcptop, ...). I've also very crudely looked at `top`/`htop` output to see that an app is not CPU-bound as a first guideline.

ZFS -- slow reads due to pool-level decompression. zfs has it's own utilities, iirc it's something like `zpool iostat` to see raw disk vs filesystem IO.

RAID -- with heterogenous disks in something like RAID 6, you get minimum disk speed. This shows up when doing fio benchmarking (the first thing I do after setting up a new filesystem/mounts). It could be that better sw has ameliorated this since (last checked something like 5ish years ago).

> that was with success on the first try of the first round (which is very rare).

This very much depends on the patient history (age, cause of infertility, …) and the clinic. Live births per intended retrieval can vary from 10%-60% conditional on the above.

I can’t tell if this is a genuine quote or not. Can you provide a citation?

(I think something like this comes up in the Phaedrus)

I personally am getting better results with codex recently. Claude ($20 plan) honestly comes across as a total ai slop turd of an app (unreliable, frequent incidents, burns through the token after 2-3 prompts that just clinfinite loop doing nothing). Codex will iterate much faster.

Agreed.

LLM’s are fundamentally text generators, not verifiers.

They might spot some typos and stylistic discrepancies based on their corpus, but they do not reason. It’s just not what the basic building blocks of the architecture do.

In my experience you need to do a lot of coaxing and setting up guardrails to keep them even roughly on track. (And maybe the LLM companies will build this into the products they sell, but it’s demonstrably not there today)

Like offsetof[1]?

[1] https://en.cppreference.com/w/cpp/types/offsetof

This is addressed in the article:

> Turns out, it doesn’t matter that much where your first offer is from, or even how much they’re offering you. Just having an offer in hand will get the engine running.

> If you’re already in the pipeline with other companies (which you should be if you’re doing it right), you should proactively reach out and let them know that you’ve just received an offer. Try to build a sense of urgency. Regardless of whether you know the expiration date, all offers expire at some point, so take advantage of that.

Anecdotally, I have seen this work many times to great effect.

See “Import a Git Repository” at https://nest.pijul.com/pijul/pijul

The trouble for me is the text flashing in and out on top of the graphics and the rescaling of the images by scrolling.

If the text was above/below the images (like a python notebook) and the images were static, I imagine I would like it a lot more.

> Can I just open an issue in the TypeScript repo for this sort of thing if I have a concrete suggestion?

Yes. There are even issue templates to guide you through writing an issue that the team will be able to address effectively.

Not sure about your second point. Let’s consider an oversimplifying example where population is homogenous in an area/nation. If 50% of the land is unpleasant, then 50% of the population will live next to unpleasant stuff. If only 20% is unpleasant, 20% will love, saving 30% of the population.

Managing a landfill/sewage plant can be worthwhile.

Imagine the following three enforcement schemes for taking down a post due to reports:

* if your post gets reported 10 times, it gets taken down

* if your post gets reported (# of followers / 10) times, it gets taken down

* if your post gets reported (# of followers * 100) times, it gets taken down

Which of these are fair in your opinion? For an account with a huge # of followers, the last one effectively means their posts can't be taken down.

It seems a system like XCheck is a step function where at a certain point, you get exempt from certain checks altogether.

The "equality" here could refer to each account's potential to go through the vetting that would give them exempt status.

==============

Maybe this deserves a separate response, but another way to think of this is to compare it to income taxes. There are different income brackets that affect your marginal tax rate in the US. Is it equal for everyone to pay the same dollar amount in income taxes? The same rate? A progressive rate? Are people treated equally under the law in all these cases? In none of them?

That’s playing a bit fast and loose with the facts.

The timing of his announcement was suspicious: https://m.youtube.com/watch?v=CH55WpJxF1s

And he’s gotten some flak from a high profile Republican as well: https://m.youtube.com/watch?v=7kT_80NaS6A

HN is maintained at least in part to promote YC startups and the reputation of YC itself. The monetization is indirect. (Maybe some posts are sponsored? I would be mildly surprised.)

This suggests the incentives for YC are more aligned to users’ goals than, say, Reddit.

Amazing! Does anyone know of a comparable toolkit for quick UI’s (gui or tui) in the linux/bash ecosystem?

Calculus is useful to make rigorous statements in stats. How do you relate the pdf/cdf of a continuous probability distribution without calculus?

Agreed that “memorize rules” is not a great learning experience for students… but it is easy to present.

The author addresses the claim about “thinking better” in TFA.

How is this different from getting a notification in gmail?

A bit ironic to find this article by way of casually browsing HN.