Lisp style is the main lifesaver in this practice.

While the joke is that having a highly unique fancy style of your very own is the lisp style, they tend to what the language tends to- long life in an environment with every possible comfort.

One key feature is not believing we know what success is going to look like in the distant future and so focusing on taking strong steps in the best direction that occurs to us here and now. Less obviously, being able to take big steps quickly seems to be important. This has been called exploratory programming.

I'm going to share a really plain example of twenty minutes of a live video of my own programming (video at the end). Different lispers will be a bit different, but we will have lots of features and goals in common.

I wanted named rooms, with description text a la https://lambda.moo.mud.org so I named a new source block from within my lisp image

(ed 'screwtapes-room)

(check the video for what that does for me)

and stuck a description property in the plist (property list) of a test room name, screwtapes-room

(setf (getf (symbol-plist 'screwtapes-room) 'description)
      "The room of screwlisp")

} this is also an example of the Big Steps approach I said lispers have found important so I will quickly run through each function inside-out

1.2.1. (symbol-plist 'screwtapes-room)

1.2.2. (getf (symbol-plist 'screwtapes-room) 'description)

1.2.3. (setf (getf (symbol-plist 'screwtapes-room) 'description) "The room of screwlisp")

I now have an example room name with a description. The lisp image opens interactive prompts if I do want to read and then eval the new snippet I had worked on.

when I issued =(ed 'frame)= this source appears:

(define-application-frame moonclimb
    ()
  ((current-room :initform nil :accessor current-room))
  (:panes
   (int :interactor)
   (title :title :title-string "my title")
   (app :application :display-function 'display-current-room))
  (:layouts (default (vertically () title (horizontally () int app )))))

(defun display-current-room (frame pane)
  (format pane "~a" (current-room frame)))

which was the whole program so far. CLIM is the best interactive GUI development gets by the way.

Add a slot, make the names a little better, jiggle layout, say I want the description displayed when it changes, suggest a low height :

(define-application-frame moonclimb
    ()
  ((current-room :initform nil :accessor current-room)
   (current-description :initform nil :accessor current-description))
  (:panes
   (int :interactor)
   (title :title :title-string "my title")
   (current-room :application :display-function 'display-current-room)
   (current-description :application :display-function
                        'display-current-room-description))
  (:layouts (default (vertically () (horizontally (:height 64) current-room title)
                       (horizontally () int current-description )))))

(defun display-current-room (frame pane)
  (format pane "Currently in: ~a" (current-room frame)))

(defun display-current-room-description (frame pane)
    (format pane "Description:~%~a" (current-description frame)))

while incrementally looking at the frame to see how it's going and checking that "change room" prompts for and changes the symbolic room.

Turning a computer off and then on again isn't a powerful way to grow programs.

Instead, constructive wandering able to take big steps and with high visibility and interactivity are powerful ways to explore a program's future goals.

https://toobnix.org/w/kTjp7StwkZvdzdgfQwmR6J