Unix
People today don't know what a real OS is. All they've ever used are toys and jokes. VMS, OS/360, OS/400, Multics, Genera...those are real OSes. Unix was created to run a game on a PDP-7. Linux was created as a personal hobby OS. MS-DOS was literally a "Quick and Dirty Operating System." Windows was originally a shell for MS-DOS. Windows NT had some promise, but MS managed to fuck it up by putting the GUI in kernel mode, deleting all of the subsystems besides Win32 and NTVDM, and copying the (lack of) security model from the DOS-based Windows versions. This "worse is better" approach is killing computing.
The file system is an artifact of the limitations of early processors that had no memory virtualization capabilities and had an insufficient memory address word size. Programs and data had to be marshalled out of and back into a logically distinct store because 64K can only hold so much information. Modern 32 and 64 bit processors with memory management units can treat storage as large, slow, persistent memory obviating the contortions required in conventional operating systems to keep data from going away when the computer is shut down.
>>9
Linux is shit. Stallman is evil jew: http://www.gnu.org/prep/standards/html_node/Source-Language.html#Source-Language
>in general it is much better to use C, rather than the comparable alternatives.
>C has one advantage over other compiled languages: more people know C
>the best language to use is C. Using another language is like using a non-standard feature: it will cause trouble for users.
>>10 the best language to use is C. Using another language is like using a non-standard feature: it will cause trouble for users.
Says the guy who endorses "GNU + C" and GCC still has no C99 support.
All pages except the first one are 404-ing.
Unix I/O? I liked my I/O in CL and Scheme just fine, but I suppose people are a bit more familiar with C I/O, but it really feels like a hack to use that in a Lisp.
Using fn instead of fun,function or lambda? Graham did that with his Arc, but I never had any trouble writing any of those, it's not like Emacs/SLIME doesn't make it quite easy to write even long function names.
Arc-like let form? Not sure how I feel about this without seeing the full refenrece/documentation (it's not there yet).
Is it a Lisp-1 or a Lisp-2/n? Not mentioned. It does seem to use Scheme's conventions for naming functions, so it might be a Lisp-1, but this is not mentioned.
The part that bothered me quite a bit was this: Gensyms in Plan are created by calling the symbol function with no arguments. Gensyms are based on random strings, instead of a globally-increasing counter, because it's safer to run things in parallel that way. At some point we may switch to a mix of randomness and counting, to be extra-safe.
First, the ``globally-increasing counter'' that is used in CL doesn't even matter, because even if I gave each gensym the exact same name, there would never be any symbol conflicts. Why? gensyms are uninterned symbols, that is, they don't belong to any package, thus function generating the symbol will just return a new object/symbol each time, which is not eq (pointer compare) to anything, because it's a freshly allocated object. Interning a symbol in a package will give you symbols which can be compared by eq if they have the same name (will get the same pointer as when you intern a symbol into a package, it searches/inserts the symbol by name into the package's symbol table- this allows efficient comparison by eq).
Now, let's assume for a second that you'd have a single package or a global environment in which all symbols are interned, thus uninterned symbols (such as what gensyms actually are) wouldn't exist, in that case, naming conflicts would matter, but even then, the use of a counter wouldn't be a problem in multi-threading scenarios if you just used a lock (or some atomic-like operation) around that counter.
Native reg-exp? Hardly a problem to implement with some reader-macros.
Even if we consider that you've both used this terrible idea of a global environment and can't even use basic parallel programming techniques (why are you doing multithreading then?) such as locks or atomic operations, I don't think it matters if you use a counter or a randomly generated string - if the seed is the same for the PRNG, it would be just as bad as using a counter, in which case, you need a thread-safe PRNG (I think some C implementations provide one, but I don't know what language is used to implement this, there's no download available).
In conclusion: hard to evaluate this Lisp, but judging only from the first and only page that is available, it doesn't seem like anything that would be very hard to make in a few hours of work in CL (if Lisp-2, it would be doable with just a package and some reader macros (for reg-exp functionality), if Lisp-1, you might want to make a thin compiler or interpreter that compiles to the underlying Lisp).
Symta:
expmod Base Exp M = {eq Exp 0 = #y
;even? Exp = rem (expmod Base Exp/2 M)^2 M)
; #y = rem Base*(expmod Base Exp-1 M) M}
prime? K N
= lehmannTest:<Tries A = X:(expmod A (N-1)/2.0 N)
= {eq Tries 0 = #y
;{eq X 1; eq X (mod -1 N)} = r Tries-1 (rand N)+1
;#t = #f}>
= {lt N 2 = #y
;eq N 2 = #n
;even? N = #f
;#t = lehmanTest K (rand N)+1}
Scheme:
(define (square x) (* x x))
(define (expmod base exp m)
(cond ((= exp 0) 1)
((even? exp)
(remainder (square (expmod base (/ exp 2) m)) m))
(else
(remainder (* base (expmod base (- exp 1) m)) m))))
(define (prime? k n)
(define (lehmann-test tries a)
(let ((x (expmod a (/ (- n 1) 2.0) n)))
(cond ((= tries 0) #t)
((or (= x 1) (= x (modulo -1 n)))
(lehmann-test (- tries 1) (random>0 n)))
(else #f))))
(cond ((< n 2) #f)
((= n 2) #t)
((even? n) #f)
(else (lehmann-test k (random>0 n)))))
Name:
Anonymous2011-12-21 23:38
Plan opens by saying how it offers nothing new. What the hell.