4 ms·

No, Lisp is not interpreted. Lisp compilers exist for long times. Lisp is dynamic typed. "Strong" typing often is wrongly used as a term for static typing. Whe

by _ph_ 3y ago

No, Lisp is not interpreted. Lisp compilers exist for long times. Lisp is dynamic typed. "Strong" typing often is wrongly used as a term for static typing. When programming, Lisp certainly benefits from good editor support - as most other languages do too. And remarkably, the Lisp community pretty much agreed on a formatting and indentation style, so support in editors like Emacs is pretty good. But its dynamic nature together with automatic memory management certainly limited the performance especially on the weak hardware back then. In comparison, it is almost trivial to write a small compiler for a language like Pascal which will produce efficient code. Fun fact: the back then popular UCSD Pascal (I used it on the Apple II) was using a bytecode engine as the compilation task.

lispm 3y ago
> But its dynamic nature together with automatic memory management Generally Lisp was used with a resident interpreter and (loadable) compiler, often interactively, it contained lots of information about the program under development. PASCAL tended to be compiled to small programs with small runtimes by a batch compiler. The actual performance was only a secondary problem. The main problem was that Lisp used lots of memory and when the GC kicked in, it was generating a lot of memory usage -> for example by a mark & sweep GC. On a shared computer this could mean that just the Lisp program used much of the memory and on GC it was busy for some period of time. Other uses would see a massive performance degradation of the computer. That was one of the reason to develop special computers, expensive single user workstations for Lisp, which had lots of expensive memory just for one user and improved memory management. For example, they then had four megabyte (or more) of random access memory. ;-) > UCSD Pascal (I used it on the Apple II) was using a bytecode engine as the compilation task Lisp systems also used byte code engines. Example: https://dl.acm.org/doi/pdf/10.1145/800087.802811 https://dl.acm.org/doi/pdf/10.1145/800087.802811
tgv 3y ago
> "Strong" typing often is wrongly used as a term for static typing. Minor contradiction: the distinction between strong and static typing is modern. From wikipedia: > In 1974, B. Liskov and S. Zilles defined a strongly-typed language as one in which "whenever an object is passed from a calling function to a called function, its type must be compatible with the type declared in the called function."

by _ph_ 3y ago

lispm 3y ago

> But its dynamic nature together with automatic memory management Generally Lisp was used with a resident interpreter and (loadable) compiler, often interactively, it contained lots of information about the program under development. PASCAL tended to be compiled to small programs with small runtimes by a batch compiler. The actual performance was only a secondary problem. The main problem was that Lisp used lots of memory and when the GC kicked in, it was generating a lot of memory usage -> for example by a mark & sweep GC. On a shared computer this could mean that just the Lisp program used much of the memory and on GC it was busy for some period of time. Other uses would see a massive performance degradation of the computer. That was one of the reason to develop special computers, expensive single user workstations for Lisp, which had lots of expensive memory just for one user and improved memory management. For example, they then had four megabyte (or more) of random access memory. ;-) > UCSD Pascal (I used it on the Apple II) was using a bytecode engine as the compilation task Lisp systems also used byte code engines. Example: https://dl.acm.org/doi/pdf/10.1145/800087.802811 https://dl.acm.org/doi/pdf/10.1145/800087.802811

tgv 3y ago

> "Strong" typing often is wrongly used as a term for static typing. Minor contradiction: the distinction between strong and static typing is modern. From wikipedia: > In 1974, B. Liskov and S. Zilles defined a strongly-typed language as one in which "whenever an object is passed from a calling function to a called function, its type must be compatible with the type declared in the called function."