PuercoPop

It is not, Hanami is a batteries-included framework. It not even a pay-as-you-go framework like Pyramid. The equivalent of Flask in Ruby land is Roda+Sequel.

but I want durable messages and a mobile client.

And IRCv3 has chat history to provide that. But https://snikket.org/ (XMPP) is more likely aligned with what you are looking for

The protocol is OCapN

http://ocapn.org/

It is likely you use Chrome or a browser that uses Blink for its engine and the OP uses a non-blink browser like Firefox. I use Firefox and I can cofirm since the last few months Youtube usability borders on usable

junit was not invented, it was a port from Smalltalk's SUnit, which was created on 1989, ~6 years before the first release of Apache. Yes, the extreme programming (XP) craze hadn't popularized TDD, but united testing as a practice already existed, even if only some communities.

Though I agree, that although not a technical justification, an explanation as to why there are no tests is because Apache HTTP is from the 90's. Not writing unit tests was par for course back then. Most FLOSS code bases in the 90s didn't have unit tests, let a alone a CI to run the test suite for each change. Adding tests later is hard. Though there are some tests under the test folder.

Recently saw this through https://discuss.systems/@pkhuong/114532017716618023 which summaries why this would be useful:

Flagging old live (i.e., potentially immortal) allocations is easier (https://github.com/backtrace-labs/poireau) and more closely matches the goal of identifying why the heap grows instead of entering a steady state.

Ej. Why is Sidekiq memory consumption growing over time.

wmii[0], it implements the acme window layout. But the interesting part is that it exposes its state as a file-system. The main loop is a shell script[1]. So BYO posible, fe here is a Ruby one [2]

[0] https://github.com/0intro/wmii [1]: https://github.com/0intro/wmii/blob/main/cmd/wmii.rc.rc [2]: https://github.com/sunaku/wmiirc

The original hy annoucement makes it clear that they embed a Lisp by compiling with Python bytecode. You can see it in the following video about the 16:25 mark

https://m.youtube.com/watch?v=1vui-LupKJI

That is because I only mentioned them, didn't explain them.

Kara-cancel is a mechanic that lets you extend the range of your moves, in 3s is used for throws.

So the input for throws in 3s is lp+lk. Now, what happens if while one is trying to press the buttons at the same time they press one slighty before the other? A move will start to come out and then you can't throw because you are doing another move. To make it easier to input throws, devs made so that _any_ move can be canceled into a throw in the first 5 frames of the move. 5 frames is 5/60ths of a second.

Separate to that, some moves move the character forward. Ej. Chunli's HK. So people figured out that if you press a move that moved your character forward and then canceled that into a throw you can extend the effective range of your throw.

Mind you doing this means pressing a button 83 milliseconds before the other one. Which is of course not something you can do by thinking about it, instead you learn to position your hand in a way so that when you move it down together one finger lands before the other two. The name kara-cancels comes from the Japanese word for empty, because you are canceling a move that never came out.

Now I don't know the history, whether the mechanic was first found in 3s and then in SF2T or not, but it is an example of a mechanic intended to ease the input of something being used to expand the toolkit of a character.

V-cancel (not sure if that was the name ppl used for it, didn't play sfa2) refers to the fact that in sfa2 the number of frames to go from standing to downblock is more that the number of frames a character needs to go from standing to a low attack if the character is in v-ism. This means that if two characters are standing next to each other and one activates their v super, they have a guaranteed hit.

This was first used by Ricki Ortiz in a tournament setting in a finals and that is how it became wildly know. The story of it was documented in Sirlin's Play to Win book, which is how I learned about it. https://www.sirlin.net/ptw

Also, I would love for this guy to do a deep dive on the SC:BW approach to balance, which is map-based rather than based on traditional unit-based balance changes. This way the community is effectively able to balance the game themselves.

Yes, that it something really important that the modern landscape of competitive gaming lost and the frequency of patching increasing. Not just in BW, older fighting games, especially those arcade based ones, people found ways (which sometimes blur the lines between exploit or technique) to keep pushing the bounders. Things like Kara-cancels in 3s, were one is using a mechanic meant to facilitate the throw input to extend the range of the throw. Or wave dashing. It is wild how even character tier lists changed in the original SmashBros 64.

And also how people adapt to this meta changing discoveries, like the bisu-build in BW or when Ricki Ortiz unleashed v-cancel in sfa2!

For what is worth in nix after the code is downloaded the code is built in a sandbox without network access. So one does have a viable alternative for Rust.

And is true that most package managers for popular language allow arbitrary code execution during the install process. That is how husky adds git hooks to the developers machines.

For example in Ruby I need to patch the Kafka gem, karafka because it downloads, builds and stores librdkafa.so in the gem's directory.

I understand that this as well as the husky example comes from a desire to make developer lifes easier but I'd rather we erred on the side of caution. Making sure that software builds without access to the network and without being able to modify your system (ej. Adding files to $HOME)

is arguably the most powerful debugging experience available for any programming language.

The sly debugger is better than most debuggers, but calling it the most powerful debugging experience is a stretch. Just try the debuger in a Smalltalk implementation (Squeak/Pharo/Cuis)

I use project.el instead of projectile but yeah that is exactly what I do. It is only a couple of lines.

https://github.com/PuercoPop/.emacs.d/blob/9d0b99d332d619fe3...

You are thinking of darcs, that is the one that was written in Haskell. Although Darcs is more related to pijul than to git

No, the included demos have examples for a analyzing Ruby (ActiveRecord) and Java. There was a paper a while back about moldable development where they showed a Python debugger.

That is what I was trying to say by

Other than using version control to determine what are the sources of the derivation

I don't think that defaulting to using git to list the sources when inside a git repo means that it is tightly coupled to git. If one doesn't want to commit/stage the flake files in the repo one can do `nix develop .` and it works . It will take a little longer because it will copy the entire directory to the store iiuc.

I use nix with flakes, have written a couple of flakes day to day use. I am not a nix power user. But based on my current understanding this statement seems incorrect

Flakes are tightly coupled to Git.

How is it tightly coupled to Git if it supports Mercurial out of the box?

Other than using version control to determine what are the sources of the derivation, what does flakes lean on version control?

Amarok was the first app in Linux that was better than the Windows counterpart. My non-technical friends would ask how could they use it. It was the killer app for the Linux Desktop at the time.

Also, dcop is probably the best GUI automation tool I’ve used.

Everytime I have to use dbus from the CLI I think to myself, dcop died for this?!

To me the best GUI automation tool (in Linux at least) was Kommander, another KDE app that didn't survived the KDE3-4 transition. A pretty decent 'low-code' tool that unfortunately didn't make it to KDE4.

I used KDE4 up to 4.2, when it supposedly 'got good'. It wasn't bad by any means. But KDE3 was better.

a fork of a DE from 2002

Not 2002, 2008. Trinity was forked after KDE3 was EOL.

I'm curious if they are keeping DCOP alive or have they embraced dbus?

It is like printf to stderr and exit(1)

I knew that as RICE: Rest Ice Compression Elevation. I remember seeing in in medwiki which was a wikipedia curated my doctors that Standford tried to launch iirc.

The plumber is cool, it’s like “what if xdg-open was good actually”

Yeah, plumber is way better than xdg-open in that it is extensible and it can be invoked from a script more easily via 9P. Given how hard it to customize xdg-open, I use a xdg-open wrapper that gets the caller's name using procfs and sends it to the plumber service. That way I can open links on a different browser depending from where the link was clicked/opened from .

  #!/usr/bin/env bash
  # this is named xdg-open and placed in a directory that is
  # before /usr/bin in the $PATH

  PARENT_COMMAND=$(cat "/proc/$PPID/comm")

  case "$PARENT_COMMAND" in
      slack)
   /home/puercopop/src/plan9/bin/9 plumb -s slack "$@"
   ;;
      zoom)
          /home/puercopop/src/plan9/bin/9 plumb -s zoom "$@"
   ;;
      *)
   /usr/bin/xdg-open "$@"
   ;;
  esac

  type is text
  src is zoom
  data matches 'https?://.*'
  plumb to firefox-trunk $data

  type is text
  plumb to xdg-open $data

Why wouldn't you want the lint error to be highlighted right as you type the code?

Why do you think you need to involve an LSP for that?. ESLint, as most linters, can take their input from stdin. That is exactly how the eslint-flymake[0] works. Lint on buffer contents, not file on disk. No JSON RPC involved.

0: https://github.com/emacs-pe/eslint-flymake/

Eglot was written with the explicit goal of landing into Emacs. Which is why from the start it required copyright assignment for non trivial changes.

Landing into Emacs core was never a goal for lsp. So it wasnt a choice between eglot vs lsp. It was eglot, yay or nay.

Why would one want to run eslint through an LSP? Using flymake it call the CLI works just fine and is more direct.

The author did a great job explaining the motivation for Aurae. I fully agree that there should be tighter integration between k8s and the init system on each node. But thinking of the desktop, having a gRPC server on PID 1 seems unnecessary. dbus is the RPC used by systemd. Is there a reason why gRPC instead of dbus[0]? Or is the goal of Aurae to replace systemd in the cloud/server Linux space?

[0]: dbus normally is used over a unix socket but afaik you can use dbus over a regular tcp socket

Because many inputs map to that hash (the hashing function is surjective instead of bijective). People re-use passwords all the time. If the hash leaks it will only affect the particular service.

Literally anything? Never let me go? The wizard of Earthsea? I have a hard time seeing how can anyone not agree with the parent's assessment. Foundation is interesting because of the idea/plot it presents. But the characters themselves bring little to the table. In a way the Foundation series is a good piece of conceptual art, but sci-fi novels.

I would argue that 1Q84 (don't read it!, it sucks) is the exact opposite. Interesting characters but lacking an overarching setting/plot.

Does it? Asking for a value when encountering an unbound variable is a default restart

    $ sbcl
    This is SBCL 2.1.1.52.HEAD.321-f8a57bcca, an         
    implementation of ANSI Common Lisp.
    More information about SBCL is available at 
    <http://www.sbcl.org/>.

    SBCL is free software, provided as is, with absolutely no warranty.
    It is mostly in the public domain; some portions are provided under
    BSD-style licenses.  See the CREDITS and COPYING files in the
    distribution for more information.
    \* (\* x x)

    debugger invoked on a UNBOUND-VARIABLE in thread
    #<THREAD "main thread" RUNNING {1001860103}>:
      The variable X is unbound.

    Type HELP for debugger help, or (SB-EXT:EXIT) to exit from SBCL.

    restarts (invokable by number or by possibly-abbreviated name):
      0: [CONTINUE   ] Retry using X.
      1: [USE-VALUE  ] Use specified value.
      2: [STORE-VALUE] Set specified value and use it.
      3: [ABORT      ] Exit debugger, returning to top level.

    (SB-INT:SIMPLE-EVAL-IN-LEXENV X #<NULL-LEXENV>)

    Enter a form to be evaluated: 3
    9
    \*

Vivek Haldar did an overview of the paper this week: https://www.youtube.com/watch?v=_o9CgLjo9Kk