Secret Source

Do you guys know of any torrents or other means for obtaining interesting/rare source code, like the torrent for Symbolics Open Genera¹?

___________________________________
1. http://thepiratebay.se/torrent/3769989/Symbolics_Open_Genera_2.0_for_Alpha_-_complete_package_with_Lisp1

No but I have some requests:

1. Mirai (or N-world, or S-graphics) (with sources in the former case)
2. Macsyma.
3. A scan of Koegge's architecture of symbolic computers.
4. ICAD
5. Derive for DOS.

>>1
In case anyone is wondering, Stanislav Datskovsky has confirmed there is no difference between the Open Genera linked above and the one you can get from Symbolics' corpse. You can run it in the crappy and buggy VLM for Linux. You also need an old enough X windows.

>>2
The macsyma source code was forked circa 1982 into an open source thing called maxima. Shitloads of common lisp code. very little comments.

>>4

here's sample btw, from sin.lisp (Copyright 1982 Massachusetts Institute of Technology)


(defun checkderiv1 (expr wrt old-wrt)
(cond ((alike1 (car wrt) var)
(if (equal (cadr wrt) 1) ;Power = 1?
(if (null (cddr wrt)) ;single or partial
(if (null old-wrt)
expr ;single
`((%derivative), expr ;partial in old-wrt
,.(nreverse old-wrt)))
`((%derivative) ,expr ;Partial, return rest
,.(nreverse old-wrt)
,@(cddr wrt)))
`((%derivative) ,expr ;Higher order, reduce order
,.(nreverse old-wrt)
,(car wrt) ,(add* (cadr wrt) -1)
,@ (cddr wrt))))
((null (cddr wrt)) () ) ;Say it doesn't apply here
(t (checkderiv1 expr (cddr wrt) ;Else we check later terms
(list* (cadr wrt) (car wrt) old-wrt)))))



also, in the obituary for the guys who maintained the FOSS macsyma fork they said he was an "expert programmer".

>>4

I love and use Maxima all the time. Here's a tip; evaluate to_lisp() and then start SWANK ;). Some russian guy forked Maxima and made an ASDF build, so it could be quicklispable but then he abandoned the fork for some reason? According to a mailing list the Maxima people were quite interested in eventually merging it too. I think if Maxima were quicklispable far more people would use it cause it's very very useful.

However, Maxima is missing about 10 years worth of commercial, paid for Macsyma development from Symbolics. Rumor has it that Macsyma can do things no other CAS can:

Out came the four-term typeset result of logarithms and arctangents, plus a fifth term I'd never seen before. "I've never seen any computer algebra system add that fifth term," I said, "but it doesn't look incorrect." The fifth term was a floored expression, whose value increased with the period of the function preceding it. "Let's plot it," Bill said. He plotted it using MACSYMA's menu interface, and it was what appeared to be an increasing, non-periodic function. I think we determined it was because MACSYMA properly handled branch cuts, with other systems have been known to be unorthodox about. It definitely had a pragmatic feel to it.

http://symbo1ics.com/blog/?p=1999

If you're interested in CASs there's also Axiom (and two recent forks) which, as I understand it, took a very unique approach. However since I already know Maxima and Mathematica I have not (yet) taken the time to look into it.

>>4

I'll also add that Derive for DOS is specifically interesting cause it was programmed in MuLisp (which was a Commonish Lisp for computers with not much memory) and its the (basis of the?) CAS that runs on TI calculators from the 92 family and the 89 Titanitum. In any case, a low memory Lisp with in built CAS is very interesting :)

bump

this is semi-relevant semi-interesting, it's a document about the wolfram internals.

http://reference.wolfram.com/mathematica/tutorial/TheInternalsOfMathematicaOverview.html

notice how they spend lots of time describing what a "tree" is without actually saying "tree":

the "backbone" of the list will be stored at one place, while each of the actual elements will be stored at a different place.

The backbone of the list then consists just of three "pointers" that specify the addresses in computer memory at which the actual expressions that form the elements of the list are to be found. These expressions then in turn contain pointers to their subexpressions. The chain of pointers ends when one reaches an object, such as a number or a string, which is stored directly as a pattern of bits in computer memory.

btw, wolfram himself has essentially stated that macsyma was early inspiration for wolfram:

And @O 236 went to an open computer at MIT that ran a program called Macsyma—that did algebra, and could be used interactively. I was amazed so few people used it. But it wasn’t long before I was spending most of my days on it. I developed a certain way of working—going back and forth with the machine, trying things out and seeing what happened.

(http://blog.stephenwolfram.com/2013/06/there-was-a-time-before-mathematica/)

>>5

LISP

I bet that shit spends 90% of it's time collecting garbage.

GC is shit.

>>10
free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(free(malloc(

>>11

more like

let foo = ~bar;

Rust: memory safety without GC shit.

Rust a shit.