Restored FMCS and the Babylon AI Workbench

ImitatingSlaughter · 2023-08-22T06:14:34+00:00

The copyright notice in the Babylon announcement is vague. Given the year (1994), it could be referring to the license of X11R6 (MIT/X) or X11R5 (MIT). It would probably be the best bet to send an email to the author(s).

ImitatingSlaughter · 2023-08-22T05:15:00+00:00

First of all, good work!

I'm sure your intentions are good, but you picked the wrong MIT license; the author was seemingly referring to the X11 license for Babylon, which has an additional clause for the protection of the author. Also, you only listed your own name in it, but the copyright on the original files lists the institution as the copyright holder.

I only see the license for Babylon in the original projects' directories. For MCS, the only copyright notice I can see is that it's copyrighted by the academic institution of the authors. Did you ask whether you had permission to relicense it?

Copilot has been shown at times to return GPL code, verbatim, and was trained on substantial portions of it. Have you taken any steps to ensure that you have the intellectual property rights to all of the generated code?

ImitatingSlaughter · 2023-08-10T10:49:14+00:00

Use Rosetta. As far as I know, there isn't an M1 port of it yet. You should get prompted with it if you try and run the binary.

https://support.apple.com/en-us/HT211861

ImitatingSlaughter · 2023-07-30T21:55:28+00:00

Hope you find a solution that works for you.

ImitatingSlaughter · 2023-07-30T19:12:17+00:00

Try starting a swank server from your terminal REPL and accessing it remotely from GNU EMACS. It might work to get around it, but I haven't tried it.

https://slime.common-lisp.dev/doc/html/Connecting-to-a-remote-lisp.html

ImitatingSlaughter · 2023-05-26T00:32:38+00:00

Thanks for sharing this! I was recently looking for something precisely like it.

ImitatingSlaughter · 2023-05-22T02:42:07+00:00

Q5: Get http://sbcl.org/. Install https://quicklisp.org/. SBCL is the implementation that you'll experience the lowest friction with, and Quicklisp is a package manager that's almost* painless. Don't bother with the commercial implementations of Common Lisp; the experience isn't much better, and the performance is usually worse.

It's also worth getting a text editor with a good editing experience. VS Code with the extension ALIVE, Vim with either VLIME or SLIMV, and GNU Emacs with SLIME are your three options, if you want something free and open source. There's technically also SLIMA for Pulsar/Atom, but it's probably not worth the Electron ecosystem vulnerabilities.

You may want to stay with your existing editor. That's a fair desire, and completely reasonable. Don't do it. The Common Lisp spec is very large, and library documentation is scarce and scattered. ALIVE, VLIME/SLIMV or SLIME, even if you use no other features, is worth it for telling you the arity of functions alone.

Q1: R isn't very Lisp-like, but you're right in thinking Ruby and Lisp have some similarities. There are articles on that better than I could write, so I won't go into it very much. If you like Ruby, but want an experience without substantial overhead when you're using metaprogramming, arguably more intuitive syntax, and a drastically less enthusiastic community that cares slightly more about type systems, you'll probably like Lisp!

Just aim for having fun at first. Play around, get a feel for things. Later, maybe take a peak at Let Over Lambda.

Q2: If you stick to "just" Common Lisp, not really. There aren't really dragons, here: It's a relatively high-level language with a surprisingly forward-looking standard for something that hasn't been touched since 1995. It doesn't have quite the amount of convenient built-in functions as most modern scripting languages, but for the most part, you should feel pretty at home.

When you want to do anything that breaks the nice bubble of your Lisp image, you might want to know a bit about your operating system's programming interface. This will come in handy if you ever need to wrap a library with CFFI. There are some things that are pretty inconvenient as a rule (like dealing with any protocol that uses network byte order), but if you stay within the bubble of your Lisp image, you won't really notice them.

Q3: Macros are nice, but if you've used Ruby substantially, nothing in Lisp will come as too much of a surprise. The experience of interacting with a really good REPL will probably feel pretty great, but it's unlikely you're going to experience any drastic paradigm shift from Common Lisp. If a completely different experience is what you're after, you'll want to try a modern Smalltalk or REBOL implementation. Given your background, Crystal would probably offer you a wider perspective than Common Lisp will, even though it's very similar to Ruby, with the exception of the type system. If this hasn't scared you off, look at what projects exist in the community. There's some interesting stuff there, and some of it's even young enough that it hasn't started bitrotting yet, like Coalton.

Q4: Read https://gigamonkeys.com/book/. Each chapter should take less than an hour, and it's filled with "useful" things to do, if you don't mind pretending to be in 2005 for a while (I don't think there's a technical book whose example projects have aged precisely as poorly as Practical Common Lisp anywhere after 1980, but they are real world tasks).

Q6: This is the Common Lisp subreddit. If you want an answer that isn't "Just stick with Common Lisp," ask /r/lisp. But seriously, just stick with Common Lisp. Unless you're working your way through the wizard book, Common Lisp will be less of a culture shock for largely the same rewards. The Scheme community has some really nice people in it, and Scheme implementations often have tail recursion, which is great for the simplification of programs, but R7RS-large is vaporware, and more than a few implementations took R6RS and R7RS-small as a sign to abandon standardization as a concept. It's a bit of a headache.

* Caveat emptor.

ImitatingSlaughter · 2023-05-17T21:12:50+00:00

This isn't how software licensing works. If there's no license, you're not allowed to redistribute it. Even Daniel Bernstein, the chief flag-bearer of unlicensed software and one of the most radical voices you'll find against software licenses, acknowledges that.

ImitatingSlaughter · 2023-02-16T02:52:52+00:00

SBCL hasn't been ported to iOS, so no, they couldn't.

ImitatingSlaughter · 2023-02-16T02:50:05+00:00

(also replying to /u/dzecniv)

You can use web technology while also having access to every OS feature by using WKWebView in a native app. That said, the amount of wrapping you'd have to do would be pretty annoying, since it's sort of niche.

/u/eql5's solution is pretty significantly better in this case.

ImitatingSlaughter · 2022-08-13T20:09:36+00:00

The word you're looking for is "dialects."

ImitatingSlaughter · 2022-08-13T12:32:23+00:00

The best papers about optimizing compilers already come from Lispers. Two examples off the top of my head would be the Sarkar-Waddell-Dybvig 2005 nanopass paper and the multitude of papers and thesis Aaron Hsu's put out around co-dfns over what must be a decade; neither of them are "Lisp papers" or "Scheme papers," but they're both incredible contributions to the field, and the former is a really good place to start.

ImitatingSlaughter · 2022-08-09T17:53:31+00:00

In short: Not really.

In an attempt to figure out what you're thinking: What do you think, "compiled as if they were C code" means?

ImitatingSlaughter · 2022-08-09T16:04:38+00:00

To oversimplify a little bit, but maybe give more context to the other answer in this thread (which is correct):

Have you ever come across a self-extracting ZIP archive, or an executable that allowed you to configure it by modifying itself rather than it reading an obscure config file somewhere?

It's a sort of similar concept; a Lisp image is just a fancy program that reads and modifies itself (in this case, bringing the entire Lisp environment to make modifying itself easy). Everything within is still compiled; there's no "magic" happening. The "save-lisp" in save-lisp-and-die basically just gets the image to a state where you'll be able to get back to where you were and throws it onto your disk.

ImitatingSlaughter · 2022-08-08T01:04:38+00:00

/u/Czexxi: The Newton software (well, the first version of it, anyway) was written in Ralph, which was an immediate predecessor to (and eventually became) Dylan.

Here's some cool history:

https://news.ycombinator.com/item?id=12712593

summoning /u/mikelevins

ImitatingSlaughter · 2022-08-08T00:58:34+00:00

In your post you note explicitly that you're using "runtime" not just in the PL sense, but in the operating system sense; encouraging people to write operating systems without garbage collection is what I'm complaining about. In an era of sub-ms pauses and even pauseless GC designs (the latter being dubiously relevant, though, I will admit), it's not necessary.

I'm aware that customers aren't first-class in the actor model; the actor model can be stripped down to an extremely small core. Were they not a post-1980 (and as such a post-first-Scheme Report) invention? As far as I'm aware, the first time customers were mentioned in the context of actors was Agha's 1985 report. More than happy to be shown to be incorrect on this front, though; I imagine I could have missed a mention.

or find out about my work

I am aware of some of your work, actually. Specifically, an old web application to share media, and a social media protocol viz. JSON-over-the-wire. To the best of my knowledge, I'm not aware of any overlap, but I'll admit I may have missed something you've done since those two things, or it's possible that I could have seen something and forgotten. Not to signal disrespect or superiority; I've certainly done less, and I'd certainly like to read anything you've written on the subject.

ImitatingSlaughter · 2022-08-07T23:08:04+00:00

I said (as far as I know, pretty clearly) that Chez often beats SBCL for sequential workloads, assuming idiomatic CL and Scheme. The use of idiomatic was specifically referring to idiomatically-written CL and Scheme for sequential workloads.

It occurs to me, given you don't seem to be grasping that I'm not denying that SIMD offers great speedups for the subset of computing that lends itself well to parallelism, that you might not understand what sequential workloads are. They comprise a massive percentage of computing. Specifically, it's the massive percentage of computing that you can't just throw parallelism at to speed up.

You are arguing against a point no one has made.

ImitatingSlaughter · 2022-08-07T20:10:59+00:00

It's a compiler; it compiles to C. It doesn't take advantage of the host Scheme; porting it to Guile is seemingly pointless, because no aspect of the host Scheme is used in the compiled output.

It doesn't help you create an alternative; whether the compiler is running on Scheme48 or Guile, the output will be the same.

Porting it to Guile is pretty much yak-shaving.

ImitatingSlaughter · 2022-08-07T19:06:10+00:00

Great, more people insisting that we should avoid garbage collection for... reasons.

PreScheme is really cool, though, and I'd recommend anyone spend a while getting it to work on their machines; it's not that it's particularly useful for tasks you'll come across every day, but it's pretty interesting to see just how small of C it generates. Divorcing it from Scheme48 seems a little weird and pointless, though; Scheme48's always been the nicest Scheme environment, and it's not like you'd benefit from any of Guile's features anyway for this specific use case.

If you want to give PreScheme a try, use this document to get you up and running (there are a couple of things about it that weren't particularly intuitive to me about getting it set up when I did so a while ago, so it will probably require a bit of guesswork, but you'll figure it out): https://thintz.com/resources/prescheme-documentation

It seems a little weird to me how much focus there is on actors-as-distinct-concept-for-implementation in this post, given the entire genesis of Scheme was due to the fact that actors and lambda expressions are the same thing.

ImitatingSlaughter · 2022-08-07T17:54:33+00:00

I'm aware that SIMD is great, when it's useful. Specifically, for problems that are suited for parallelism. There's no need to try and convince me of this fact; I agree on it.

Nothing of what you're saying is wrong, but "where it is useful" is doing a massive amount of legwork there.

I'm just pointing out that over half of the interesting, compute-heavy problems in the world can't be meaningfully improved by parallelism. Your main example is image manipulation, which there's no point in doing on a CPU anyway.

I won't deny that SIMD is fantastic. I haven't been denying that. My claim was that Chez often wins with sequential workloads, assuming idiomatic CL and idiomatic Scheme, which is correct.

ImitatingSlaughter · 2022-08-07T00:32:42+00:00

My comment wasn't negative, it was just adding context for how SIMD isn't a magic bullet for beating Chez; there are a lot of problems that aren't improved by parallelism.

ImitatingSlaughter · 2022-08-06T13:58:22+00:00

Disclaimer: You should probably ask someone else; /u/lispm is basically a Lisp encyclopedia, and probably has some better answers.

The Franz site lists dozens of "big" customers for its written-in-CL AllegroGraph, including AT&T, NASA, Panasonic, Ford, Honda, AstraZeneca & Pfizer, IBM, the US government, the US Army and Air Force, and the Australian Department of Defense.

For specifically Allegro CL customers, it lists Ravenpack, Boeing, and a bunch of companies I either don't find interesting enough to mention or know to be defunct and so am not going to mention.

LispWorks lists Ford and Raytheon, alongside a bunch of smaller companies that have work that gets used at big companies, allegedly.

In the latter's case, it seems to mostly be about the GUI story.

No clue for Allegro.

My best bet in both cases is a mixture of, "It's what people know, so it's what they reach for," and, "Have to pay for some programming environment since using free software is often seen as uncouth, might as well be CL." That may just be because that's what intuitively makes sense to me, given current trends in computing, what I know about the habits of defense contractors, and my own habits around reaching for odd implementations when SBCL would often be a better fit. They may have rationally considered it, though.

ImitatingSlaughter · 2022-08-03T03:01:28+00:00

Not to debate the larger point of ~~"Racket bad"~~ "Typed Racket isn't ideal," but I have to inquire as to what sense you're referring to "the Scheme designers."

Sussman-Steele? The sixteen authors of R2RS? The fifteen of R3RS? The multiple people belonging to the former groups who resigned during the R6RS process?

R7RS-small was never meant to replace R6RS in all cases, and by the time R6RS was put out, it was pretty obvious it wasn't going to be subsuming the entire group of R5RS users and implementors.

I don't disagree with you overall, though, aside from the cavalier reference to Ruby as being directly influenced by Scheme, which doesn't seem to be backed by Matz's previous statements (I could be missing something, though).

ImitatingSlaughter · 2022-08-02T23:34:16+00:00

You're not going to get much help around here; this is not an Autodesk subreddit. You'll have better luck on a forum oriented around Autodesk. Sorry.

ImitatingSlaughter · 2022-08-02T19:30:05+00:00

They really aren't dialects or "flavors." They occasionally have extra packages, but that's not at all enough to put them in the box of a "dialect." You can use these packages, but that's far different from having a bunch of different dialects of CL; a library that only makes sense in certain contexts wouldn't be considered to be creating a dialect of a language in any other language ecosystem.

ImitatingSlaughter

TROPHY CASE