Hacker News Reader

bluefoxon Emacs Lisp Readable Closures (2013)

Yes, it is unfortunate. Information loss on the internet is not limited to CL, however, and many of my bookmarks became stale over the years. When I encounter a "treasure trove" of information, I make sure to archive it on my machine (and ultimately on backup hardware). Sometimes I put it up on sites like GitHub.

bluefoxon Emacs Lisp Readable Closures (2013)

I believe you can find it via archive.org, but you should probably ask Paul Khoung (pvk.ca) to push it to GitHub or something.

bluefoxon Emacs Lisp Readable Closures (2013)

Like I said, the mapping from tags to forms is available and you can serialize that as well, if you wish. Using a tag is useful, as it makes for a compact serialization when creating many closures of the same function. With regards to security, you would want to attach an authentication tag that you can verify prior to deserialization. Common Cold comes with an example of a Hunchentoot handler that compresses and encrypts the serialized continuation representations.

bluefoxon Emacs Lisp Readable Closures (2013)

You can serialize closures (and continuations) in Common Lisp using Common Cold. The serialized representation of a closure contains a tag instead of the actual code, but the forms are also available in case you need to serialize them as well.

  CL-USER> (write-to-string
            (let ((y 4))
              (common-cold:slambda (x)
                (* x y))))
  "#.(S:F '1 '(4))"
  CL-USER> (funcall (read-from-string *) 3) ;; * here means reference to the last returned value
  12

bluefoxon Janet – a Lisp-like functional, imperative programming language

Simply false. For example, LISP 1.5 manual had this definition for UNION:

  (union (lambda (x y) (cond ((null x) y) ((member
         (car x) y) (union (cdr x) y)) (t (cons (car x)
         (union (cdr x) y))))))

It had a MAPLIST (today called MAPCAR):

  maplist[x;fn]=[null[x]->NIL;
                 t->cons[fn[x];maplist[cdr[x];fn]]]

Or APPEND:

  append[x;y] = [null[x] -> y; T -> cons[car[x]; append[cdr[x];y]]]

Et cetera. Sure, it also had, say, NCONC. But it had these operators and style from the beginning, not surprisingly, as Lisp came from lambda calculus.

bluefoxon The Problem with Macros

Remember JavaScript before "async"? Lots of boilerplate there. You had to wait until some committee decided to incorporate it into the language.

So "modern" languages without macros have such patches every now and then. Still, it's easy to find boilerplate in programs.

The reason is that a lot of boilerplate is specific to the program's domain, and you're left with cumbersome syntactic patterns and no tools to abstract them.

So yes, you need to learn how to write macros. But, assuming good taste, the simplicity is in their use, not their definition. It's a good tradeoff because macros are used much more often than they are defined.

By the way, the language introduced by a macro often allows arbitrary Lisp code to be mixed with it. The example did not demonstrate this, and that's why you had an easy time thinking up a non-macro alternative (which still has some unfortunate implications, like needing to interpret at runtime).

bluefoxon Mozilla to put ads in Firefox address bar suggestions

Good thing I stopped updating Firefox a long time ago. "But, but, security!" I hear you scream inside. Well, JS disabled by default pretty much covers it. "But, but, security!" I hear you whisper to your fingers, ready to take down my HN comment. Well, I'd rather live "dangerously" than be a MozillaCorp hostage. If security is the only reason to update, no wonder bugs, security updates, and alarmist propaganda are pushed to users in full force.

bluefoxon Common Lisp

So what?

You can come up with something like:

    (from u in users where u.age > 18 select u.name)

It's a simple matter of programming.

bluefoxon Common Lisp

Yes, CFFI is the defacto standard, and has support for practically all implementations in use today. Nobody (but CFFI) uses the implementation-specific interfaces.

bluefoxon A search engine that favors text-heavy sites and punishes modern web design

This is a very cool project! Thank you.

bluefoxon NSO Group iMessage Zero-Click Exploit Captured in the Wild

The simple solution for those who are concerned about this is to use a dumbphone. It's simple, easily hackable, and most importantly does not promote a false sense of security.

bluefoxon Improving Git protocol security on GitHub

It will invalidate all existing git:// links to repositories hosted on Microsoft GitHub, in the name of "security".

bluefoxon GitHub Copilot

I don't understand fascination with bullshit machines.

While they may be useful in propaganda, state or commercial, I'm not sure why Microsoft GitHub would find it useful to generate volumes of bullshit source code.

bluefoxon ML Beyond Curve Fitting: An Intro to Causal Inference and Do-Calculus (2018)

Do you feel it was a waste of time?

BTW I used Xidel some years ago and it was great, so thanks!

bluefoxon How did Replit respond to this blog post?

IANAL, but if Radon is reading this: in such situations, don't discuss things over the phone like the other guy proposed (you can see it was a mistake, with him "quoting" stuff you may not have said or that were taken out of context), only in writing.

bluefoxon A Project of One’s Own

It's a good start for an essay, and there was even a paragraph getting close to the crux of the matter (about projects of the kind that doesn't necessarily make money). The problem is that of the starving artist, and a solution, or a big step towards a solution, is universal basic income. This kind of safety net would let us at least partially revert back to the carefree ways of the child and give us the freedom to work on our own projects without the fear of and actual possibility of falling into destitution.

bluefoxon Symbolics Lisp Machine demo (2013) [video]

Not exactly a Lisp machine, but check out Medley: https://github.com/Interlisp/medley/

Lots of fun...

bluefoxon Minio Changes License to AGPL

I'm not sure it's "illegal"... but according to [0] the Apache license is subsumed by AGPL3, so I think this means they can add AGPL3 code freely and the result still makes sense to lawyers. They may also relicense code fully authored by themselves as AGPL3. Perhaps it may be even possible to relicense contributor code given these specific licenses? I don't know. They can push to that repository, so it's their prerogative to add whatever. Of course, people could use their own forks without these commits, not upgrade, etc.

[0] https://www.gnu.org/licenses/license-compatibility.en.html

bluefoxon Signal adds a payments feature with a privacy-focused cryptocurrency

So Signal is now a payments app? Really? Installed Element and will be phasing Signal out of my life.

bluefoxon Lisp-stat: An environment for Statistical Computing

Your comment makes it seem like Tierney et al. only authored XLisp Stat, and you wrote a "reboot in Common Lisp" called Lisp Stat. That is not the case.

Tierney et al. authored both XLisp Stat and Lisp Stat. You took the code and modified it. There's nothing wrong with that, but you also present this modified code as Lisp Stat, a project "inspired" by XLisp Stat. You gave this code a new license, too.

I wonder what's the purpose of using "Lisp Stat" and "Symbolics" as project/company names, if not to mislead others. If that was not your intention, consider being more explicit about what is authored by you, and what is authored by others, and avoid using the same name for your project as that of the historical project.

bluefoxon Lisp-stat: An environment for Statistical Computing

It has already made some damage. Now this website is the first result you get when you type "lisp stat" in DDG.

Hopefully when the joke is over, the owner will instead redirect to Tierney's site or replace this nonsense with something more respectful.

bluefoxon Lisp-stat: An environment for Statistical Computing

Re-read my comment.

bluefoxon Lisp-stat: An environment for Statistical Computing

http://homepage.divms.uiowa.edu/~luke/xls/xlsinfo/xlsinfo.ht...

This is Lisp-Stat.

This website looks like a (sad, tasteless) April Fools' joke.

bluefoxon Writing Small CLI Programs in Common Lisp

> I don't think I ever heard anyone calling Prolog a Lisp though.

I guess we can agree that it's not a sufficient condition, but from my selection of languages you may consider that maybe I meant it as a necessary condition.

Another interesting separator is: does it include "Lisp" in its name? Scheme and Dylan don't. Maybe people don't use "Lisp" in the name to indicate that they intend the language to break away in some way from the Lisp tradition. In a similar way, Racket broke away from Scheme tradition, for example.

Kent Pitman, in his "Lambda the Ultimate Political Party" article, wrote that people have been writing programs to help transition code written in the older dialects to the new dialects. The fact that it's doable without expending too much energy also suggests close relationship. Some months ago I wrote some <100 lines of code, consisting mostly in a bunch of macros, to make a program using Flavors work on Common Lisp with CLOS. Are the people using Clojure, Janet, etc. doing this? Can they pick up an old program written in another Lisp dialect that's close to them and, with not too much fuss, make it run? Which dialect would that be?

bluefoxon Writing Small CLI Programs in Common Lisp

Some languages that have CONS cells: Common Lisp, Emacs Lisp, Scheme, Dylan, Maclisp, Interlisp, AutoLisp, Lisp Machine Lisp, EuLisp, ISLisp, *Lisp, LeLisp, Lisp 1.5.

Some languages that don't have CONS cells: Clojure, Janet, Julia, R.

Of course, that is only one attribute, and may not be the most important one, but it's an interesting separating line.

If you describe each language by a set of language feature attributes, you can perform some easy computations (e.g., Jaccard distance, or some clustering) to get more clue about how related these languages really are. I think Janet wouldn't fare so bad in relation to obvious Lisps, so I'm not strongly opposed to calling it a Lisp.

bluefoxon GitHub refuses to help me unsubscribe from thousands of notifications

Yeah, my first thought was to use some XTEST hack.

My next one was "does Wayland have something like that?"

Quick search brings up uinput, a kernel module...

Sorry, ddevault :)

bluefoxon Review: The Book of Why

You seem to read too much into my comment, and make it into something partisan. I'm not interested in that debate. My thoughts about statistics and probability were there before I read Pearl's book. Pearl mentions potential outcomes in his book.

bluefoxon Review: The Book of Why

I've read this book twice. The first time, I enjoyed it, and as I read it I felt that I understood the gist, at least intuitively. Similar to what you describe, my view was always that statistics is a bunch of tricks, and probability is much deeper. After reading this book, I read another book, a technical book about probabilistic graphical models. As I read the book, I implemented most of the algorithms. I also had to read a bunch of papers from the 80s and 90s to do that. I then decided to read this book a second time, and now I really came to appreciate Pearl's points, and can see why statistics (and probability...) are insufficient, and the need for his do-calculus. I've also been reading much of his 1988 classic, though not done with it. While I'm not there yet (still implementing more papers, and not read his Causality book yet) I can see how his proposed calculus and the work of his students in that area can help do the things he describes in the last chapter. So, the book can be interesting to lay people, and it may entice them to learn more. I think this is the book's purpose, and therefore that it is a success, at least with me.

bluefoxon Python 3.10.0a6 is available, now with 100% more pattern matching

Can't wait to make my programs incompatible with all previous versions!

bluefoxon What I Worked On

Graham says Arc had to be frozen because other programs depended on it. Indeed, much of Lisp language design came about by demands of the applications that used it.

So, is Bel finished or still changing? Are there other programs that depend on it? If Bel is developed "axiomatically", maybe not programs, but more thinking about the theory of computation may be its driver of change.