the right thing vs C

11.7: adda/the right thing vs c:

. an mit scheme (lisp) fan railed against c as a virtual virus,

pointing out that it was easy on compiler writers

and writing this one simple compiler

gave access to libraries of unix code

-- never mind that the whole c-unix way of doing things

was not making it easy to catch app'designer errors .

. how could they pick c over lisp,

when scheme compilers were so mature, just as efficient,

and provided libraries that were much safer than unix ?

. the lisp approach reminds of

the christian invitation:

talk this funny, anti-intuitive way,

and you're assured acceptance into a society

that includes many benefits.

. everyone is born with their own intuitive religion

and so they gravitate toward the society

that demands the least changes.

. c didn't offer many benefits,

but it talked to us in plain english,

and gave us the tools to at least start designing

the full-benefits system we dreamed of.

. c is the American way,

encouraging the maximum degree of

state-centric experimentation; [2019.9.19:
ie, giving states or locales more freedom
than the federal or global gov:
. C gives locals a chance to do things their own way,
while benefiting less from reuse.]

. the scheme way had pre-decided

the best interface to huge libraries,

whereas the unix way let everyone contribute pieces of library

and then let popularity decide on pieces of library.

11.30: adda/lisp/integrating the essentials:

. how is adda being lispy?

isn't there much can be done with building lists of function pointers

and then have a recursive tree item caller?

need to restudy lisp to get working knowledge of

what they like to do that needs self-compile .

. when an etree being built declares locals

and then tries for a compile to vm`byte.code,

how the machine builds function literals

should be mappable with

how users can do the same by menu;

but, coders also like to use macro-like transforms:

eg, assign a list var' some

listeral (list literal) having no context,

so all the symbols used by the listeral

are all {params, free vars}

then when list var's contents are

dropped into another list which does have a context,

then the param's are linked to

the symbols of the same name in the context (symbol lib) .