50 Matching Annotations
  1. Jan 2024
    1. More, essentially all research in self-reference for decades has been in artificial intelligence, which is the device around which this plot turns. The language of AI is LISP, the name of the archvillain. In the heyday of LISP machines, the leading system was Flavors LISP Object Oriented Programming or: you guessed it -- Floop. I myself worked on a defense AI program that included the notion of a `third brain,' that is an observer living in a world different than (1) that of the world's creator, and (2) of the characters.
  2. Jun 2023
    1. kons-9 is that it combines the power of a software development IDE with the visual tools of 3D graphics authoring system. It does this by being implemented in Common Lisp, an object-oriented dynamic language which provides powerful facilities for exploratory development and rapid prototyping within a live interactive software environment

      IDE + 3D + Lisp = Unique features:: * software development IDE with visual toold of 3d graphics authoring system * unlimited extensibility (no distinction between developers and end users)

      https://youtu.be/NJe4isZ7NHI

  3. Apr 2023
  4. Mar 2023
    1. We already did, it was called Lisp Machines and Smalltalk, and we are yet to fully replicate them.

      No del todo. Las interfaces kinestésicas y el pensamiento con todo el cuerpo están lejos de lo que se hace con estas tecnologías

  5. Dec 2022
  6. Oct 2022
  7. May 2022
    1. Experienced Lisp programmers divide up their programs differently. As well as top-down design, they follow a principle which could be called bottom-up design-- changing the language to suit the problem. In Lisp, you don't just write your program down toward the language, you also build the language up toward your program. As you're writing a program you may think "I wish Lisp had such-and-such an operator." So you go and write it. Afterward you realize that using the new operator would simplify the design of another part of the program, and so on. Language and program evolve together. Like the border between two warring states, the boundary between language and program is drawn and redrawn, until eventually it comes to rest along the mountains and rivers, the natural frontiers of your problem. In the end your program will look as if the language had been designed for it. And when language and program fit one another well, you end up with code which is clear, small, and efficient.

      Bottom-up design!

  8. Aug 2021
    1. this kind of run-time code generation is certainly more natural in Ruby, it's one of its Lispish elements
  9. May 2021
    1. Note that variables cannot appear in the predicate position.
  10. Apr 2020
    1. When you're writing software that is only going to run on your own servers, you can use whatever language you want.
  11. Nov 2019
    1. The first indication of a change in weather was the sudden collapse of the market for specialized AI hardware in 1987. Desktop computers from Apple and IBM had been steadily gaining speed and power and in 1987 they became more powerful than the more expensive Lisp machines made by Symbolics and others. There was no longer a good reason to buy them. An entire industry worth half a billion dollars was demolished overnight.
  12. Jul 2019
    1. The Lisp Machine (which could just as easily have been, say, a Smalltalk machine) was a computing environment with a coherent, logical design, where the “turtles go all the way down.” An environment which enabled stopping, examining the state of, editing, and resuming a running program, including the kernel. An environment which could actually be fully understood by an experienced developer.  One where nearly all source code was not only available but usefully so, at all times, in real time.  An environment to which we owe so many of the innovations we take for granted. It is easy for us now to say that such power could not have existed, or is unnecessary. Yet our favorite digital toys (and who knows what other artifacts of civilization) only exist because it was once possible to buy a computer designed specifically for exploring complex ideas.  Certainly no such beast exists today – but that is not what saddens me most.  Rather, it is the fact that so few are aware that anything has been lost.
  13. May 2019
    1. Although regular macros work on programs in the form of trees, a special type of macro, called a read macro, operates on the raw characters that make up your program.

      this make me wonder how is this different from pre-processors? if I'm working on text before compile, is being in the same language giving me any advantage

  14. Oct 2018
    1. Perhaps part of the confusion - and you say this in a different way in your little memo - is that the C/C++ folks see OO as a liberation from a world that has nothing resembling a first-class functions, while Lisp folks see OO as a prison since it limits their use of functions/objects to the style of (9.). In that case, the only way OO can be defended is in the same manner as any other game or discipline -- by arguing that by giving something up (e.g. the freedom to throw eggs at your neighbor's house) you gain something that you want (assurance that your neighbor won't put you in jail).

      [9] "Sum-of-product-of-function pattern - objects are (in effect) restricted to be functions that take as first argument a distinguished method key argument that is drawn from a finite set of simple names."

    2. Ad hoc polymorphism - functions and data structures with parameters that can take on values of many different types.

      does he mean that list in python is polymorphic because it can be list of integers or string or ... ?

    3. Encapsulation - the ability to syntactically hide the implementation of a type. E.g. in C or Pascal you always know whether something is a struct or an array, but in CLU and Java you can hide the difference.

      is this because:

      • interfaces--contextually identical (because satisfy common set of behaviours)?
      • or being wrapped in objects (thus blurring the difference)?
    1. Lisp macros were also useful for the definition of new control structures, as well as new data structures. In ZWEI, we created a new iterative control structure called charmap, which iterates over characters in an interval. Intervals are stored as doubly-linked lists of arrays, and the starting point might be in the middle of one array and the ending point might be in the middle of another array. The code to perform this iteration was not trivial, and someone reading it might easily not understand the function it was performing, even though that function was the conceptually simple one of iterating over characters. So we created a macro called charmap that expands into the double-loop code to iterate over the characters. It is simple and obvious, and is used in many places, greatly reducing the size of the code and making the functionality obvious at a glance.

      use of macros implementing data structures making things more readable!

    2. It became policy to avoid abbreviations in most cases. In ZWEI, we made a list of several words that were used extremely often, and established 'official' abbreviations for them, and always used only those abbreviations. ... Words not on this list were always spelled out in full.

      abbreviations whitelist - good programming practice!

    3. The use of the mouse is still considered experimental. We know of several editors which depend highly on the use of a mouse for input, but we are not convinced that it is better than a keyboard; after more people start using ZWEI, it will be interesting to see how many of them make heavy use of the mouse and how many hardly use it at all.

      mouse considered experimental mouse better than keyboard?

    4. Since ZWEI is written in Lisp and lives in the Lisp environment of the Lisp machine, it is in a very good position to interface closely with other elements of that environment.

      living system interacting with a running lisp machine

    5. ZWEI is display-oriented: the text the user is editing is actually displayed (this is relevant because many editors of the time often showed out-of-date text due to efficiency and bandwidth restrictions, putting the burden on the user to imagine what their text looks like currently).

      bandwith restrictions -> out of date text -> user has to imagine what it currently looks like

    6. Some paragraphs are devoted to what must have been a novel concept at the time for such a system: that the Lisp Machine was a personal system, not time-shared, and this gave rise to features not viable on time-sharing systems, due to the fact that the user was not contending with other users for resources.

      personal computers as novel concept (vs time sharing) and what it enables

  15. Oct 2017
  16. Dec 2015
  17. Oct 2015
  18. Nov 2014