XPost: alt.folklore.computers   
   From: antispam@fricas.org   
      
   In alt.folklore.computers rbowman  wrote:   
   > On Fri, 2 Jan 2026 15:27:42 -0000 (UTC), Waldek Hebisch wrote:   
   >   
   >> You mean 'expert system' coded in Lisp or Prolog?  Or just general   
   >> coding in Lisp or Prolog?   Concerning general coding IMO Prolog is   
   >> great for backtracking search and a few similar problem, but not good   
   >> for most of programs.  On the other hand Lisp is quite capable general   
   >> purpose language.   
   >   
   > I meant the general case. There were precedents and other people involved   
   > in the evolution but as shorthand I'll say Lisp embodies the was McCarthy   
   > thinks, and Prolog does the same for Roussel. At that point it gets   
   > philosophical. How does a person structure and perceive reality? In   
   > another thread Hume and Kant came up. Hume triggered Kant's thought but   
   > Kant approached the world differently.   
   >   
   > Less esoterically, I looked at Lisp, or Scheme precisely in the Wizard   
   > book, and I could understand the concepts and follow the thought processes   
   > but they were not a natural approach for the way i address the world. I   
   > didn't mean a general indictment of the language when I said I couldn't   
   > understand why someone would do it that way, but a very specific *I*.   
      
   I do not look philosophy, for me a programming language is a practial   
   (or mabye inpractical) tool.  When people now write Lisp the usual   
   assumption is that they mean Common Lisp.  Scheme is different, it   
   is much smaller language (but there are many dialect, some have   
   quite a lot of extentions).  Concerning Common Lisp, if you want   
   description bordering philosophical, then it is an WSL (wide   
   spectrum language).  Which means that staying withing the   
   language you can have quite different looking code.  In standard   
   Common Lisp you can essentially write code as if it was Fortran   
   66 or 77.  If you want to write C in Lisp, then there are some   
   limitations: Lisp do not have pointers, you are supposed to   
   use arrays instead (or take advantage of fact that most Lisp   
   data have reference sematics).  Lisp structures behave is a different   
   way than C structures: in C structure may contain a substructure   
   or programmer may explicitely use a pointer referencing some   
   other structure.  In Lisp substructures are always references.   
   But that is getting too technical, if you ignore technicalities   
   you can program in similar style to C or Pascal.  But you can   
   also write higher level code.  Lisp has garbage collection,   
   so no need to manualy free memory.  Which means that you can   
   build new things at any time without risk of leaking memory.   
   Lisp has object system, so if you are OO zealot you can   
   have your classes, methods and objects.  Or you may prefer   
   functional style, building a complex data structures which   
   share many substuctures.  You can create closures and return   
   them.   
      
   Some folks like symbols, but if you want you can use strings.   
   Hash tables are included in the standard, for more special   
   things therea are libraries.   
      
   Common Lisp was standarized in eigthies, but that followed long   
   tradition, so there are several historical warts.  One is that   
   internally Common Lisp is case sensitive and all system things   
   have upper case names.  That is usually obscured by input   
   system (technicall 'Lisp reader') which in default setting   
   uppercases everthing, so sources look as if Common Lisp was   
   case insenitive.  But sometimes discrepancy between upper   
   case inside and what you see in the source may catch you.   
   Or you may write many things in upper case, but than the   
   code look like Nigerian scam.  Another wart is that to   
   call a function passed as a parameter you need something   
   like   
      
   (FUNCALL foo x y z)   
      
   instead of more natual   
      
   (foo x y z)   
      
   BTW: this is one of most visible differences between Common   
   Lisp and Scheme.   
      
   People who look first time at Lisp note a lot of parenthesis.   
   Essentially, Lisp programer writes parse tree of the program   
   using parenthesis to delimit subtrees.  Initally (around 1958),   
   this was just a shortcut to avoid writing proper parser (parser   
   for parenthesised notation is very simple).  But it was noticed   
   that Lisp sources can be transformed under program control   
   and such transformations are easy because the Lisp source has   
   the same form as Lisp data.  Anyway, this capability is   
   frequently used and support for it is main reason to keep   
   parenthesised notation.   
      
   BTW: Passage from textual source to data structures is programmable.   
   In principle you can write a support library such that small   
   magic sequence of characters switches input notation to someting   
   completely different.  For example, there is well-known package   
   allowing infix notation for expressions.  If somebody really   
   wanted to, it should be not very hard to allow say Pascal sources   
   as Lisp programs.  In fact, computer algebra system Reduce uses   
   a Lisp dialect as implementation language.  But most sources   
   is written in a Pascal-like language.  Everything read from   
   a file eventually leads to Lisp expression, but notation used   
   can vary within the file.   
      
   > Prolog is either further away for me. It sounds contradictory but I'm   
   > logical but never was comfortable with formal logic.   
      
   --   
                                 Waldek Hebisch   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)