According to Paul Graham, the power of a programming language is equal
to its succinctness (see "http://www.paulgraham.com/power.html"). I
agree with him, and extend his postulate from languages to application
development environments in general.

I'm spending most of my time writing the database-and-GUI kind of
business applications. So this is the field where I'm personally
interested in, and which is sufficiently large and specialized in its
requirements to be also of general interest. I'm using Pico Lisp for
that, having built an application server framework on top of it with
quite high succinctness and abstractions for this type of applications.

I don't doubt that other people have tried to solve these problems before, so
there should be other environments with equal or higher succinctness (and thus
programming power). To make the systems somehow comparable, I specified a very
simple application with certain typical features, and posted it as a challenge
to the Lisp community:

   http://software-lab.de/succinctness.html

There is a specification, a complete solution (in Pico Lisp), and a link
to a life test setup.

- Alex

--

I think programming languages are more about "expressiveness",
of which "succinctness" is just one aspect.  This all just sounds
to me like an opportunity to argue over the meaning of words.

I thought this was settled 20 years ago and the answer was "Genera".
(The MIT-cum-Symbolics crowd had plenty of discussions and ideas about
relatively radical new places to move forward from there, but the world
wasn't even ready for Genera, yet, so those were never realized.)

 Alexander> But perhaps is it possible in some certain, well-defined fields?

Generally, people will construct a problem that suits
the answer they wanted.

For example, I think most people would even agree that SQL
is the best language for manipulating SQL databases as such.

APL is a very concise and beautiful language for expressing
many kinds of problems.

If you're talking about programming environments, I think
you'll find that it's fairly religous.   Might as well ask
what the "best" editor is.

And we all know the answer is ZMACS/ZWEI, so don't kid yourself.

I don't want to start a philosophical debate, but simply see hard facts.
A short and succinct solution. Is that so difficult?

- Alex

--

Also, I don't want to compare languages, but APIs.

   (rel mate   (+List +Joint) mate (+Person))      # Spouse(s)

completely specifies the bi-directional Spouse relation. What does it
help here to draw arrows, except to make it less succinct?

- Alex

--

"Alexander Burger" <a...@software-lab.de> wrote

But the physical appearance of the GUI doesn't matter. I'm only
interested in the functionality and behavior of the resulting
application.

- Alex

--

- Alex

--

- Alex

--

anyway, here's a ucw version of your program.

Notes:

0) the db is in RAM. UCW doesn't impose a particular db setup, so i'll
   just use the simplest one i can think of. Redfining the accessors
   for the person class should be easy enough should someone want to
   add a "proper" DBMS in here.

1) I've left out the date manipulation code, it's currently broken.

2) The view tables are written out by hand only because i haven't
   decided which abstraction i want for auto generating data views,
   not because i don't want it. (well, that's my excuse at least :)).

3) i've not implemented the propagation of sex changes from one person
   to their childern's parents, it's fairly trivial, rather boring,
   and adds nothing to this example.

4) there's more or less no explicit validation when creating a new
   user since this app never asks you for textual input but only
   allows you to chose from a list of valid possibilites. this choice
   would have to be revisited if the db becomes large.

5) This a 40 minute hack which may or may not even work, i just hope
   it's enough to give you an idea of what the ucw API is like.

The app initally presents the user with a listing of all the people in
the db (and a "create new user" button), navigating the app is done by
clicking on the names of the current person's spouses, parents or
children. the "search for person by name" button doesn't exist.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(in-package :it.bese.ucw-user)

(defclass people-app (standard-application)
  ((people :accessor people :initform (make-hash-table :test 'equal))))

(defapplication *people-db*
  (:url-prefix "/ucw/people/")
  (:clase people-app))

(defclass person ()
  ((name :accessor person.name :initarg :name :initform (gensym))
   (sex  :accessor person.sex  :initarg :sex  :initform :unknown)
   (mother :accessor person.mother :initarg :mother :initform nil)
   (father :accessor person.father :initarg :father :initform nil)
   (children :accessor person.children :initarg :children :initform nil)
   (spouses :accessor person.spouses :initarg :spouses :initform nil)))

;;; init the db

(let ((adam (make-instance 'person :name "Adam"
                                   :sex :male
                                   :birthdate (cl-icu:make-date 0)))
      (eve (make-instance 'person :name "Eve"
                                  :sex :female
                                  :birthdate (cl-icu:make-date 0))))
  (push adam (person.spouses eve))
  (push eve (person.spouses adam))
  (setf (gethash "Adam" (people *people-db*) adam
        (gethash "Eve" (people *people-db*) eve))))

;;;; viewing, editing and navigating an individual

(defcomponent person-viewer (standard-component)
  ((person :accessor person :initform nil :initarg :person)))

(defaction view ((p person))
  (call (make-instance 'person-viewer :person p)))

(defaction change-name ((p person))
  (let ((new-name (call 'string-choser
                        :message "New name:"
                        :validate (lambda (name)
                                    (not (gethash name (people *people-db*))))
                        :error-message "Sorry, the name ~S is taken.")))
    (remhash (person.name p) (people *people-db*))
    (setf (person.name p) new-name
          (gethash new-name (person.name *people-db*)) p))
  p)

(defaction change-sex ((p person))
  (setf (person.sex p) (call 'option-dialog
                             :message "New sex?"
                             :options '((:male . "Male") (:female . "Female"))
                             :confirm nil))
  (case (call 'option-dialog
              :message "What should we do about ~S's child's fathers?"
              :options '((:leave . "Leave the DB in an invalid state.")
                         (:update . "Change the other parent's sex and swap mother and father.")))
    (:leave
     ;; just return the person
     t)
    (:update ;;update the entire db
     (dolist (c (person.children p))
       (case (person.sex p)
         ;; person has changed from male to female, need to change the
         ;; mother's sex and update all of the mother's children.
         (:female ...)
         ;; person has changed from female to male, need to change the
         ;; father's sex and update all of the father's children.
         (:male ...)))))
  p)

(defaction chose-or-make-person ((subject person) message &key (test #'identity))
  (or (call 'option-dialog
            :message message
            :options (list*
                      (cons nil "Make a new person.")
                      (loop
                         for person being the hash-values of (people *people-db*)
                         when (funcall test person)
                           collect person)))
      (call 'new-person :person (make-instance 'person) :test test)))

(defaction change-mother ((p person))
  (let ((new-mother (chose-or-make-person p "Who should be the new mother?"
                                          :test (lambda (possible-mother)
                                                  (eql :female (person.sex possible-mother))))))
    (setf (person.mother p) new-mother)
    (unless (find p (person.children new-mother))
      (push p (person.children new-mother)))
    p))

(defaction change-father ((p person))
  (let ((new-father (chose-or-make-person p "Who should be the new father?"
                                          :test (lambda (possible-mother)
                                                  (eql :male (person.sex possible-mother))))))
    (setf (person.father p) new-father)
    (unless (find p (person.children new-father))
      (push p (person.children new-father)))
    p))

(defaction add-spouse ((p person))
  (let ((new-spouse (chose-or-make-person p "Who should be the now spouse?"
                                          :test (lambda (possible-spouse)
                                                  ;; assume a conservative country
                                                  (not (eql (person.sex possible-spouse)
                                                            (person.sex p)))))))
    (push new-spouse (person.spouses p))
    (unless (find p (person.spouses p))
      (push p (person.spouses new-spouse))))
  p)

(defaction add-childer ((p person))
  (let ((new-child (chose-or-make-person p "new child?")))
    (push new-child (person.children p))
    (ecase (person.sex p)
      (:male (setf (father new-child) p))
      (:female (setf (mother new-child) p)))
    p))

(defaction delete-child ((p person) (child person))
  (setf (person.children p) (delete child (person.children p)))
  ;; must chose a new mother-father for child
  (if (eql p (person.mother child))
      (setf (person.mother child)
            (chose-or-make-person p (format nil "New mother for ~S?"
                                                (person.name child))))
      (setf (person.father child)
            (chose-or-make-person p (format nil "New father for ~S?"
                                                (person.name child)))))
  p)

(defaction delete-spouse ((p person) (spouse person))
  (setf (person.spouses p) (delete spouse (person.spouses p)))
  (setf (person.spouses spouse) (delete p (person.spouses spouse)))
  p)

(defmethod render-on ((res response) (v person-viewer))
  (with-slots (name sex birthdate mother father children spouses)
      (person v)
    ;; yes, this mess should be class->table macro,
    (<:table
     (<:tr (<:td "Name:") (<:td (<:as-html name)
                                (<ucw:a (lambda () (change-name (person v)))
                                        "Change Name.")))
     (<:tr (<:td "Sex:") (<:td (<:as-html sex)
                               (<ucw:a (lambda () (change-sex (person v)))
                                       "Change Sex.")))
     (<:tr (<:td "Mother:") (<:td (<ucw:a (lambda () (view mother))
                                          (<:as-html (person.name mother)))
                                  (<ucw:a (lambda () (change-mother (person v)))
                                          "Change Mother.")))
     (<:tr (<:td "Father:") (<:td (<ucw:a (lambda () (view father))
                                          (<:as-html (person.name father)))
                                  (<ucw:a (lambda () (change-father (person v)))
                                          "Change Father.")))
     (<:tr (<:td "Children:")
           (<:td
            (<:ul
             (dolist (c children)
               (<:li (<ucw:a (lambda () (view c)) (<:as-html (person.name c)))
                     (<ucw:a (lambda () (delet-child (person v) c)) "Delete.")))
             (<ucw:a (lambda () (add-child (person v))) "Add a child."))))
     (<:tr (<:td "Spouses:")
           (<:td
            (<:ul
             (dolist (s spouses)
               (<:li (<ucw:a (lambda () (view s)) (<:as-html (person.name s)))
                     (<ucw:a (lambda () (delete-spouse (person v) s)) "Delete."))))
            (<ucw:a (lambda () (add-spouse (person v))) "Add a spouse."))))
    (<ucw:a (lambda () (make-new-person (make-instance 'new-person :person (make-instance 'person))))
            "Create a new person.")
    (<ucw:a (lambda () (answer-component v (person v))) "Ok.")))

;;; creating new people

I didn't know ucw, but it seems to be a web development package. Then
it does not really access the type if (interactive) applications I
need for my projects, but covers mainly the HTTP/HTML part, right? But
this is Ok, as you said, if we settle on certain types of apps.

So now it would be interesting to separate the parts which implement a
general API (the "abstractions") from those which a special for the
demo application (the "elaborations") to see the resulting
succinctness.

Explanation: In my usual work I have to write such applications
permanently, and then there are much more complicated relations than
in the given spec, between tens or hundreds of classes, so we cannot
code these things explicitly each time.

- Alex

--

- Alex

--

I think it is ok to use JavaScript in a web page, but its use should
be restricted to form validation to reduce traffic back and forth
between the client and server.  The application should not rely on the
JavaScript being turned on.

I've seen many sites where links call JavaScript functions.  They
don't seem to do it for any particular reason other than that they
can.  I think this should be a crime.

In many ways, going with pure HTML simplifies UI design for web
applications.  You no longer have to worry about the annoying
differences between JavaScript implementations.  You are just
generating text for your output, not code.  It's a practical
application of Occam's razor.

- Alex

--

"Alexander Burger" <a...@software-lab.de> wrote

It's /almost/ as if Microsoft were /intentionally/ introducing compatibility
problems. Imagine that! :-O

Plain HTML (with or without server- or browser-based scripting) does
not allow a life connection between the client and the server, so the
GUI handling of the resulting applications is always limited.

For example, our customers are used to applications
- where keyboard input is expanded automatically from the database
- immediate responses to function keys acting on the database
- pop-up dialogs and menus which handle database contents
- unlimited table scrolling through the database

For a more complete application than the simple person database take a
loot at "http://bws.software-lab.biz", which is a scaled-down version
of a real application. It may not be fully functional because we were
too lazy to generate all necessary test data, but you'll get an idea.
Login with "test" and "test" and play around a little.

- Alex

--

- enable/disable GUI components depending on the current state of the
  database and the activities of other users

- Alex

--

And also :
Simultaneous update of all the views for all the users when a value changes.
On the fly pdf generation with cl-pdf and cl-typesetting,
It works trough firewalls and proxies.
(cf the ILC2002 paper for details)

I was trying many times to get away from Java (that's also the reason
for the experiments in "lib/htm.l" I mentioned before), not because of
security reasons, but because of poor Java support across many
platforms.

As you said, it depends very much on the purpose. A web application is
probably easier for an un-initiated user, but for people who have to
work with it 8 hours a day a dedicated application might be preferred.

It would be nice if you could post a solution to the simple person
database of my original posting, using your framework.

- Alex

--

(defclass person nil
  ((name :value-type string :user-name #T(:en "Name" :fr "Nom" :de "" :sp ""
:it "") :disable-predicate 'locked-name)
   (locked-name :value-type boolean :user-name #T(:en "Lock name" :fr
"Verouiller nom" :de "" :sp "" :it ""))
   (sex :value-type symbol :user-name #T(:en "Sex" :fr "Sexe" :de "" :sp ""
:it "") :initform :male)
   (bithdate :value-type :date :user-name #T(:en "Birth date" :fr "Date de
naissance" :de "" :sp "" :it ""))
   (father :value-type person :user-name #T(:en "Father" :fr "Père" :de ""
:sp "" :it "") :get-object-func 'choose-father)
   (mother :value-type person :user-name #T(:en "Mother" :fr "Mère" :de ""
:sp "" :it "") :get-object-func 'choose-mother)
   (maried :value-type boolean :user-name #T(:en "Maried" :fr "Marié" :de ""
:sp "" :it ""))
   (spouse :value-type person :user-name #T(:en "Spouse" :fr "Conjoint" :de
"" :sp "" :it "") :disable-predicate '(not maried) :get-object-func
'choose-spouse))
  (:user-name #T(:en "Person" :fr "Personne" :de "" :sp "" :it "") :guid
39944127642591635827640405902 :short-description 'name))

(defun choose-father (obj)
  (remove obj
     (remove :female (persons *all-persons*) :key 'sex)))

(defun choose-mother (obj)
  (remove obj
     (remove :male (persons *all-persons*) :key 'sex)))

(defun choose-spouse (obj)
  (nset-difference
   (remove (sex obj)(persons *all-persons*) :key 'sex)
   (list obj (father obj)(mother obj))))

(defmethod (setf spouse) :around (spouse (obj person))
  (let ((prev-spouse (spouse obj)))
    (unless (eq prev-spouse spouse)
      (call-next-method)
      (when prev-spouse
 (setf (maried prev-spouse) nil))
      (when spouse
 (setf (maried spouse) t
       (spouse spouse) obj)))))

(defmethod (setf maried) :before (maried (obj person))
  (let ((spouse (spouse obj)))
    (when (not maried)
      (setf (spouse obj) nil))))

(defmethod (setf sex) :before (value (obj person))
  (unless (eq value (sex obj))
    (setf (maried obj) nil)))

The ability to make an interactive application with a pure HTML
interface (no JavaScript) that approaches the interactivity of a local
desktop application is something I find very appealing at this time.

There is of course the academic (or perhaps not so academic) curiosity
that I have about the future being server based applications, a place
where I could use Lisp or any other language I want.  There is also a
more practical problem that I am working on where a desktop app looks
like the only way to produce the required interactivity, but I am not
so sure and would love to do it as a pure web based app.

Brian Mastenbrook demoed a web based IRC application.  It's not as
good as a "real" IRC client, but it will run on a web enabled phone
without having to install any special software on the phone.  It was
really cool.