pooyamo

A harmonious comment about an impedance mismatch quickly spiraled into a galvanizing flow

Does any expert in the field know whether it is really the case that this intelligence we are seeing with frontier models is an "emerging" phenomena, only coming up when the architecture is scaled?

Like isn't it weird that the 1 million parameter model with the same architecture can't solve basic puzzles but suddenly the 1 trillion parameter can conjure up counter-examples for the Jacobian conjecture?

It's unintuitive since, to the best of my knowledge, one of the basic tenants of algorithm development was that you can't just brute-force your way towards a solution for some complex problems, e.g. naive sorting algorithms suddenly won't beat quicksort if you put more processing to them, but in the modern LLM scene it seems people are in a race to scaling up, experimenting empirically and hoping the same algorithm/architecture comes to a solution.

The LOOP solution could be written using DOLIST or DO forms too (likewise built-in):

  (defun calculate (instructions)
    (let ((result 0))
      (dolist (e instructions result)
        (destructuring-bind (operator operand) e
          (setf result
                (case operator
                  (add      (+ result operand))
                  (multiply (* result operand))
                  (subtract (- result operand))))))))
  
  (defun calculate (instructions)
    (do ((result 0))
        ((null instructions) result)
      (destructuring-bind (operator operand) (pop instructions)
        (setf result
              (case operator
                (add      (+ result operand))
                (multiply (* result operand))
                (subtract (- result operand)))))))

Zed team is writing their own in-house GUI stack [1] that leverages the computer's GPU with minimal middleware in-between. It's a lot of work short-term but IMO the payoff would be huge if they establish themselves. I imagine they could poke into the user-facing OS sector if their human-agent interaction is smooth. (I have not tried it yet though)

[1]: https://www.gpui.rs

>vscode fork

I wonder why they are not trying to fixup something based on their own GUI stacks like Flutter or Compose Multiplatform.

It seems only Zed is truly innovating in this space.

> MusicBrainz Picard

I don't think it can be used as a CLI tool. It's mainly a GUI app. I've tested it in the past and it works fine too.

It's a good tool. However, last I checked, it was not possible to run it in a one-shot stateless fashion, like, passing it a list of music files so it auto-fetches album art, lyrics and updates the very same input files.

Do other editors and IDEs bundle-in these external language servers? I don't think so, unless they are specifically tied to the language like Eclipse or PyCharm

Binaries for dynamic libraries of tree-sitter (usually compiled with C compiler) would be smaller than that. For example this [1] .so bundle for 107 different grammars is ~137 MiB.

Unless by "compiled in", some in-lining of the C code into Rust codebase is meant.

[1] https://github.com/emacs-tree-sitter/tree-sitter-langs/relea...

Can you create and run a service that starts when phone is turned on, with a PWA app? Usecase is a backup daemon.

Thanks! Fixed that example. (In fish shell that I use, it didn't need those quotes that's why I didn't catch it)

>there are still missing expressions, such as "add up", "a couple", etc.

Googling "pronounce add up" does not show the google short answer box for me. Aside from that, the heuristic method I used may miss some words since it's not quite clear to me how the naming scheme works in that static stash. The 2024 stash is more straightforward but as I mentioned in readme, it sounds synthetic to me.

> I guess this is for when you're knee deep in terminals?

One can use it directly in terminal or it can be used as a dependency tool in other scripts similar to the way other UNIX tools are used. For example I use it as a pronunciation player in my dictionary dict-master [1]. It's a shell script too.

Another example (run two times so it uses the cache the second time):

  echo this unix pipeline is poor man text to speech | xargs -n 1 gsay

[1]: https://github.com/pvonmoradi/dict-master

Some stuff like LAPACK and BLAS fit your bill. They are math libraries written decades ago and still in use.