PuercoPop

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>)

0] 2

    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

Why? There isn't a centralized message queue. Its just everything uses the same abstraction and is presented as filesystem or a file.

Another alternative for shell scripting in CL there is https://www.cliki.net/cl-launch

> doesn’t even say that a byte is 8 bits

That is likely due to the fact the historically that wasnt the meaning of the word. There is a reason the RFC for IP uses octet to refer to 8 bit bytes. Another example of an old document that doesnt use byte to refer to 8 bit bytes is the Common Lisp standard.

So even though the current definition of byte is 8-bits the fact that the C standard uses the old definitiom is most likely because it is a document that can be traced back to an era were there was more diversity in the hardware architectures in common use.

Yes, but they are an 'in-process' form of code generation. The distinction is important. Especially when you are extending the system on the fly.

A lot of the pain regarding JS build-systems could be avoided with macros (and reader macros/a customizable reader). Babel is literally macros + a reader.

> The main difference is that it chose javascript instead of lisp as its universal language,

That is not the main difference. The main difference is that Emacs can be extended on the fly. While VS follows the traditional plugin approach.

For VSCode to the have the same kind of extensibility it would have to allow opening an inspector on the _running_ instance. Click an element, jump to its source edit the source on the fly and have that change persisted. Or allowing your settings to patch (which by the nature of ES6 modules is not something you will be able to do).

The on the fly extension is crucial for quick QoL improvements to your workflow. You can spend 5 minutes writing a function instead of having to setup a project/plugin to something as trivial as say, copying a .env file and updating some values when you create a [git] worktree.

> Which is exactly the reason why... VSCode is winning the editors war.

The main reason why VSCode is 'winning' the 'editor' wars is because Microsoft is spending tons of money to build a great product. Emacs, vim, and other open source projects can't compete as they don't have nearly the same amount of resources. They have healthy communities and are thriving FLOSS communities but people who are scratching an itch won't be writing monthly tours of new features like https://code.visualstudio.com/updates/v1_52 f/e.

> ask anyone who had to maintain bash/awk/perl labyrinthine assemblies...

Text in Emacs is richer than plain-text. You have overlays to annotate it with metadata, text properties, you can attach callbacks to it, etc. It is only at the boundaries that you have to resort to plain-text for interoperability purposes.

This means it is easy to inter-op with CLI utils but present a richer, more powerful interface. Ej. dired uses ls.

I wouldn't say it has no purpose existing, but it is the path less trodden so you'll run into more issues.

I doubt there is lots of JS code in NPM which is independent of either Node or browser APIs when including transitive dependencies. But that is besides the point. I said no NPM as in no access to NPM. Not just no node APIs. Let's say you install a library from npm using either npm or yarn. Its downloaded into the node_modules directory. how would you require it as an es6 module?

Another poor design from the GNOME team. How is the JS code in the gnome extension distributed? It is embedded in .so files! so much for hackability. (I learned this when upon a fresh Ubuntu install I run into bug in my gnome shell version which was a one liner fix but I couldn't find the file in the backtrace.)

In principle it was the right decision. Opening an application shouldn't take over the root window. The was specially obvious for people who don't use gnome but use nautilus. The problem is that as you mention "The Gnome shell desktop extension is not as robust as nautilus"

> JS as the extension language

Just to reinforce why it is a bad decision. One of the selling points of JS is that vast amount of libraries available to you. But in GNOME's case they use spider-monkey as their JS engine, which means that although JS is the extension language not using node means _no_ npm (or node APIs like the fs module)

They are not talking about manual triggers. afaik, and correct me in I'm wrong, I have to write a commit and push yaml file to the repo to be able to run the pipeline. On srht's builds on the other hand I can submit a yaml file by itself to start a job. That way when setting up the build you don't have to go through the whole edit/commit/push cycle.

Yes, there there is. You are looking for t is called Cappuccino. One of its developers literally wrote a rant about with the exact same complaint. It requires a significant buy-in though, it is written in another language, objective-j.

- [0] https://www.cappuccino.dev/

- [1] http://web.archive.org/web/20140326112535/https://randylueck...

- [2] https://news.ycombinator.com/item?id=5415585

> "hostile fork" -- the entire notion is nonsensical.

It is not. It is based in experience. See the xMule/aMule fork. A hostile fork is when the fork project starts bad-mouthing the original project and its maintainers.

The notion that forking is by itself hostile is non-sense.

You can use multiple #langs, in separate files. The name collision is unrelated to the #lang of the file. It is handled by the module system.

It is also ~20 lines in CL http://lisp-univ-etc.blogspot.com/2013/01/real-list-comprehe...

But list comprehensions suffer from the same problem the author is taking about, they don't compose. Its even worse than CL remove-if variant, where one can reify the filter into a function that can then compose.

> that's a non-starter for heavy games because you need to be able to control & predict the performance spikes that GC creates

Real-time garbage collectors are a thing. Maybe not common, but they have existed for at least 20+ years.

Also if you want a menu of places to go Emacs has bookmarks for that.

The Unix CLI is most definitely a REPL. But it is a system-level REPL. So instead of running functions you run programs. You can't interactively develop a program in the UNIX CLI. Especially not in Python, JS, Ruby, etc. You can try to establish a REPL like flow in the CLI, by using a watcher like entr and doing something like $ cat test-input.txt | python ./my-script.py but the granularity of this approach is too coarse for the programming _language_. It is the ideal granularity for orchestrating shell scripts and CLI programs.

For the record, CLJS does count. And the tooling although painful is on par with the one found in JS (webpack). Maybe even a little less painful.

But one problem that ClojureScript avoids by virtue of being a 'hosted language' and not having a spec is having to implement its own numeric tower. Numbers can just be floats and move on.

CL mandates integers. Not just fixnums, like WebASM provides, but bignums. As well as rationals. That is a lot of code your run-time will have to provide.

iirc Whalesong (the Racket to JS implementation) bundled a numeric tower that implemented integers using strings).

Can someone who has used this featured give an example of what they used it for and how it improved their build system?

The author has stated in Reddit that their goal is able the insta parse library.

Several Common Lisp implementations do it, ej. SBCL. Why do you think interactivity is opposed to compilation?

I'm not too familiar with Julia but afaik it compiles the forms entered in the REPL as well.

> I'm just pointing out that there are millions of developers that won't use

You are just stating it. Without any reason. One can't argue against a statement, you have to provide reasons behind your statement for there to be an argument.

For example: "Asking people to use an editor where C-c doesn't copy and they have to relearn the keybindings is an unnecessary barrier of entry". I would agree with that and note that as a stop measure they can use the mouse for most tasks so they can postpone learning Emacs until they have learned CL.

If you are on OSX CCL has an alternate IDE that's pretty good. Otherwise you can pay Lispworks or Allegro. Yeah it would be awesome if there were a multitude of IDEs, but people are not going to write IDEs for environments they don't use for free, it is unreasonable to expect that.

I've never heard people say 'it is unreasonable to ask people to use Android Studio to develop for Android' so I'm not inclined to agree that it is unreasonable to ask people to use a Emacs to develop for CL. Especially after Shinmera has gone to great lengths to package a pre configured version. I know of a recent lisper that just uses Emacs for CL without previous Emacs exposure. It is an unnecessary barrier, but not more than a hump.

You must visit different sites than me then. It doesn't happen even on a yearly basis for me. The last time it happened was two years ago on my bank's website. And that was due to poor coding practices on their part

The reason it is slow is not because it is written is Lisp but because of how it is implemented, primarily because it is a hobby project. Graphics are rendered on the CPU for example.

https://github.com/froggey/Mezzano/blob/master/gui/blit-x86-...

It _is_ linked to in their front page. The article is complaining about not finding documentation for the openssl command while literally linking to the front page that contains a link to said the documentation. They don't even have to Google, just read!

I agree that is nice idea but sadly only the JS server improves my experience compared to the alternatives, which is more an indictment on the JS toolchain than anything else. And even then its jump to definition leaves a lot to be desired. For example Robe jumps to a method inside Rails that was defined at run-time w/o any issue. Solargraph, even with experimental features enabled doesn't. I look forward to a future where language server implementations improve.

> return/if/while/break/continue actually work in Hylang. Common Lisp doesn't have these.

Don't know where you get your facts from, but Common Lisp certainly has those.