Re: Org and Hyperbole

[Jean Louis <bugs@gnu.support>]

* Robert Weiner <rsw@gnu.org> [2022-10-09 00:06]:
> We had object-based, multi-media files with Engelbart's NLS/Augment
> system.  We had relational databases way before the web.
> 
> But here we are in 2022 with enormous personal computing power and for
> interactive editing, everyone is using and transferring stream-based files
> of characters that are then interpreted at the delivery site.

Alright, though I do not see relation from transferring files to
databases. Just any digital information may be transferred to delivery
sites by many different means. I understand that two paragraphs are
related and I inject my thoughts in maybe not proper place.

> There are many reasons for this including limits in many
> organizations of the file types that may be transferred through
> common protocols and the difficulty of maintaining relational
> database or structured file type schemas across time.

I can't see how relational database is more difficult to maintain then
for example Emacs itself. Emacs is master of difficulties for computer
user. For example I have not touched configuration files for
PostgreSQL since years, if not decades. I start wondering why.

Backing up relational database is so much easier than backing up
plethora of apparently randomly dispersed files. It is just single
command line or click on some graphical interface. Just do
`pg_dumpall'. 

Let us say I wish to backup all the information that Hyperbole created
in various directories, on computer, is there such option? Missing.

We can't compare apples and eggs, but I have to give you for thinking. 

Hyperbole buttons in their files are underlying structure, user need
not know anything about it. User has interface and uses higher level
interface functions.

But let us analyze it little that way. If you have a Hyrolo file, what
you can do with it? You can send it to somebody? But that somebody
need to use what? Emacs or any editor to work with contacts.

Today users use mobile devices, they exchange structured contact
information by using vCard format, and users of many mobile devices can
accept contact information from other operating systems and import in
their phones as one or multiple without problems.

Hyrolo can't transfer contact information. And why? Because it is
written more or less freely in the text file and it is not structured. 

We don't speak of maintaining Hyrolo -- that is not easy task really,
it needs GNU Emasc which has so many dependencies, then it needs
Hyperbole, then user can handle Hyrolo. What I want to say we shall
not think of complexities, issues of installation and underlying
management by software are not concern for user. User shall be able to
click and get application. That is what 50% of people using computers
know, they have mobile devices, they click and get it. No thinking
there, but I don't say it advances society that way.

In any relational databases there are views and various exports and
unlimited variations how final data may be presented to user.

Let us say contacts, that may be transferred by using vCard
mechanism. Various other formats are possible.

Let us say I need to exchange tasks, that is what I do all the
time. Nobody at delivery site need know that I have underlying
PostgreSQL database, that is not their business. They will get the
PDF, image, video, text, WWW link, ZIP, and similar. Delivery site
will get it delivered in the format how they can read it.

If delivery site needs full database, it is just matter of two
commands pg_dumpall and pg_restore and even those commands may be
automated.

Full database is similar to file system. One does not share file
system, one shares database entries. And how such entries are shared
depends of the programmer and user. Thousands of entries from my
database are shared through web server and as HTML documents. Program
generates PDF files and text, and emails for plans, programs and
projects, and such are shared by any type of communication channel.

> Simple tends to win out over more powerful because few people want to bear
> the cost of continual training to raise all of the newcomers to a level of
> performance that they cannot teach themselves.

Today people use structured information without knowing. Contacts on
phone are structured. Even notes' applications on mobile devices are
pretty much structured, usually stored in SQLited databases and
exported in various ways. Much of information in any libraries, online
databases, and personal computers is stored in such databases.

> I like your model, Jean, and am a fan of such things but I am also
> pragmatic and thus focus on building things that I think people will
> consume within a given environment.

In the Emacs environment we consume anything that is useful, it is
wide open. Emacs 29 comes with SQLite built-in. That is advance,
progress. 

We can progress all with databases.

>  In Hyperbole's case, it is base Emacs and nothing more.

Emacs alone has many ways to store ordered and structured
information.

> If you are familiar with what it takes to standup a scalable web
> application today (what everyone wants), you understand why that is
> not a great model for systems where the users have to manage and
> customize the infrastructure themselves.

I can't. 

What I think is that you never tried it out and did not understand
that database minimizes human efforts and errors. It minimizes our
efforts also because many functions you have programmed for Hyperbole
and many functions people do in Org are already built-in in the
database.

There are many various systems that use ordered information.

Example is Leo editor:

Leo programmable editor:
http://leoeditor.com/

Leo editor vs Org-mode:
https://leoeditor.com/emacs.html

I guess it fully uses database and thus it can handle ordered
information so much easier.

I have examined hyrolo-add function, it only adds a single name to the
file. And function is that huge.

Here is function that adds name, email and description in the simple database:

(defun my-people-add ()
  (interactive)
  (let* ((first-name (read-string "First name: "))
	 (middle-names (read-string "Middles names: "))
	 (name-or-last-name (let ((result))
			      (while (not result)
				(setq result (apply 'read-string '("Last name: "))))
			      result))
	 (email (read-string "Email: "))
	 (description (read-string "Description: ")))
    (sqlite-execute my-db "INSERT INTO people (people_firstname, people_middlenames, people_name, people_email, people_description)
                           VALUES (?, ?, ?, ?, ?) RETURNING people_id" 
		    (list first-name middle-names name-or-last-name description))))

And then we speak of internal and external complexities. But those are
subjective opinions.

What is objective is to see the how big is the code that handles
purely text (and never reaches the point of being deterministic) and
the size of code that handles equivalent functions using database.

-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/