Fortran Topics (outline-minor-mode, require, fixed format)

Fortran Topics (outline-minor-mode, require, fixed format)

[ludvig-faddeev]

We want to know how to set up three things.

outline-minor-mode oriented

1. How to include headings and subheadings for fortran (fixed and free format)
2. Code structure hiding (subroutine, function)
3. Setting up new heading lists (outline-regexp, outline-heading-alist)

Other things

Remove the need to call "(require 'f90)" and "(require 'fortran)" in conformity
with other languages (e.g. as in emacs-lisp-mode, texinfo-mode)

Remove need to have separate modes for fixed and free format (fortran, f90).
Instead have only "fortran-mode" with a variable for fixed format setting
for use when needed by the user. These days fortran-mode mostly caters for
legacy fortran code.

Re: Fortran Topics (outline-minor-mode, require, fixed format)

[Emanuel Berg via Users list for the GNU Emacs text editor]

ludvig-faddeev wrote:

> We want to know how to set up three things.
>
> outline-minor-mode oriented
>
> 1. How to include headings and subheadings for fortran
>    (fixed and free format)
> 2. Code structure hiding (subroutine, function)
> 3. Setting up new heading lists (outline-regexp,
>    outline-heading-alist)

OK, don't know/understand what 1 and 3 means, again did you
get it to work somewhere else?

2 I do understand but have no desire for myself so don't know
the details, again I'd check out how it is done elsewhere if
I wanted it.

> Other things
>
> Remove the need to call "(require 'f90)" and "(require
> 'fortran)" in conformity with other languages (e.g. as in
> emacs-lisp-mode, texinfo-mode)

Well, easy enough to do and conformity is very difficult
(impossible) to ever achieve anyway.

> Remove need to have separate modes for fixed and free format
> (fortran, f90). Instead have only "fortran-mode" with
> a variable for fixed format setting for use when needed by
> the user. These days fortran-mode mostly caters for legacy
> fortran code.

Okay.

-- 
underground experts united
https://dataswamp.org/~incal

Re: Fortran Topics (outline-minor-mode, require, fixed format)

[Jean Louis]

* Emanuel Berg via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> [2021-05-29 23:16]:
> > outline-minor-mode oriented
> >
> > 1. How to include headings and subheadings for fortran
> >    (fixed and free format)
> > 2. Code structure hiding (subroutine, function)
> > 3. Setting up new heading lists (outline-regexp,
> >    outline-heading-alist)
> 
> OK, don't know/understand what 1 and 3 means, again did you
> get it to work somewhere else?

In Fortran the comment is ! and how somebody wish to set headings is
really personal choice.

I use just one heading in Emacs Lisp:

;;;; ↝ MY EMACS LISP FUNCTIONS

And I like using Unicode that way.

;;;; ⧭⧭⧭⧭⧭⧭⧭⧭⧭ Or maybe like this

All that can work. Is it visual enough? That is what matters.

Or how about:

;⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞
;⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞                      ⮜⮜⮜⮜⮜⮜⮜⮜⮜⮜⮜⮜
;⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞ Emacs Lisp Functions ⮜⮜⮜⮜⮜⮜⮜⮜⮜⮜⮜⮜
;⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞                      ⮜⮜⮜⮜⮜⮜⮜⮜⮜⮜⮜⮜
;⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞

I like those.

Headings and subheadings in outline mode don't exist in Fortran as a
language.  Outline Minor Mode is universal it is up to user to decide
what is heading and what not.

All of the above depends of settings, right?

> > Remove the need to call "(require 'f90)" and "(require
> > 'fortran)" in conformity with other languages (e.g. as in
> > emacs-lisp-mode, texinfo-mode)
> 
> Well, easy enough to do and conformity is very difficult
> (impossible) to ever achieve anyway.

Reference here:
https://www.emacswiki.org/emacs/FortranMode

(add-to-list 'auto-mode-alist '("\\.f\\'" . f90-mode))


-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Fortran Topics (outline-minor-mode, require, fixed format)

[Christopher Dimech]

> Sent: Sunday, May 30, 2021 at 8:48 AM
> From: "Jean Louis" <bugs@gnu.support>
> To: help-gnu-emacs@gnu.org
> Subject: Re: Fortran Topics (outline-minor-mode, require, fixed format)
>
> * Emanuel Berg via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> [2021-05-29 23:16]:
> > > outline-minor-mode oriented
> > >
> > > 1. How to include headings and subheadings for fortran
> > >    (fixed and free format)
> > > 2. Code structure hiding (subroutine, function)
> > > 3. Setting up new heading lists (outline-regexp,
> > >    outline-heading-alist)
> > 
> > OK, don't know/understand what 1 and 3 means, again did you
> > get it to work somewhere else?
> 
> In Fortran the comment is ! and how somebody wish to set headings is
> really personal choice.
> 
> I use just one heading in Emacs Lisp:
> 
> ;;;; ↝ MY EMACS LISP FUNCTIONS

In emacs-lisp-mode, outline-minor-mode uses ;; as level 1 heading, 
;;; as level 2 heading, ;;;; as level 3 heading etc.

For fortran-mode and f90 mode, outline-minor-mode could be set the same way.

!! Heading Level 1
!!! Subheading Level 2
!!!! SubSubHeading Level 3

Have tried doing "Hide Body" for comments starting with "!" (free format) or 
"C" (fixed form).  But does not look that "Hide Body" does anything.

Then users can change them if they want something else or additional settings.

For emacs-lisp-mode, outline-minor-mode can hide strucutres starting with "(".

For fortran, there can be hiding for lines starting with "subroutine" and "function"
when outline-minor-mode in enabled.

Could send a bug report for a feature request.  What do you think Jean?


> 
> And I like using Unicode that way.
> 
> ;;;; ⧭⧭⧭⧭⧭⧭⧭⧭⧭ Or maybe like this
> 
> All that can work. Is it visual enough? That is what matters.
> 
> Or how about:
> 
> ;⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞
> ;⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞                      ⮜⮜⮜⮜⮜⮜⮜⮜⮜⮜⮜⮜
> ;⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞ Emacs Lisp Functions ⮜⮜⮜⮜⮜⮜⮜⮜⮜⮜⮜⮜
> ;⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞                      ⮜⮜⮜⮜⮜⮜⮜⮜⮜⮜⮜⮜
> ;⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞⮞
> 
> I like those.
> 
> Headings and subheadings in outline mode don't exist in Fortran as a
> language.  Outline Minor Mode is universal it is up to user to decide
> what is heading and what not.
> 
> All of the above depends of settings, right?
> 
> > > Remove the need to call "(require 'f90)" and "(require
> > > 'fortran)" in conformity with other languages (e.g. as in
> > > emacs-lisp-mode, texinfo-mode)
> > 
> > Well, easy enough to do and conformity is very difficult
> > (impossible) to ever achieve anyway.
> 
> Reference here:
> https://www.emacswiki.org/emacs/FortranMode
> 
> (add-to-list 'auto-mode-alist '("\\.f\\'" . f90-mode))

They also can do that with the rest

  (add-to-list 'auto-mode-alist '("\\.f95\\'" . f90-mode))
  (add-to-list 'auto-mode-alist '("\\.f03\\'" . f90-mode))
  (add-to-list 'auto-mode-alist '("\\.f08\\'" . f90-mode))

Regards
Christopher

> 
> -- 
> Jean
> 
> Take action in Free Software Foundation campaigns:
> https://www.fsf.org/campaigns
> 
> Sign an open letter in support of Richard M. Stallman
> https://stallmansupport.org/
> 
>

Re: Fortran Topics (outline-minor-mode, require, fixed format)

[Jean Louis]

* Christopher Dimech <dimech@gmx.com> [2021-05-30 00:26]:
> For fortran-mode and f90 mode, outline-minor-mode could be set the same way.
> 
> !! Heading Level 1
> !!! Subheading Level 2
> !!!! SubSubHeading Level 3

I think it is user's choice. I did not find any pre-settings.

> Have tried doing "Hide Body" for comments starting with "!" (free format) or 
> "C" (fixed form).  But does not look that "Hide Body" does anything.

It does on my side. To activate settings that I did on the fly, I had
to do twice M-x outline-minor-mode

> Then users can change them if they want something else or additional settings.
> 
> For emacs-lisp-mode, outline-minor-mode can hide strucutres starting with "(".
> 
> For fortran, there can be hiding for lines starting with "subroutine" and "function"
> when outline-minor-mode in enabled.

I think that is users' choice.

> Could send a bug report for a feature request.  What do you think
> Jean?

I think that few variables are not customizable, but there is no need
for feature request related to headings for specific mode as
outline-minor-mode is a users' choice.

General settings could be better, I have already explained how it
could work, but it is up to developers to decide on it. 

-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Fortran Topics (outline-minor-mode, require, fixed format)

[Christopher Dimech]

> Sent: Sunday, May 30, 2021 at 9:56 AM
> From: "Jean Louis" <bugs@gnu.support>
> To: "Christopher Dimech" <dimech@gmx.com>
> Cc: help-gnu-emacs@gnu.org
> Subject: Re: Fortran Topics (outline-minor-mode, require, fixed format)
>
> * Christopher Dimech <dimech@gmx.com> [2021-05-30 00:26]:
> > For fortran-mode and f90 mode, outline-minor-mode could be set the same way.
> >
> > !! Heading Level 1
> > !!! Subheading Level 2
> > !!!! SubSubHeading Level 3
>
> I think it is user's choice. I did not find any pre-settings.
>
> > Have tried doing "Hide Body" for comments starting with "!" (free format) or
> > "C" (fixed form).  But does not look that "Hide Body" does anything.
>
> It does on my side. To activate settings that I did on the fly, I had
> to do twice M-x outline-minor-mode
>
> > Then users can change them if they want something else or additional settings.
> >
> > For emacs-lisp-mode, outline-minor-mode can hide strucutres starting with "(".
> >
> > For fortran, there can be hiding for lines starting with "subroutine" and "function"
> > when outline-minor-mode in enabled.
>
> I think that is users' choice.

Yes.  For emacs-lisp-mode, there are some default settings already.
I rather not force users to first learn elisp before being able to
easily work on their code.

> > Could send a bug report for a feature request.  What do you think
> > Jean?
>
> I think that few variables are not customizable, but there is no need
> for feature request related to headings for specific mode as
> outline-minor-mode is a users' choice.
>
> General settings could be better, I have already explained how it
> could work, but it is up to developers to decide on it.

Agreed then.

> --
> Jean
>
> Take action in Free Software Foundation campaigns:
> https://www.fsf.org/campaigns
>
> Sign an open letter in support of Richard M. Stallman
> https://stallmansupport.org/
>

How users start programming in Emacs Lisp...

[Jean Louis]

* Christopher Dimech <dimech@gmx.com> [2021-05-30 01:08]:
> Yes.  For emacs-lisp-mode, there are some default settings already.
> I rather not force users to first learn elisp before being able to
> easily work on their code.

When any user is setting any variable that is already Emacs Lisp. Is
is a slight subterfuge, we call it "customization" but user starts
already programming in Lisp. 

*scratch* buffer is famous for it.

I just need more of them but *scratch*, so I do it this way:

;;;; ↝ RCD TEMPORARY BUFFERS

(defvar rcd-temp-buffer-mode-history nil)

(defun rcd-temp-buffer (&optional name mode)
  (interactive "p")
  (let* ((format "*RCD TEMPORARY BUFFER%s%s*")
	 (buffer (if name (format format ": " name) (format format "" ""))))
    (switch-to-buffer (generate-new-buffer "*RCD TEMPORARY BUFFER*"))
    (if current-prefix-arg
	(let* ((modes '("adoc-mode" "emacs-lisp-mode" "lisp-mode" "markdown-mode"
			 "org-mode" "sql-mode" "fundamental-mode" "html-mode"))
	       (mode (completing-read "Mode: " modes nil t nil 'rcd-temp-buffer-mode-history)))
	  (funcall (intern mode)))
    (funcall (intern (or mode "fundamental-mode"))))))

(defun rcd-temp-buffer-destroy-em ()
  (kill-matching-buffers "RCD TEMPORARY BUFFER"))



-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Jean Louis wrote:

> When any user is setting any variable that is already Emacs
> Lisp. Is is a slight subterfuge, we call it "customization"
> but user starts already programming in Lisp.

And conversely, do enough Lisp and what happens is that many
of these people end up Emacs users.

-- 
underground experts united
https://dataswamp.org/~incal

How users start programming in Emacs Lisp...

[Christopher Dimech]

> Sent: Sunday, May 30, 2021 at 10:37 AM
> From: "Jean Louis" <bugs@gnu.support>
> To: "Christopher Dimech" <dimech@gmx.com>
> Cc: help-gnu-emacs@gnu.org
> Subject: How users start programming in Emacs Lisp...
>
> * Christopher Dimech <dimech@gmx.com> [2021-05-30 01:08]:
> > Yes.  For emacs-lisp-mode, there are some default settings already.
> > I rather not force users to first learn elisp before being able to
> > easily work on their code.
> 
> When any user is setting any variable that is already Emacs Lisp. Is
> is a slight subterfuge, we call it "customization" but user starts
> already programming in Lisp. 
> 
> *scratch* buffer is famous for it.
> 
> I just need more of them but *scratch*, so I do it this way:
> 
> ;;;; ↝ RCD TEMPORARY BUFFERS
> 
> (defvar rcd-temp-buffer-mode-history nil)
> 
> (defun rcd-temp-buffer (&optional name mode)
>   (interactive "p")
>   (let* ((format "*RCD TEMPORARY BUFFER%s%s*")
> 	 (buffer (if name (format format ": " name) (format format "" ""))))
>     (switch-to-buffer (generate-new-buffer "*RCD TEMPORARY BUFFER*"))
>     (if current-prefix-arg
> 	(let* ((modes '("adoc-mode" "emacs-lisp-mode" "lisp-mode" "markdown-mode"
> 			 "org-mode" "sql-mode" "fundamental-mode" "html-mode"))
> 	       (mode (completing-read "Mode: " modes nil t nil 'rcd-temp-buffer-mode-history)))
> 	  (funcall (intern mode)))
>     (funcall (intern (or mode "fundamental-mode"))))))
> 
> (defun rcd-temp-buffer-destroy-em ()
>   (kill-matching-buffers "RCD TEMPORARY BUFFER"))

I wonder how you call the buffer optional parameters

C-u 8 C-u 5 M-x rcd-temp-buffer

Could you pass a buffer-name and mode as strings, or just the number as
position in the corresponding list?

Re: How users start programming in Emacs Lisp...

[Eduardo Ochs]

On Sat, 29 May 2021 at 23:12, Christopher Dimech <dimech@gmx.com> wrote:
>
> > Sent: Sunday, May 30, 2021 at 10:37 AM
> > From: "Jean Louis" <bugs@gnu.support>
> > To: "Christopher Dimech" <dimech@gmx.com>
> > Cc: help-gnu-emacs@gnu.org
> > Subject: How users start programming in Emacs Lisp...
> >
> > (...)
> >
> > *scratch* buffer is famous for it.
> >
> > I just need more of them but *scratch*, so I do it this way:


Hi, just a curiosity...

why do you prefer to use scratch buffers for elisp code instead of
using (semi-scratch?) files in which we record all our experiments?

In the tutorials of eev I try to convince the new users to treat their
notes and scratch code as "field notes", and save everything they
can... one of my arguments is this:

  Learning eev is also like learning to use paper notebooks. It is
  much easier to understand the notes and ideas what we wrote
  ourselves in our notebooks than to understand what other people
  wrote in their notebooks... when we go back to what _we_ wrote we
  are able to reconnect with what we were thinking, even when our
  notes are quite terse because we did not write down all details -
  and we can't do that with other people's notes.

  (From:)
  http://angg.twu.net/eev-intros/find-here-links-intro.html
  (find-here-links-intro)

Grepping and `C-s'-ing our own notes is easy, and most of the time we
can read - and reuse - what we wrote.

By the way (for Christopher): eev has a hands-on elisp tutorial. It's
here:

  http://angg.twu.net/eev-intros/find-elisp-intro.html
  (find-elisp-intro)



Cheers,
  Eduardo Ochs
  http://angg.twu.net/#eev

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Eduardo Ochs <eduardoochs@gmail.com> [2021-05-30 07:33]:
> Hi, just a curiosity...
> 
> why do you prefer to use scratch buffers for elisp code instead of
> using (semi-scratch?) files in which we record all our experiments?

I use *scratch* buffer long time. It is for things that need not be
saved. There is `persistent-scratch' library loaded that does save it
over the sessions. However, whatever I write there is not of
importance if it is lost.

And temporary buffers I use because I don't want to save such. That is
where I evaluate and test things that don't belong to any file neither
should be saved. Bufffer could be saved though if necessary. 

> In the tutorials of eev I try to convince the new users to treat their
> notes and scratch code as "field notes", and save everything they
> can... one of my arguments is this:

Then it is not temporary any more, not scratch any more. Not something
being free to forget it and drop it. Temporary buffer is just a more
static version of IELM, or more expanded version of M-: so things in
M-: evaluation I also don't save; with the difference that scratch
buffer is separated from other buffers, it will not work with buffer
variables, and in my case I never need such.

Example text in Emacs Lisp scratch that still hangs there is the stuff
with Fortran discussion where some testing of outline-minor-mode was required:

```
outline-regexp ⇒ "[*\f]+"
(setq outline-regexp "[!\f]+")
outline-heading-alist ⇒ nil
(setq outline-heading-alist '(("!" . 1) ("!!" . 2) ("!!!" . 3)))

!     ! Something
      Program
      nOK
!!!     Somethingp
!     Something
      More
Something
```

that stuff I would not save. The point learned is that there are
variables to be set for outline-minor-mode for it to make it work. I
don't need to know which variables, I will find them in future by
inspecting {C-h v outline TAB} list of variables or by 
{M-x customize-group RET outlines RET}

> Learning eev is also like learning to use paper notebooks. It is
> much easier to understand the notes and ideas what we wrote
> ourselves in our notebooks than to understand what other people
> wrote in their notebooks... 

That is right. I like any guidances related to notes, you remember
that I switched from Org and file system based editing to mostly
database backed column's value editing so it is always relevant to
me. `eev' can be used there I guess.

> when we go back to what _we_ wrote we are able to reconnect with
> what we were thinking, even when our notes are quite terse because
> we did not write down all details - and we can't do that with other
> people's notes.

That is right. What is interesting in my system is that I have:

- dates that are relevant to creation of a node (which can be of any type);

- dates relevant to modification of a node;

- which user in collaboration created it, or modified it;

- any access and additional actions on a single node/document are
  recorded, for example change of a name from Johnny to John would be
  recorded by its date/time and by user name;

- any activation of a node/document, like opening of a hyperlink is
  recorded too, automatically; if user did read the note, or modified
  the node/document, or opened up the document is recorded;

- and so on; that all works without disturbance for user;

Then the whol track or history can be played back, it is possible to
find out:

- which people or participants where assigned to tasks or documents at
  specific times, dates in past;

- which stuff was researched back in time;

- related to which groups, companies, organizations, people, projects,
  etc.

Those are not main feautures, just side effects. 

Some of such features are within these Hyperscope ring functions:

;;;; ↝ HYPERSCOPE RING FUNCTIONS

Here is the variable initialization defined by fetching information
from a database:

(defvar hyperscope-ring-current
  (rcd-sql-first "SELECT hyperscopering_id FROM hyperscopering ORDER BY hyperscopering_id DESC LIMIT 1" hs-db)
  "Hyperscope's current ring item.")

The "ring" remains in the database and can be stored in a variable,
but it is persistent along sessions.

(defvar hyperscope-ring
  (rcd-sql-list "SELECT hyperscopering_hyperdocument FROM hyperscopering ORDER BY hyperscopering_id DESC" hs-db)
"Hyperscope ring uses RCD utilities function
  `next-circular-list-item'")

However	it is not yet upgraded for multiple users, as then I just need
to add the columns like `usercreated' and `usermodified' so that ring
becomes collaborative:

 hyperscopering_id            | integer                     |
 hyperscopering_datecreated   | timestamp without time zone |
 hyperscopering_datemodified  | timestamp without time zone |
 hyperscopering_usercreated   | text                        |
 hyperscopering_usermodified  | text                        |
 hyperscopering_hyperdocument | integer                     |
 hyperscopering_description   | text                        |

Then instead of this function:

(defvar hyperscope-ring-current
  (rcd-sql-first "SELECT hyperscopering_id FROM hyperscopering WHERE ORDER BY hyperscopering_id DESC LIMIT 1" hs-db)
  "Hyperscope's current ring item.")

I would need to use this one:

(defvar hyperscope-ring-current
  (rcd-sql-first "SELECT hyperscopering_id FROM hyperscopering WHERE hyperscopering_usercreated = current_user ORDER BY hyperscopering_id DESC LIMIT 1" hs-db)
  "Hyperscope's current ring item.")

As that one would choose only those items related to current user of
the database. Thus multiple users can contribute documents where all
things get tracked.

Choosing the last item accessed or activated is easy:

(defun hyperscope-ring-last ()
  (rcd-sql-first "SELECT hyperscopering_hyperdocument FROM hyperscopering WHERE hyperscopering_usercreated = current_user ORDER BY hyperscopering_id DESC LIMIT 1" hs-db))

Updating new items is just calling the function, while ignoring
duplicates (who knows maybe duplicates are also important):

(defun hyperscope-ring (id)
  "Setup Hyperscope ring"
  (let ((last (hyperscope-ring-last)))
    (cond ((null last) (hyperscope-ring-update id))
	  ((= last id) (ignore))
	  (t (hyperscope-ring-update id)))))

And here is how somebody is recording everything within Memacs:

Memacs
https://github.com/novoid/Memacs

>   (From:)
>   http://angg.twu.net/eev-intros/find-here-links-intro.html
>   (find-here-links-intro)
> 
> Grepping and `C-s'-ing our own notes is easy, and most of the time we
> can read - and reuse - what we wrote.

Often I am re-using notes, or duplicating it to have a new version,
single click, and then editing new version. Unless those are some
disposable notes.

Then again I have a `hyperscope-capture-buffer' function where
whatever I write in other buffer is captured in the dynamic knowledge
repository. Then such function leaves a link like this one, as if I
placed the "stamp" in the email, I can quicker find some important
email captured as a note: (hyperscope 38116)

Description of such note is:

* Captured Buffer Text

Buffer name: mutt-protected-1001-4182-5758066564440477891
Buffer file: /home/data1/protected/tmp/mutt-protected-1001-4182-5758066564440477891
Time captured:  2021-05-30-09:34:13

Why would anybody "capture" one's own buffer? Well, why not, it can be
single key, some text that can be re-used for later or re-ordered for
articles. The difference is that "grep" need not be used but full text
search and results for searching "eev" appear almost instantly. A node
can be related to Eduardo Ochs and later the notes related to single
person can be listed. 

A classic file system allows user tags and group tags, but nothing
about relations to other people, groups, organizations, various
activities or businesses. 

> By the way (for Christopher): eev has a hands-on elisp tutorial. It's
> here:
> 
>   http://angg.twu.net/eev-intros/find-elisp-intro.html
>   (find-elisp-intro)

Hyperlink generation functions are useful. I don't know if I can use
such to enter URL into the database for example, you tell me.

You have PDF link generation functions. But is it generic that I could
connect it to something else? For example to invoke a key, capture the
PDF URL or URL or file system location (also link) and return it as
link which can be then entered in the database. Or is it hard coded?

And finally why not integrate the database in your system, it would
help greatly. Install this module:

emacs-libpq @ Github
https://github.com/anse1/emacs-libpq

Then install this package:

RCD Database Basics
https://hyperscope.link/3/7/4/9/3/RCD-Database-Basics-37493.html

Then use M-x cf-sql-table to design your own first SQL table. 

Integrate eev with permanent database backed information.


-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Eduardo Ochs]

Hi Jean Louis,

I did this,

  sudo apt-get install libpq-dev postgresql

  rm -Rfv ~/usrc/emacs-libpq/
  cd      ~/usrc/
  git clone https://github.com/anse1/emacs-libpq
  cd      ~/usrc/emacs-libpq/

  cd ~/usrc/emacs-libpq/
  make clean
  make \
    EMACS=$HOME/bigsrc/emacs28/src/emacs \
    EMACS_INCLUDE_DIR=$HOME/bigsrc/emacs28/src/ \
    all check \
    2>&1 | tee om

and "make check" failed with several errors like this:

  Test pq-async-notify-test condition:
      (error "FATAL:  role \"edrx\" does not exist\12")

What should I do?
  Cheers, E.
    http://angg.twu.net/#eev

On Sun, 30 May 2021 at 04:07, Jean Louis <bugs@gnu.support> wrote:
>
> * Eduardo Ochs <eduardoochs@gmail.com> [2021-05-30 07:33]:
> > Hi, just a curiosity...
> >
> > why do you prefer to use scratch buffers for elisp code instead of
> > using (semi-scratch?) files in which we record all our experiments?
>
> I use *scratch* buffer long time. It is for things that need not be
> saved. There is `persistent-scratch' library loaded that does save it
> over the sessions. However, whatever I write there is not of
> importance if it is lost.
>
> And temporary buffers I use because I don't want to save such. That is
> where I evaluate and test things that don't belong to any file neither
> should be saved. Bufffer could be saved though if necessary.
>
> > In the tutorials of eev I try to convince the new users to treat their
> > notes and scratch code as "field notes", and save everything they
> > can... one of my arguments is this:
>
> Then it is not temporary any more, not scratch any more. Not something
> being free to forget it and drop it. Temporary buffer is just a more
> static version of IELM, or more expanded version of M-: so things in
> M-: evaluation I also don't save; with the difference that scratch
> buffer is separated from other buffers, it will not work with buffer
> variables, and in my case I never need such.
>
> Example text in Emacs Lisp scratch that still hangs there is the stuff
> with Fortran discussion where some testing of outline-minor-mode was required:
>
> ```
> outline-regexp ⇒ "[* ]+"
> (setq outline-regexp "[! ]+")
> outline-heading-alist ⇒ nil
> (setq outline-heading-alist '(("!" . 1) ("!!" . 2) ("!!!" . 3)))
>
> !     ! Something
>       Program
>       nOK
> !!!     Somethingp
> !     Something
>       More
> Something
> ```
>
> that stuff I would not save. The point learned is that there are
> variables to be set for outline-minor-mode for it to make it work. I
> don't need to know which variables, I will find them in future by
> inspecting {C-h v outline TAB} list of variables or by
> {M-x customize-group RET outlines RET}
>
> > Learning eev is also like learning to use paper notebooks. It is
> > much easier to understand the notes and ideas what we wrote
> > ourselves in our notebooks than to understand what other people
> > wrote in their notebooks...
>
> That is right. I like any guidances related to notes, you remember
> that I switched from Org and file system based editing to mostly
> database backed column's value editing so it is always relevant to
> me. `eev' can be used there I guess.
>
> > when we go back to what _we_ wrote we are able to reconnect with
> > what we were thinking, even when our notes are quite terse because
> > we did not write down all details - and we can't do that with other
> > people's notes.
>
> That is right. What is interesting in my system is that I have:
>
> - dates that are relevant to creation of a node (which can be of any type);
>
> - dates relevant to modification of a node;
>
> - which user in collaboration created it, or modified it;
>
> - any access and additional actions on a single node/document are
>   recorded, for example change of a name from Johnny to John would be
>   recorded by its date/time and by user name;
>
> - any activation of a node/document, like opening of a hyperlink is
>   recorded too, automatically; if user did read the note, or modified
>   the node/document, or opened up the document is recorded;
>
> - and so on; that all works without disturbance for user;
>
> Then the whol track or history can be played back, it is possible to
> find out:
>
> - which people or participants where assigned to tasks or documents at
>   specific times, dates in past;
>
> - which stuff was researched back in time;
>
> - related to which groups, companies, organizations, people, projects,
>   etc.
>
> Those are not main feautures, just side effects.
>
> Some of such features are within these Hyperscope ring functions:
>
> ;;;; ↝ HYPERSCOPE RING FUNCTIONS
>
> Here is the variable initialization defined by fetching information
> from a database:
>
> (defvar hyperscope-ring-current
>   (rcd-sql-first "SELECT hyperscopering_id FROM hyperscopering ORDER BY hyperscopering_id DESC LIMIT 1" hs-db)
>   "Hyperscope's current ring item.")
>
> The "ring" remains in the database and can be stored in a variable,
> but it is persistent along sessions.
>
> (defvar hyperscope-ring
>   (rcd-sql-list "SELECT hyperscopering_hyperdocument FROM hyperscopering ORDER BY hyperscopering_id DESC" hs-db)
> "Hyperscope ring uses RCD utilities function
>   `next-circular-list-item'")
>
> However it is not yet upgraded for multiple users, as then I just need
> to add the columns like `usercreated' and `usermodified' so that ring
> becomes collaborative:
>
>  hyperscopering_id            | integer                     |
>  hyperscopering_datecreated   | timestamp without time zone |
>  hyperscopering_datemodified  | timestamp without time zone |
>  hyperscopering_usercreated   | text                        |
>  hyperscopering_usermodified  | text                        |
>  hyperscopering_hyperdocument | integer                     |
>  hyperscopering_description   | text                        |
>
> Then instead of this function:
>
> (defvar hyperscope-ring-current
>   (rcd-sql-first "SELECT hyperscopering_id FROM hyperscopering WHERE ORDER BY hyperscopering_id DESC LIMIT 1" hs-db)
>   "Hyperscope's current ring item.")
>
> I would need to use this one:
>
> (defvar hyperscope-ring-current
>   (rcd-sql-first "SELECT hyperscopering_id FROM hyperscopering WHERE hyperscopering_usercreated = current_user ORDER BY hyperscopering_id DESC LIMIT 1" hs-db)
>   "Hyperscope's current ring item.")
>
> As that one would choose only those items related to current user of
> the database. Thus multiple users can contribute documents where all
> things get tracked.
>
> Choosing the last item accessed or activated is easy:
>
> (defun hyperscope-ring-last ()
>   (rcd-sql-first "SELECT hyperscopering_hyperdocument FROM hyperscopering WHERE hyperscopering_usercreated = current_user ORDER BY hyperscopering_id DESC LIMIT 1" hs-db))
>
> Updating new items is just calling the function, while ignoring
> duplicates (who knows maybe duplicates are also important):
>
> (defun hyperscope-ring (id)
>   "Setup Hyperscope ring"
>   (let ((last (hyperscope-ring-last)))
>     (cond ((null last) (hyperscope-ring-update id))
>           ((= last id) (ignore))
>           (t (hyperscope-ring-update id)))))
>
> And here is how somebody is recording everything within Memacs:
>
> Memacs
> https://github.com/novoid/Memacs
>
> >   (From:)
> >   http://angg.twu.net/eev-intros/find-here-links-intro.html
> >   (find-here-links-intro)
> >
> > Grepping and `C-s'-ing our own notes is easy, and most of the time we
> > can read - and reuse - what we wrote.
>
> Often I am re-using notes, or duplicating it to have a new version,
> single click, and then editing new version. Unless those are some
> disposable notes.
>
> Then again I have a `hyperscope-capture-buffer' function where
> whatever I write in other buffer is captured in the dynamic knowledge
> repository. Then such function leaves a link like this one, as if I
> placed the "stamp" in the email, I can quicker find some important
> email captured as a note: (hyperscope 38116)
>
> Description of such note is:
>
> * Captured Buffer Text
>
> Buffer name: mutt-protected-1001-4182-5758066564440477891
> Buffer file: /home/data1/protected/tmp/mutt-protected-1001-4182-5758066564440477891
> Time captured:  2021-05-30-09:34:13
>
> Why would anybody "capture" one's own buffer? Well, why not, it can be
> single key, some text that can be re-used for later or re-ordered for
> articles. The difference is that "grep" need not be used but full text
> search and results for searching "eev" appear almost instantly. A node
> can be related to Eduardo Ochs and later the notes related to single
> person can be listed.
>
> A classic file system allows user tags and group tags, but nothing
> about relations to other people, groups, organizations, various
> activities or businesses.
>
> > By the way (for Christopher): eev has a hands-on elisp tutorial. It's
> > here:
> >
> >   http://angg.twu.net/eev-intros/find-elisp-intro.html
> >   (find-elisp-intro)
>
> Hyperlink generation functions are useful. I don't know if I can use
> such to enter URL into the database for example, you tell me.
>
> You have PDF link generation functions. But is it generic that I could
> connect it to something else? For example to invoke a key, capture the
> PDF URL or URL or file system location (also link) and return it as
> link which can be then entered in the database. Or is it hard coded?
>
> And finally why not integrate the database in your system, it would
> help greatly. Install this module:
>
> emacs-libpq @ Github
> https://github.com/anse1/emacs-libpq
>
> Then install this package:
>
> RCD Database Basics
> https://hyperscope.link/3/7/4/9/3/RCD-Database-Basics-37493.html
>
> Then use M-x cf-sql-table to design your own first SQL table.
>
> Integrate eev with permanent database backed information.
>
>
> --
> Jean
>
> Take action in Free Software Foundation campaigns:
> https://www.fsf.org/campaigns
>
> Sign an open letter in support of Richard M. Stallman
> https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Eduardo Ochs <eduardoochs@gmail.com> [2021-05-30 10:51]:
> Hi Jean Louis,
> 
> I did this,
> 
>   sudo apt-get install libpq-dev postgresql

Good > and "make check" failed with several errors like this:
> 
>   Test pq-async-notify-test condition:
>       (error "FATAL:  role \"edrx\" does not exist\12")

I never did `make check'... It is obvious that you already installed
PostgreSQL, did you? But you did not create a database role `edrx',
which is not a must, however, that is what maybe `make check'
expected.

You could simply do it:

$ createuser edrx

In general, you will need to know how to create a role, user or
database before using the database;

$ createdb DATABASE

$ createuser USERNAME

Let us say you created username edrx and database name edrx (you can
have many databases):

Then you do something like:

$ psql

grant all on database edrx to edrx;

it will tell:
GRANT

which means you gave permission to user edrx to use the database edrx;

To learn about psql interface, try \?


-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Eduardo Ochs wrote:

> I did this,
>
>   sudo apt-get install libpq-dev postgresql
>
>   rm -Rfv ~/usrc/emacs-libpq/
>   cd      ~/usrc/
>   git clone https://github.com/anse1/emacs-libpq
>   cd      ~/usrc/emacs-libpq/
>
>   cd ~/usrc/emacs-libpq/
>   make clean
>   make \
>     EMACS=$HOME/bigsrc/emacs28/src/emacs \
>     EMACS_INCLUDE_DIR=$HOME/bigsrc/emacs28/src/ \
>     all check \
>     2>&1 | tee om
>
> and "make check" failed with several errors like this:
>
>   Test pq-async-notify-test condition:
>       (error "FATAL:  role \"edrx\" does not exist\12")
>
> What should I do?

I don't know but good that you do this.

Like +1

:)

What is this SQL thing I keep hear about BTW, you send
it to/from Emacs and get the data neatly or what does it do
and what databases do you use it with?

You keep track of all the weaponry you have at home? :)

Well, actually, if I had enough I would now that I say it.
Bad example.

Is relational algebra the base for SQL?

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Emanuel Berg via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> [2021-05-30 22:31]:

> What is this SQL thing I keep hear about BTW, you send it to/from
> Emacs and get the data neatly or what does it do and what databases
> do you use it with?

I am sure you know it. SQL https://en.wikipedia.org/wiki/SQL

> You keep track of all the weaponry you have at home? :)
> 
> Well, actually, if I had enough I would now that I say it.
> Bad example.
> 
> Is relational algebra the base for SQL?

You have got it right.

Relational algebra - Wikipedia
https://en.wikipedia.org/wiki/Relational_algebra

Though I know nothing about it... but I should. 

SQL database spare programming time and effort. 

Compared to Org, the file `org-agenda.el' is full of features and
handles all kinds of things. It is however slow and has several keys
that handle its incapacities, such as sticky views or stuck
projects. And it distorts the users' view of what agenda really is, as
it is not just "agenda", rather a menu of search functions, for
example it encompasses the function `org-search-view'. The function
`org-agenda' should be renamed to something else, as the true agenda
is just the `org-agenda-list', but users will not be warned.

With the SQL, as when objects are in the database, the 415 kilobytes
org-agenda.el or at least we can say several kilobytes of spaghetti
Emacs Lisp code is replaced with the SQL query and report function:

(defun hyperscope-hyperdocuments-agenda ()
  (interactive)
  (rcd-speak "Hyperscope agenda")
  (let ((sql "SELECT DISTINCT timestamps_hlinks, timestamptypes_name,
              to_char(timestamps_timestamp::date, 'Day'), timestamps_timestamp::date,
              hyobjects_name, actionstatuses_name
              FROM hyobjects, timestamps, timestamptypes, actionstatuses
              WHERE hyobjects_id = timestamps_hlinks
              AND timestamptypes_id = timestamps_timestamptypes
              AND timestamptypes_inagenda IS TRUE
              AND actionstatuses_id = hyobjects_actionstatuses
              AND actionstatuses_actionstatustypes != 3
              ORDER BY timestamps_timestamp DESC")
	(highlights (append '("ACTION") (hyperscope-timestamp-list t))))
    (rcd-db-sql-report "Hyperscope Agenda" sql [("ID" 5 t) ("Type" 10 t) ("Day" 9 t) ("Timestamp" 10 t) ("Hyperdocument" 55) ("Action" 10 t)] "hyobjects" '("Timestamp" . t) 'hyperscope-hyperdocuments-agenda highlights)))

Comparison
==========

Try reading function `org-agenda' and `org-agenda-list' and compare
to the SQL above. 


-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Jean Louis wrote:

>> What is this SQL thing I keep hear about BTW, you send it
>> to/from Emacs and get the data neatly or what does it do
>> and what databases do you use it with?
>
> I am sure you know it. SQL https://en.wikipedia.org/wiki/SQL

Yes but I mean your Emacs things with it, you have a database
and use some package to interact with it from Emacs?

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Emanuel Berg via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> [2021-05-31 01:42]:
> Jean Louis wrote:
> 
> >> What is this SQL thing I keep hear about BTW, you send it
> >> to/from Emacs and get the data neatly or what does it do
> >> and what databases do you use it with?
> >
> > I am sure you know it. SQL https://en.wikipedia.org/wiki/SQL
> 
> Yes but I mean your Emacs things with it, you have a database
> and use some package to interact with it from Emacs?

Yes, now there is preview, until all database tables get exported for
public.

RCD Notes for Emacs
https://hyperscope.link/3/7/1/5/5/RCD-Notes-for-Emacs-37155.html

-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Arthur Miller]

Eduardo Ochs <eduardoochs@gmail.com> writes:

> On Sat, 29 May 2021 at 23:12, Christopher Dimech <dimech@gmx.com> wrote:
>>
>> > Sent: Sunday, May 30, 2021 at 10:37 AM
>> > From: "Jean Louis" <bugs@gnu.support>
>> > To: "Christopher Dimech" <dimech@gmx.com>
>> > Cc: help-gnu-emacs@gnu.org
>> > Subject: How users start programming in Emacs Lisp...
>> >
>> > (...)
>> >
>> > *scratch* buffer is famous for it.
>> >
>> > I just need more of them but *scratch*, so I do it this way:
>
>
> Hi, just a curiosity...
>
> why do you prefer to use scratch buffers for elisp code instead of
> using (semi-scratch?) files in which we record all our experiments?
>
> In the tutorials of eev I try to convince the new users to treat their
> notes and scratch code as "field notes", and save everything they
> can... one of my arguments is this:
>
>   Learning eev is also like learning to use paper notebooks. It is
>   much easier to understand the notes and ideas what we wrote
>   ourselves in our notebooks than to understand what other people
>   wrote in their notebooks... when we go back to what _we_ wrote we
>   are able to reconnect with what we were thinking, even when our
>   notes are quite terse because we did not write down all details -
>   and we can't do that with other people's notes.

I think you are probably correct about saving notes. Some vary famious
scientists attribute almost everything to their notes. Maybe a
self-saving scratch buffer isn't bad idea. It could maybe append a date
and always open "fresh" but the true file would be save in the
background, as a sort of a database. Sort of like we clear the terminal
screen with Ctrl+l but the output is still there, just not
visible. There probably is some note-taking package that already does
that. Maybe some org-capture template that auto puts note in a lisp src
block. Or maybe your eev already does that. Still didn't try it. It
seems so conceptually big to me so I never get to it. Similar as that
other package Hyperbole.

How users start programming in Emacs Lisp...

[Christopher Dimech]

> Sent: Sunday, May 30, 2021 at 11:43 PM
> From: "Arthur Miller" <arthur.miller@live.com>
> To: "Eduardo Ochs" <eduardoochs@gmail.com>
> Cc: "Christopher Dimech" <dimech@gmx.com>, "help-gnu-emacs" <help-gnu-emacs@gnu.org>, "Jean Louis" <bugs@gnu.support>
> Subject: Re: How users start programming in Emacs Lisp...
>
> Eduardo Ochs <eduardoochs@gmail.com> writes:
>
> > On Sat, 29 May 2021 at 23:12, Christopher Dimech <dimech@gmx.com> wrote:
> >>
> >> > Sent: Sunday, May 30, 2021 at 10:37 AM
> >> > From: "Jean Louis" <bugs@gnu.support>
> >> > To: "Christopher Dimech" <dimech@gmx.com>
> >> > Cc: help-gnu-emacs@gnu.org
> >> > Subject: How users start programming in Emacs Lisp...
> >> >
> >> > (...)
> >> >
> >> > *scratch* buffer is famous for it.
> >> >
> >> > I just need more of them but *scratch*, so I do it this way:
> >
> >
> > Hi, just a curiosity...
> >
> > why do you prefer to use scratch buffers for elisp code instead of
> > using (semi-scratch?) files in which we record all our experiments?
> >
> > In the tutorials of eev I try to convince the new users to treat their
> > notes and scratch code as "field notes", and save everything they
> > can... one of my arguments is this:
> >
> >   Learning eev is also like learning to use paper notebooks. It is
> >   much easier to understand the notes and ideas what we wrote
> >   ourselves in our notebooks than to understand what other people
> >   wrote in their notebooks... when we go back to what _we_ wrote we
> >   are able to reconnect with what we were thinking, even when our
> >   notes are quite terse because we did not write down all details -
> >   and we can't do that with other people's notes.
>
> I think you are probably correct about saving notes. Some vary famious
> scientists attribute almost everything to their notes.

That is correct.  Darwin and Fermi have done the same.  But Stephen King
is famous for saying that notes are the best way to immortalise bad ideas.
Really good ideas stick around.  Today, I get to agree with King in respect
to the experience with Fermi.  But the same cannot be said about Darmin
during his trips.

Thusly, in point of fact, there are no good rules, but just what works for you.

> Maybe a
> self-saving scratch buffer isn't bad idea. It could maybe append a date
> and always open "fresh" but the true file would be save in the
> background, as a sort of a database. Sort of like we clear the terminal
> screen with Ctrl+l but the output is still there, just not
> visible. There probably is some note-taking package that already does
> that. Maybe some org-capture template that auto puts note in a lisp src
> block. Or maybe your eev already does that. Still didn't try it. It
> seems so conceptually big to me so I never get to it. Similar as that
> other package Hyperbole.
>

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Christopher Dimech wrote:

> That is correct. Darwin and Fermi have done the same.
> But Stephen King is famous for saying that notes are the
> best way to immortalise bad ideas. Really good ideas stick
> around.

Well, easy for him to say, maybe this method is for doing
something great but most lists like a TODO list [1] - that
software is a little bit shaky if anyone feels like reading
the short source and maybe see what it is? - what I was
saying, maybe it is not the best idea in the world but it can
still help you survive and get by another day, right?

With a TODO list, you can even erase bad ideas when and if
you decide to drop them - it is optional :)

But there was some other thing I should say... ???

?

Ah, right, the other list thing that scientists probably refer
to is just a list of data like this

  https://dataswamp.org/~incal/bike/TIRE

Very useful for science I'm sure but I don't see why just
they should get to do it :)

[1] https://dataswamp.org/~incal/emacs-init/todo-did.el

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Emanuel Berg via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> [2021-05-30 23:01]:
> Christopher Dimech wrote:
> 
> > That is correct. Darwin and Fermi have done the same.
> > But Stephen King is famous for saying that notes are the
> > best way to immortalise bad ideas. Really good ideas stick
> > around.
> 
> Well, easy for him to say, maybe this method is for doing
> something great but most lists like a TODO list [1] - that
> software is a little bit shaky if anyone feels like reading
> the short source and maybe see what it is? - what I was
> saying, maybe it is not the best idea in the world but it can
> still help you survive and get by another day, right?

Things you really need to do, you will never write them down. Like
lunch, go to work or similar. The top priorities are rarely written
down, you simply do it.

Procrastinated priorities are written down. That is where we come to
note taking. A simple digital text file is enough to replace the good
old Rolodex system. That is why GNU Hyperbole has "Rolo" system. I
recommend to try it out. I don't use it, as I have the fully
sophisticated system for addresses, call center, faxing, SMS, etc.

>   https://dataswamp.org/~incal/bike/TIRE

> Very useful for science I'm sure but I don't see why just
> they should get to do it :)
> 
> [1] https://dataswamp.org/~incal/emacs-init/todo-did.el

That is nice simple system, add TODO, visit TODO file. What else one
need? And yes, there is so much integration we do need, like:

To assign task related to person Joe, to agent Jane; write
instructions, quickly dispatch it; keep reminding yourself, and the
agent about the task by SMS, email, or loud music;

After a while, there are 10 agents, and tasks are not finished, one
can observe who is who, who is performing, in what periods, who is
more efficient;

Imagine working with 30 people employed, they come in, come out, one
has to clock-them all in and out without that ticket punching machine
as in middle or 20th century. Workflow would be to just mark the list
of employees except those who did not arrive, and clock them in all at
once.

Something to do is not necessary a completely defined action, as it is
something unfinished, procrastinated, left for later to be done, but
without full decision. 

Properly defined actions should have their starting time assigned.

Then we go into procrastinations:

- ah... now I failed to make it on 2021-05-31, then let us just make
  it 2021-06-02. Time stamp is changed and nothing happened. There is
  no trace that it ever changed. Then let me delay it
  more... Deadline? Ah let me just press shift left, and deadline is
  is shifted for few days more....

Then add the collaboration, and there will be 10² more of such
procrastinations in a team.

We managed thousands of people with paper based system and did not
have procrastinations such as now people create with computer
systems. 


-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Jean Louis wrote:

> Imagine working with 30 people employed [...]

OK, so first we talk brilliant, artistic ideas at the Stephen
King level.

Then the top scientists...

Then how to survive and get by each day...

How to do computer things!

Even control processes on you computer...

And now we are running a company with 30 people!

That software seems to be very versatile if nothing else :)

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Emanuel Berg via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org>:
> And now we are running a company with 30 people!
> 
> That software seems to be very versatile if nothing else :)

I can tell that it is pain in the associates to handle clocking in of
30 people at once. Some of them will complain... talk... I have tried
doing that with Org mode, successsfull but slow. It is better with
SQL and rapid integration. 

Something like: mmmmmmmmmmmmmm mmmmmmmm mmmmmm M-x clock-them-in over
the list of people is so much faster than going on by one over each of
their "headings" and doing some complex C-c C-x C-i magic clock-ings
for each of them. 30 people x 3 more keys plus at least several more
keys just to find person in the heading x 30 days in a month x
months... ah no. 

Org ≨ Organization

And then... CLOCK-IN let us say 2021-05-31 at 8:30 but why? It was
supposed to be 08:00 precise. So CLOCK-IN needs its description field,
to describe why, or next manager will fire the person when manager
finds that person was always coming late. Maybe goats were stolen and
guy had to search for them, but maybe it was was just a day after
drinking evening. Reason why brings meanings.

-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Jean Louis wrote:

>> And now we are running a company with 30 people!
>> 
>> That software seems to be very versatile if nothing else :)
>
> I can tell that it is pain in the associates to handle
> clocking in of 30 people at once. Some of them will
> complain... talk... I have tried doing that with Org mode,
> successsfull but slow. It is better with SQL and
> rapid integration.

People use Emacs in the corporate world like this?

They don't have special software, business software being
produced and marketed by some business?

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Emanuel Berg via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> [2021-05-31 01:51]:
> > I can tell that it is pain in the associates to handle
> > clocking in of 30 people at once. Some of them will
> > complain... talk... I have tried doing that with Org mode,
> > successsfull but slow. It is better with SQL and
> > rapid integration.
> 
> People use Emacs in the corporate world like this?

Text editors are widely used. What a question... have you not seen
black console screens in companies in Sweden, even DOS is used in many
modern places in the world because some software simply works well. 

> They don't have special software, business software being
> produced and marketed by some business?

It is difficult with other people's software. I have tried it, it is
not reliable. Example is the SugarCRM before so many years, failures
on upgrades would block the business. Today they dropped the free
software version, imagine what disaster would that be if I would be
still using it.

GeDaFe worked so well and still works:

GeDaFe - PostgreSQL Generic Database Interface
http://gedafe.github.io/doc/gedafe-sql.en.html 

and now Emacs extends it and provides more interactivity and speed. 


-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Jean Louis wrote:

>> People use Emacs in the corporate world like this?
>
> Text editors are widely used. What a question... have you
> not seen black console screens in companies in Sweden, even
> DOS is used in many modern places in the world because some
> software simply works well.

Never, they have dedicated business systems for this...

>> They don't have special software, business software being
>> produced and marketed by some business?
>
> It is difficult with other people's software. I have tried
> it, it is not reliable. Example is the SugarCRM before so
> many years, failures on upgrades would block the business.
> Today they dropped the free software version, imagine what
> disaster would that be if I would be still using it.

Well then, tell them to use Emacs instead. That will organize
up the whole place in many the most unexpected ways :)

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Emanuel Berg via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> [2021-05-31 02:05]:
> Jean Louis wrote:
> 
> >> People use Emacs in the corporate world like this?
> >
> > Text editors are widely used. What a question... have you
> > not seen black console screens in companies in Sweden, even
> > DOS is used in many modern places in the world because some
> > software simply works well.
> 
> Never, they have dedicated business systems for this...

Watch better. Software in many companies is not necessarily upgraded
just because world upgrades OS-es, when something works, it works. I
have seen DOS programs still being used in large malls (under some
Windows).

> > It is difficult with other people's software. I have tried
> > it, it is not reliable. Example is the SugarCRM before so
> > many years, failures on upgrades would block the business.
> > Today they dropped the free software version, imagine what
> > disaster would that be if I would be still using it.
> 
> Well then, tell them to use Emacs instead. That will organize
> up the whole place in many the most unexpected ways :)

You heavily underestimate the Emacs power.

It can do so much more, faster and better than SugarCRM with so much
better extensibility and so much less dark patterns.

Formula for software sales:
===========================
   Make it appear complex, inaccessible, but solution for all; the
   more complex, the more the company becomes solution provider; bind
   people, get them into the vendor trap; the more company keeps
   people stupid, the more sales they will get;

Formula for success:
====================
   Learn any programming language, DIY or organize people to program
   it for you. This is the approach taken from early years of Apple,
   micro computers and PC on the market. 

Usually accountants and engineers were responsible to read the books
about programming language, and to make programs. Programs were often
made internally, in the company. When market offered more and more
varieties of software, companies and teachers relaxed more and stopped
programming. They forgot the formula for success. 


-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Jean Louis wrote:

>> Never, they have dedicated business systems for this...
>
> Watch better. Software in many companies is not necessarily
> upgraded just because world upgrades OS-es, when something
> works, it works. I have seen DOS programs still being used
> in large malls (under some Windows).

Well, maybe you have seen that but I have not seen anyone use
DOS since the 90s and I've not seen anyone (almost?) that used
Emacs that wasn't a programmer or tech person.

There is a FreeDOS BTW:

  https://en.wikipedia.org/wiki/FreeDOS

> You heavily underestimate the Emacs power.

Well, one, I'm not a corporate-world person, and two, do say,
how much power has Emacs?

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Arthur Miller]

Christopher Dimech <dimech@gmx.com> writes:

>> Sent: Sunday, May 30, 2021 at 11:43 PM
>> From: "Arthur Miller" <arthur.miller@live.com>
>> To: "Eduardo Ochs" <eduardoochs@gmail.com>
>> Cc: "Christopher Dimech" <dimech@gmx.com>, "help-gnu-emacs" <help-gnu-emacs@gnu.org>, "Jean Louis" <bugs@gnu.support>
>> Subject: Re: How users start programming in Emacs Lisp...
>>
>> Eduardo Ochs <eduardoochs@gmail.com> writes:
>>
>> > On Sat, 29 May 2021 at 23:12, Christopher Dimech <dimech@gmx.com> wrote:
>> >>
>> >> > Sent: Sunday, May 30, 2021 at 10:37 AM
>> >> > From: "Jean Louis" <bugs@gnu.support>
>> >> > To: "Christopher Dimech" <dimech@gmx.com>
>> >> > Cc: help-gnu-emacs@gnu.org
>> >> > Subject: How users start programming in Emacs Lisp...
>> >> >
>> >> > (...)
>> >> >
>> >> > *scratch* buffer is famous for it.
>> >> >
>> >> > I just need more of them but *scratch*, so I do it this way:
>> >
>> >
>> > Hi, just a curiosity...
>> >
>> > why do you prefer to use scratch buffers for elisp code instead of
>> > using (semi-scratch?) files in which we record all our experiments?
>> >
>> > In the tutorials of eev I try to convince the new users to treat their
>> > notes and scratch code as "field notes", and save everything they
>> > can... one of my arguments is this:
>> >
>> >   Learning eev is also like learning to use paper notebooks. It is
>> >   much easier to understand the notes and ideas what we wrote
>> >   ourselves in our notebooks than to understand what other people
>> >   wrote in their notebooks... when we go back to what _we_ wrote we
>> >   are able to reconnect with what we were thinking, even when our
>> >   notes are quite terse because we did not write down all details -
>> >   and we can't do that with other people's notes.
>>
>> I think you are probably correct about saving notes. Some vary famious
>> scientists attribute almost everything to their notes.
>
> That is correct.  Darwin and Fermi have done the same.  But Stephen King
> is famous for saying that notes are the best way to immortalise bad ideas.

How could we know good ideas if it wasn't for bad ones?

King is probably correct, but 90% or more ideas people get are probably
bad, it is just that we remember the good ones (mostly :)). Also, some
good ideas probably started as bad ideas. Socrates thought that writing
is a bad idea. He never wrote a single note. :-( 

> Really good ideas stick around.  Today, I get to agree with King in respect
> to the experience with Fermi.  But the same cannot be said about Darmin
> during his trips.
>
> Thusly, in point of fact, there are no good rules, but just what works for you.

That seems like a rule you are stating there? :)

How users start programming in Emacs Lisp...

[Christopher Dimech]

> Sent: Wednesday, June 02, 2021 at 2:09 AM
> From: "Arthur Miller" <arthur.miller@live.com>
> To: "Christopher Dimech" <dimech@gmx.com>
> Cc: "Eduardo Ochs" <eduardoochs@gmail.com>, "help-gnu-emacs" <help-gnu-emacs@gnu.org>, "Jean Louis" <bugs@gnu.support>
> Subject: Re: How users start programming in Emacs Lisp...
>
> Christopher Dimech <dimech@gmx.com> writes:
>
> >> Sent: Sunday, May 30, 2021 at 11:43 PM
> >> From: "Arthur Miller" <arthur.miller@live.com>
> >> To: "Eduardo Ochs" <eduardoochs@gmail.com>
> >> Cc: "Christopher Dimech" <dimech@gmx.com>, "help-gnu-emacs" <help-gnu-emacs@gnu.org>, "Jean Louis" <bugs@gnu.support>
> >> Subject: Re: How users start programming in Emacs Lisp...
> >>
> >> Eduardo Ochs <eduardoochs@gmail.com> writes:
> >>
> >> > On Sat, 29 May 2021 at 23:12, Christopher Dimech <dimech@gmx.com> wrote:
> >> >>
> >> >> > Sent: Sunday, May 30, 2021 at 10:37 AM
> >> >> > From: "Jean Louis" <bugs@gnu.support>
> >> >> > To: "Christopher Dimech" <dimech@gmx.com>
> >> >> > Cc: help-gnu-emacs@gnu.org
> >> >> > Subject: How users start programming in Emacs Lisp...
> >> >> >
> >> >> > (...)
> >> >> >
> >> >> > *scratch* buffer is famous for it.
> >> >> >
> >> >> > I just need more of them but *scratch*, so I do it this way:
> >> >
> >> >
> >> > Hi, just a curiosity...
> >> >
> >> > why do you prefer to use scratch buffers for elisp code instead of
> >> > using (semi-scratch?) files in which we record all our experiments?
> >> >
> >> > In the tutorials of eev I try to convince the new users to treat their
> >> > notes and scratch code as "field notes", and save everything they
> >> > can... one of my arguments is this:
> >> >
> >> >   Learning eev is also like learning to use paper notebooks. It is
> >> >   much easier to understand the notes and ideas what we wrote
> >> >   ourselves in our notebooks than to understand what other people
> >> >   wrote in their notebooks... when we go back to what _we_ wrote we
> >> >   are able to reconnect with what we were thinking, even when our
> >> >   notes are quite terse because we did not write down all details -
> >> >   and we can't do that with other people's notes.
> >>
> >> I think you are probably correct about saving notes. Some vary famious
> >> scientists attribute almost everything to their notes.
> >
> > That is correct.  Darwin and Fermi have done the same.  But Stephen King
> > is famous for saying that notes are the best way to immortalise bad ideas.
>
> How could we know good ideas if it wasn't for bad ones?
>
> King is probably correct, but 90% or more ideas people get are probably
> bad, it is just that we remember the good ones (mostly :)). Also, some
> good ideas probably started as bad ideas. Socrates thought that writing
> is a bad idea. He never wrote a single note. :-(
>
> > Really good ideas stick around.  Today, I get to agree with King in respect
> > to the experience with Fermi.  But the same cannot be said about Darmin
> > during his trips.
> >
> > Thusly, in point of fact, there are no good rules, but just what works for you.
>
> That seems like a rule you are stating there? :)

The rule that there is no rule

How users start programming in Emacs Lisp...

[Christopher Dimech]

> Sent: Wednesday, June 02, 2021 at 2:09 AM
> From: "Arthur Miller" <arthur.miller@live.com>
> To: "Christopher Dimech" <dimech@gmx.com>
> Cc: "help-gnu-emacs" <help-gnu-emacs@gnu.org>, "Eduardo Ochs" <eduardoochs@gmail.com>, "Jean Louis" <bugs@gnu.support>
> Subject: Re: How users start programming in Emacs Lisp...
>
> Christopher Dimech <dimech@gmx.com> writes:
>
> >> Sent: Sunday, May 30, 2021 at 11:43 PM
> >> From: "Arthur Miller" <arthur.miller@live.com>
> >> To: "Eduardo Ochs" <eduardoochs@gmail.com>
> >> Cc: "Christopher Dimech" <dimech@gmx.com>, "help-gnu-emacs" <help-gnu-emacs@gnu.org>, "Jean Louis" <bugs@gnu.support>
> >> Subject: Re: How users start programming in Emacs Lisp...
> >>
> >> Eduardo Ochs <eduardoochs@gmail.com> writes:
> >>
> >> > On Sat, 29 May 2021 at 23:12, Christopher Dimech <dimech@gmx.com> wrote:
> >> >>
> >> >> > Sent: Sunday, May 30, 2021 at 10:37 AM
> >> >> > From: "Jean Louis" <bugs@gnu.support>
> >> >> > To: "Christopher Dimech" <dimech@gmx.com>
> >> >> > Cc: help-gnu-emacs@gnu.org
> >> >> > Subject: How users start programming in Emacs Lisp...
> >> >> >
> >> >> > (...)
> >> >> >
> >> >> > *scratch* buffer is famous for it.
> >> >> >
> >> >> > I just need more of them but *scratch*, so I do it this way:
> >> >
> >> >
> >> > Hi, just a curiosity...
> >> >
> >> > why do you prefer to use scratch buffers for elisp code instead of
> >> > using (semi-scratch?) files in which we record all our experiments?
> >> >
> >> > In the tutorials of eev I try to convince the new users to treat their
> >> > notes and scratch code as "field notes", and save everything they
> >> > can... one of my arguments is this:
> >> >
> >> >   Learning eev is also like learning to use paper notebooks. It is
> >> >   much easier to understand the notes and ideas what we wrote
> >> >   ourselves in our notebooks than to understand what other people
> >> >   wrote in their notebooks... when we go back to what _we_ wrote we
> >> >   are able to reconnect with what we were thinking, even when our
> >> >   notes are quite terse because we did not write down all details -
> >> >   and we can't do that with other people's notes.
> >>
> >> I think you are probably correct about saving notes. Some vary famious
> >> scientists attribute almost everything to their notes.
> >
> > That is correct.  Darwin and Fermi have done the same.  But Stephen King
> > is famous for saying that notes are the best way to immortalise bad ideas.
>
> How could we know good ideas if it wasn't for bad ones?
>
> King is probably correct, but 90% or more ideas people get are probably
> bad, it is just that we remember the good ones (mostly :)).

That was King's point, that you will forget them if you don't write them down.
But then we had Darwin doing the opposite.  During his two year trip, he only
took notes, and later developed his ideas from his notes and specimens after
his return to england.




> Also, some
> good ideas probably started as bad ideas. Socrates thought that writing
> is a bad idea. He never wrote a single note. :-(
>
> > Really good ideas stick around.  Today, I get to agree with King in respect
> > to the experience with Fermi.  But the same cannot be said about Darmin
> > during his trips.
> >
> > Thusly, in point of fact, there are no good rules, but just what works for you.
>
> That seems like a rule you are stating there? :)
>
>

Re: How users start programming in Emacs Lisp...

[Tomas Hlavaty]

On Sun 30 May 2021 at 13:43, Arthur Miller <arthur.miller@live.com> wrote:
> Or maybe your eev already does that. Still didn't try it. It seems so
> conceptually big to me so I never get to it.

I can only recommend eev.  It is one of the best ideas I've seen
recently.  Some things are hard to get into, but getting started with
eev-beginner is not that difficult.  My executable notes are now eepitch
blocks and I find it much better and way simpler than anything org-mode.
Some things could be improved but it is not hard to redefine a few
functions.  The biggest issue I have with eepitch is that it uses
non-printable character as a marker which does not tunnel through many
protocols; for example notice how the example in the email from Eduardo
has the eepitch block stripped.

Re: How users start programming in Emacs Lisp...

[Eduardo Ochs]

On Sun, 30 May 2021 at 11:45, Tomas Hlavaty <tom@logand.com> wrote:
>
> On Sun 30 May 2021 at 13:43, Arthur Miller <arthur.miller@live.com> wrote:
> > Or maybe your eev already does that. Still didn't try it. It seems so
> > conceptually big to me so I never get to it.
>
> I can only recommend eev.  It is one of the best ideas I've seen
> recently.  Some things are hard to get into, but getting started with
> eev-beginner is not that difficult.  My executable notes are now eepitch
> blocks and I find it much better and way simpler than anything org-mode.
> Some things could be improved but it is not hard to redefine a few
> functions.  The biggest issue I have with eepitch is that it uses
> non-printable character as a marker which does not tunnel through many
> protocols; for example notice how the example in the email from Eduardo
> has the eepitch block stripped.

Hi Tomas,

I just had an idea to make the eepitch accept both the original ^O
(char 15) and the bullet char (char 8226) to indicate its "red star
lines"... can you try this?

  (eepitch-set-glyph0 ?• ?• 'eepitch-star-face)

  (setq eepitch-regexp      "^ *[ •]\\(.*\\)")
  ;; Or: (setq eepitch-regexp "^[ •]\\(.*\\)")

  (defun eewrap-eepitch () (interactive)
    (let* ((fmt   "• (eepitch-%s)\n• (eepitch-kill)\n• (eepitch-%s)")
           (li    (ee-this-line-extract))
           (newli (format fmt li li)))
      (insert newli))
    (ee-next-line 1))

Then try to run this with <f8>s:

  • (eepitch-shell)
  • (eepitch-kill)
  • (eepitch-shell)
  cd /tmp/
  pwd

Now `M-T' will use the red bullet chars insert of the red star
chars...

  Cheers (& hope that the chars 8226 here don't get lost in
  translation),
    Eduardo =)




P.S.: Some links:

;; (find-eev "eepitch.el" "eewrap-eepitch")
;; (find-eev "eepitch.el" "eepitch" "defvar eepitch-regexp")
;; (find-elongkey-links "M-T  ;; eewrap-eepitch")
;; (find-einsert (list 8226 (char-from-name "BULLET")))
;; (eek "C-x 8 * C-h")
;; http://angg.twu.net/eev-intros/find-eev-quick-intro.html#6
;; (find-eev-quick-intro "6. Controlling shell-like programs")

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Eduardo Ochs wrote:

> ;; (find-eev-quick-intro "6. Controlling shell-like programs")

???

Now it control programs?

Didn't it do notes and lists? :)

I don't understand anything today :)

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Eduardo Ochs]

On Sun, 30 May 2021 at 16:51, Emanuel Berg via Users list for the GNU
Emacs text editor <help-gnu-emacs@gnu.org> wrote:
>
> Now it control programs?
> Didn't it do notes and lists? :)
> I don't understand anything today :)

Hi Emanuel,
see these slides:

  http://angg.twu.net/LATEX/2019emacsconf.pdf
  ("How to record executable notes with eev -
     and how to play them back")

for more introductions, see:

  https://github.com/edrx/eev#introduction

[[]], E.

Re: How users start programming in Emacs Lisp...

[Tomas Hlavaty]

Hi Eduardo,

On Sun 30 May 2021 at 12:23, Eduardo Ochs <eduardoochs@gmail.com> wrote:
> On Sun, 30 May 2021 at 11:45, Tomas Hlavaty <tom@logand.com> wrote:
>> The biggest issue I have with eepitch is that it uses non-printable
>> character as a marker which does not tunnel through many protocols;
>> for example notice how the example in the email from Eduardo has the
>> eepitch block stripped.
>
> Hi Tomas,
>
> I just had an idea to make the eepitch accept both the original ^O
> (char 15) and the bullet char (char 8226) to indicate its "red star
> lines"... can you try this?

I tried it and it works and even tunnels correctly via email and is
displayed properly on the console without X.

Thank you!

Tomas

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Tomas Hlavaty wrote:

>> Or maybe your eev already does that. Still didn't try it.
>> It seems so conceptually big to me so I never get to it.
>
> I can only recommend eev. It is one of the best ideas I've
> seen recently. Some things are hard to get into, but getting
> started with eev-beginner is not that difficult.

What does it do ???

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Arthur Miller]

Tomas Hlavaty <tom@logand.com> writes:

> On Sun 30 May 2021 at 13:43, Arthur Miller <arthur.miller@live.com> wrote:
>> Or maybe your eev already does that. Still didn't try it. It seems so
>> conceptually big to me so I never get to it.
>
> I can only recommend eev.  It is one of the best ideas I've seen
> recently.  Some things are hard to get into, but getting started with
> eev-beginner is not that difficult.  My executable notes are now eepitch
> blocks and I find it much better and way simpler than anything org-mode.
> Some things could be improved but it is not hard to redefine a few
> functions.  The biggest issue I have with eepitch is that it uses
> non-printable character as a marker which does not tunnel through many
> protocols; for example notice how the example in the email from Eduardo
> has the eepitch block stripped.

Thank you for the advice! Does it integrate well with org-capture?

Simpler than org sounds like a good selling point indeed!

Re: How users start programming in Emacs Lisp...

[Eduardo Ochs]

Eev and Org-capture are totally compatible AFAIK. They can be used together
and do not interfere on one another - but I didn't learn enough of
Org-capture to start to work on a way to integrate them...
  [[]], E.

On Tue, 1 Jun 2021, 07:30 Arthur Miller, <arthur.miller@live.com> wrote:

> Tomas Hlavaty <tom@logand.com> writes:
>
> > On Sun 30 May 2021 at 13:43, Arthur Miller <arthur.miller@live.com>
> wrote:
> >> Or maybe your eev already does that. Still didn't try it. It seems so
> >> conceptually big to me so I never get to it.
> >
> > I can only recommend eev.  It is one of the best ideas I've seen
> > recently.  Some things are hard to get into, but getting started with
> > eev-beginner is not that difficult.  My executable notes are now eepitch
> > blocks and I find it much better and way simpler than anything org-mode.
> > Some things could be improved but it is not hard to redefine a few
> > functions.  The biggest issue I have with eepitch is that it uses
> > non-printable character as a marker which does not tunnel through many
> > protocols; for example notice how the example in the email from Eduardo
> > has the eepitch block stripped.
>
> Thank you for the advice! Does it integrate well with org-capture?
>
> Simpler than org sounds like a good selling point indeed!
>
>

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Eduardo Ochs <eduardoochs@gmail.com> [2021-06-01 14:41]:
> Eev and Org-capture are totally compatible AFAIK. They can be used
> together and do not interfere on one another - but I didn't learn
> enough of Org-capture to start to work on a way to integrate them...

You can use org-protocol and this extension:
https://support.mozilla.org/1/firefox/88.0/Linux/en-US/extensions-pb

org-protocol-protocol-alist is a variable defined in ‘org-protocol.el’.

Its value is
(("Hyperscope Store Hyperlink" :protocol "store-link" :function hyperscope-org-protocol-store-link)
 ("Hyperscope Capture From Hyperlink" :protocol "capture" :function hyperscope-org-protocol-capture-link :kill-client t))
Original value was nil

  You can customize this variable.

hyperscope-org-protocol-store-link is a Lisp closure in
‘Hyperscope/hyperscope.el’.

(hyperscope-org-protocol-store-link QUERY)

You can inspect this function on how to capture in your own
system from browser. You could then just add eev links to single
file. 


(defun hyperscope-org-protocol-store-link (query)
  (let* ((splitparts (org-protocol-parse-parameters query t))
	 (uri (org-protocol-sanitize-uri (plist-get splitparts :url)))
         (title (plist-get splitparts :title))
	 (hlink-exist (hlink-link-exists-p uri t))) 
    (if hlink-exist
	(progn
	  (rcd-warning-message "Link: %s already exists." uri)
	  (espeak "Link exists already")
	  nil)
      (let* ((parent 23585) ;; (hyperscope-capture-user-sets)
	     (id (hlink-add-generic title uri 2 parent)))
      	(if id
	    (progn
	      (message "Added Hyperlink: %s to Hyperscope ID: %s" title id)
	      (hyperscope-update-tokens id)
	      (espeak "Done")
	      nil)
	  (progn
	    (message "Could not insert: %s" query)
	    (espeak "Did not work")
	    nil))))))




-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Eduardo Ochs]

On Tue, 1 Jun 2021 at 13:32, Jean Louis <bugs@gnu.support> wrote:
>
> You can use org-protocol and this extension:
> https://support.mozilla.org/1/firefox/88.0/Linux/en-US/extensions-pb


Hi Jean Louis,

I am quite slow at following textual instructions like these, and at
converting them to executable steps (accompanied by links to the
relevant documentation). You've probably noticed that the sandboxed
tutorials of eev are an experiment in writing instructions in another
way - in which the steps are very easy to execute, there are lots of
hyperlinks to documentation, to source code, and to tests that explain
the data structures and the behaviours of individual functions... and
they are an attempt to find other people who like that style, and who
would want to experiment with writing their own documentation in that
way, too.

I'll try to follow your instructions in the weekend. I am guessing
that they will take me many hours, because I know very little about
databases and SQL, and because org-capture and org-protocol also seems
to be quite complex beasts.

I think that I will start by watching and indexing the videos by J.E.
Magen and by Prot below... any other suggestions?

  Cheers,
    Eduardo Ochs
    http://angg.twu.net/#eev



;; Jonathan E. Magen: How I Use org-capture and Stuff
;; https://www.youtube.com/watch?v=KdcXu_RdKI0
;; (find-youtubedl-links nil nil "KdcXu_RdKI0" nil "orgcaptmagen")
;; (find-orgcaptmagenvideo "0:00")
;;
;; https://emacsnyc.org/assets/documents/how-i-use-org-capture-and-stuff.pdf
;; (code-pdf-page "orgcaptmagen"
"$S/https/emacsnyc.org/assets/documents/how-i-use-org-capture-and-stuff.pdf")
;; (code-pdf-text "orgcaptmagen"
"$S/https/emacsnyc.org/assets/documents/how-i-use-org-capture-and-stuff.pdf")
;; (find-orgcaptmagenpage)
;; (find-orgcaptmagentext)

;; Protesilaos Stavrou: Emacs: Introduction to ORG-CAPTURE
;; https://www.youtube.com/watch?v=qCdScs4YO8k
;; (find-youtubedl-links nil nil "qCdScs4YO8k" nil "orgcaptprot")
;;
;; https://protesilaos.com/codelog/2020-02-04-emacs-org-capture-intro/

;; (find-orgnode "Capture")

;; https://irreal.org/blog/?p=8694 An Introduction to Org Capture

;; Emacs Meet up Session I: Org Capture - Suvrat
;; https://www.youtube.com/watch?v=tFt6plDQm58
;; (find-youtubedl-links nil nil "tFt6plDQm58" nil "orgcaptsuvrat")

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Eduardo Ochs <eduardoochs@gmail.com> [2021-06-02 03:56]:
> On Tue, 1 Jun 2021 at 13:32, Jean Louis <bugs@gnu.support> wrote:
> >
> > You can use org-protocol and this extension:
> > https://support.mozilla.org/1/firefox/88.0/Linux/en-US/extensions-pb
> 
> 
> Hi Jean Louis,
> 
> I am quite slow at following textual instructions like these, and at
> converting them to executable steps (accompanied by links to the
> relevant documentation). You've probably noticed that the sandboxed
> tutorials of eev are an experiment in writing instructions in another
> way - in which the steps are very easy to execute, there are lots of
> hyperlinks to documentation, to source code, and to tests that explain
> the data structures and the behaviours of individual functions... and
> they are an attempt to find other people who like that style, and who
> would want to experiment with writing their own documentation in that
> way, too.
> 
> I'll try to follow your instructions in the weekend. I am guessing
> that they will take me many hours, because I know very little about
> databases and SQL, and because org-capture and org-protocol also seems
> to be quite complex beasts.

org-protocol is about sending information from outside of Emacs to
Emacs, normally people capture things in Org files, but because you
can use any function, you can make your own to capture things into eev
hyperlinks.

Using browser for org-protocol is one of possible methods, one could
use various outside programs or methods.

First thing to do is to customize the variable: `org-protocol-protocol-alist'

----- See more of its description with C-h v:
org-protocol-protocol-alist is a variable defined in ‘org-protocol.el’.

Its value is
(("Hyperscope Store Hyperlink" :protocol "store-link" :function hyperscope-org-protocol-store-link)
 ("Hyperscope Capture From Hyperlink" :protocol "capture" :function hyperscope-org-protocol-capture-link :kill-client t))
Original value was nil

  You can customize this variable.

Register custom handlers for org-protocol.

Each element of this list must be of the form:

  (module-name :protocol protocol :function func :kill-client nil)
---------

"store-link" is just to store the link in this case, it should be
quick; it will store title and hyperlink that browser is visiting;

"capture" is to store the marked text in the browser and the hyperlink
and title together;

For you it could be this way:

----
(("Eev Store Hyperlink from Browser" :protocol "store-link" :function eev-org-protocol-store-link)
 ("Eev Capture From Browser" :protocol "capture" :function eev-org-protocol-capture-link :kill-client t))
---

Your function for "store-link" would be like this:

(defun eev-org-protocol-store-link (query)
  (let* ((splitparts (org-protocol-parse-parameters query t))
	 (uri (org-protocol-sanitize-uri (plist-get splitparts :url)))
         (title (plist-get splitparts :title))
	 (my-file "~/my-eev-captured-hyperlinks.eev"))
    (with-temp-file
	(insert-file-contents my-file)
      (insert "\n" title "\n" "(find-firefox \"" uri "\")\n\n"))))

Now when you use that extension I recommended (for others I don't
know), you would quickly store the hyperlink in the file in the
eev style just by clicking in the browser at right place.

When this starts working, let me know, then we move to capturing
more text then just the title and link. But same concept is used
with the difference that you would open the capturing file for
editing maybe. It would not be just click and go, it would be
click, and Emacs buffer is opened for you to edit the captured
text, title and hyperlink.

-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Eduardo Ochs]

On Sun, 30 May 2021 at 08:43, Arthur Miller <arthur.miller@live.com> wrote:
>
> I think you are probably correct about saving notes. Some vary famious
> scientists attribute almost everything to their notes. Maybe a
> self-saving scratch buffer isn't bad idea. It could maybe append a date
> and always open "fresh" but the true file would be save in the
> background, as a sort of a database. Sort of like we clear the terminal
> screen with Ctrl+l but the output is still there, just not
> visible. There probably is some note-taking package that already does
> that. Maybe some org-capture template that auto puts note in a lisp src
> block. Or maybe your eev already does that. Still didn't try it. It
> seems so conceptually big to me so I never get to it. Similar as that
> other package Hyperbole.

Hi Arthur,

Eev is indeed "conceptually big" (unfortunately), but AFAIK it is
compatible with everything else, it is easy to test "in small pieces",
it is easy to turn on and off, it is very hacker-friendly in all
senses, it is, or tries, to be very friendly to people with short
attention spans who will play with it at most 10 minutes per session,
and - ta-daaaa! - now it has very, very, very nice video links in its
tutorials!!! See:

  https://lists.gnu.org/archive/html/emacs-devel/2021-05/msg00527.html
  http://angg.twu.net/2021-video-links.html

If anything in the sales pitch above turns out to be false please tell
me - I'll fix it and you'll also get twice your money back! =P

  Cheers =),
    Eduardo Ochs
    http://angg.twu.net/#eev

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Eduardo Ochs wrote:

>   https://lists.gnu.org/archive/html/emacs-devel/2021-05/msg00527.html
>   http://angg.twu.net/2021-video-links.html
>
> If anything in the sales pitch above turns out to be false
> please tell me - I'll fix it and you'll also get twice your
> money back! =P

? :)

You seem to be sure of success whatever that idea is, that's
good...

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Arthur Miller]

Eduardo Ochs <eduardoochs@gmail.com> writes:

> On Sun, 30 May 2021 at 08:43, Arthur Miller <arthur.miller@live.com> wrote:
>>
>> I think you are probably correct about saving notes. Some vary famious
>> scientists attribute almost everything to their notes. Maybe a
>> self-saving scratch buffer isn't bad idea. It could maybe append a date
>> and always open "fresh" but the true file would be save in the
>> background, as a sort of a database. Sort of like we clear the terminal
>> screen with Ctrl+l but the output is still there, just not
>> visible. There probably is some note-taking package that already does
>> that. Maybe some org-capture template that auto puts note in a lisp src
>> block. Or maybe your eev already does that. Still didn't try it. It
>> seems so conceptually big to me so I never get to it. Similar as that
>> other package Hyperbole.
>
> Hi Arthur,
>
> Eev is indeed "conceptually big" (unfortunately), but AFAIK it is
> compatible with everything else, it is easy to test "in small pieces",
> it is easy to turn on and off, it is very hacker-friendly in all
> senses, it is, or tries, to be very friendly to people with short
> attention spans who will play with it at most 10 minutes per session,
> and - ta-daaaa! - now it has very, very, very nice video links in its
> tutorials!!! See:
>
>   https://lists.gnu.org/archive/html/emacs-devel/2021-05/msg00527.html
>   http://angg.twu.net/2021-video-links.html
>
> If anything in the sales pitch above turns out to be false please tell
> me - I'll fix it and you'll also get twice your money back! =P
>
>   Cheers =),
>     Eduardo Ochs
>     http://angg.twu.net/#eev
Yeah, I know. I have actually seen your video, but I'll have to re-watch
it some time.

Best regards!

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Arthur Miller wrote:

> I think you are probably correct about saving notes.
> Some vary famious scientists attribute almost everything to
> their notes.

Yes but what do you mean? :)

Do you mean text files on the computer for example?

Don't we do that already?

Or they (the scientists) have more creative minds/notes
you mean?

Because me fiddling around with these files, can't say that
has contributed to any huge success be it personal or
scientific :)

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Arthur Miller]

Emanuel Berg via Users list for the GNU Emacs text editor
<help-gnu-emacs@gnu.org> writes:

> Arthur Miller wrote:
>
>> I think you are probably correct about saving notes.
>> Some vary famious scientists attribute almost everything to
>> their notes.
>
> Yes but what do you mean? :)
>
> Do you mean text files on the computer for example?
>
> Don't we do that already?
>
> Or they (the scientists) have more creative minds/notes
> you mean?
>
> Because me fiddling around with these files, can't say that
> has contributed to any huge success be it personal or
> scientific :)

Computers are just a recent discovery, but anyway, computer or paper, it
is just a media. "Taking note" is a general human activity which can be
done independent of media.

If you are (still) consuming most of your reading material from written
media, then I guess pen and paper are most suitable to you. If you are
like most people today consuming your information from a computer screen
then taking notes with your computer is probably more appropriate since
you will anyway have a keyboard and screen in front of you, ready to
just type.

But anway, it is your choice :-). Einsteing didn't have a mini
calculator and Socrates didn't have neither paper nor computer (and
never took a note), so it's all relative and up to you :).

How users start programming in Emacs Lisp...

[Christopher Dimech]

> Sent: Tuesday, June 01, 2021 at 10:22 PM
> From: "Arthur Miller" <arthur.miller@live.com>
> To: help-gnu-emacs@gnu.org
> Subject: Re: How users start programming in Emacs Lisp...
>
> Emanuel Berg via Users list for the GNU Emacs text editor
> <help-gnu-emacs@gnu.org> writes:
>
> > Arthur Miller wrote:
> >
> >> I think you are probably correct about saving notes.
> >> Some vary famious scientists attribute almost everything to
> >> their notes.
> >
> > Yes but what do you mean? :)
> >
> > Do you mean text files on the computer for example?
> >
> > Don't we do that already?
> >
> > Or they (the scientists) have more creative minds/notes
> > you mean?
> >
> > Because me fiddling around with these files, can't say that
> > has contributed to any huge success be it personal or
> > scientific :)
>
> Computers are just a recent discovery, but anyway, computer or paper, it
> is just a media. "Taking note" is a general human activity which can be
> done independent of media.

Computers are just tools, like taking notes.  Use what you find useful.
If a tool helps you, use it; if it doesn't, don't use it.

> If you are (still) consuming most of your reading material from written
> media, then I guess pen and paper are most suitable to you. If you are
> like most people today consuming your information from a computer screen
> then taking notes with your computer is probably more appropriate since
> you will anyway have a keyboard and screen in front of you, ready to
> just type.
>
> But anway, it is your choice :-). Einsteing didn't have a mini
> calculator and Socrates didn't have neither paper nor computer (and
> never took a note), so it's all relative and up to you :).
>
>

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Eduardo Ochs wrote:

> Hi, just a curiosity...
>
> why do you prefer to use scratch buffers for elisp code instead of
> using (semi-scratch?) files in which we record all our experiments?
>
> In the tutorials of eev I try to convince the new users to treat their
> notes and scratch code as "field notes", and save everything they
> can... one of my arguments is this:

Okay?

Sounds interesting but what is it and what does it do?

?

:)

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Emanuel Berg via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> [2021-05-30 22:24]:
> Eduardo Ochs wrote:
> 
> > Hi, just a curiosity...
> >
> > why do you prefer to use scratch buffers for elisp code instead of
> > using (semi-scratch?) files in which we record all our experiments?
> >
> > In the tutorials of eev I try to convince the new users to treat their
> > notes and scratch code as "field notes", and save everything they
> > can... one of my arguments is this:
> 
> Okay?
> 
> Sounds interesting but what is it and what does it do?

It is hyperdocument system for Emacs. You can create hyperlinks in
form of Emacs Lisp and jump somewhere and come back, use it for
workflows of life and business, for education and similar.

WWW Hyperlinks for example, one cannot use to read any kind of
documents or jump just anywhere but Emacs Lisp may be used to create
such hyperlinks. 


Here is one hyperlink:

Press M-e within M-x evv on this line opens manual:  (find-man "date") 

Going back from manual page works with M-k



-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Jean Louis wrote:

>> Sounds interesting but what is it and what does it do?
>
> It is hyperdocument system for Emacs. You can create
> hyperlinks in form of Emacs Lisp and jump somewhere and come
> back, use it for workflows of life and business, for
> education and similar.
>
> WWW Hyperlinks for example, one cannot use to read any kind
> of documents or jump just anywhere but Emacs Lisp may be
> used to create such hyperlinks.

But that we already do with Emacs all the time...

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Emanuel Berg via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> [2021-05-31 00:45]:
> Jean Louis wrote:
> 
> >> Sounds interesting but what is it and what does it do?
> >
> > It is hyperdocument system for Emacs. You can create
> > hyperlinks in form of Emacs Lisp and jump somewhere and come
> > back, use it for workflows of life and business, for
> > education and similar.
> >
> > WWW Hyperlinks for example, one cannot use to read any kind
> > of documents or jump just anywhere but Emacs Lisp may be
> > used to create such hyperlinks.
> 
> But that we already do with Emacs all the time...

Principle is important. eev can be embedded in text, the following
link may be evaluated with M-e and point being anywhere before the
sexp:

This is line before the sexp (find-man "man")

But I think it should also work after the sexp. And the sexp could be
underlined visually. In one way is similar to GNU Hyperbole buttons.

It is useful for instructions.

1. Do something (ok I will do)

2. Do more (ok-here is more)

And I have it similar in combination either with eev or GNU Hyperbole:

1. SLIME: The Superior Lisp Interaction Mode for Emacs (hyperscope 37269)

2. Handle the Magic Keywords File List (hyperscope 35956)

It jumps quickly to the note or item that I need. Numbers are used. I
could as well use: id:35956 

It then jumps to the list here:

 37272 Introducing Linux Air Combat                                           WWW          
 37271 SLY User Manual, version 1.0.42                                        WWW          
 37270 Emacs Lisp Introduction                                                WWW          
⧓37269 SLIME: The Superior Lisp Interaction Mode for Emacs                    WWW          
 37268 Functions | Common Lisp                                                WWW          
 37267 Read–eval–print loop - Wikipedia                                       WWW          
 37266 PostgreSQL: The world's most advanced open source database             WWW          

But it could as well open it, instead jump to the heading. It could
jump to edit the note, or to read the PDF, or watch movie. Only that
attributes are defined in the object itself, not in the Lisp
function. 

The list of items can be generated, in fact I generate Org file with
hyperlinks out of all nodes.


-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Jean Louis wrote:

> This is line before the sexp (find-man "man")

Yeah but just eval this:

  (man "ls")

I know right? You always wondered what that command did...

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Emanuel Berg via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> [2021-05-31 01:17]:
> Jean Louis wrote:
> 
> > This is line before the sexp (find-man "man")
> 
> Yeah but just eval this:
> 
>   (man "ls")
> 
> I know right? You always wondered what that command did...

It is not same. eev links are embedded in text and user need not move
to the endof sexp, it works from anywhere before the sexp with M-e

In your case there is problem:

Debugger entered--Lisp error: (void-variable >)
  eval(> nil)
  elisp--eval-last-sexp(nil)
  eval-last-sexp(nil)
  funcall-interactively(eval-last-sexp nil)
  call-interactively(eval-last-sexp nil nil)
  command-execute(eval-last-sexp)

-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Jean Louis wrote:

>>   (man "ls")
>> 
>> I know right? You always wondered what that command did...
>
> It is not same. eev links are embedded in text and user need not move
> to the endof sexp, it works from anywhere before the sexp with M-e
>
> In your case there is problem:
>
> Debugger entered--Lisp error: (void-variable >)
>   eval(> nil)
>   elisp--eval-last-sexp(nil)
>   eval-last-sexp(nil)
>   funcall-interactively(eval-last-sexp nil)
>   call-interactively(eval-last-sexp nil nil)
>   command-execute(eval-last-sexp)

This shows the man page for ls(1):

  (man "ls")

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Emanuel Berg via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> [2021-05-31 01:50]:
> This shows the man page for ls(1):
> 
>   (man "ls")

User friendliness lacking.

C-x C-e on the end of sexp is not same as M-e anywhere on the line.

I would underline it and enable mouse hyperlinks as well. Yes,
Eduardo? Why not...

-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Jean Louis wrote:

>> This shows the man page for ls(1):
>> 
>>   (man "ls")
>
> User friendliness lacking.
>
> C-x C-e on the end of sexp is not same as M-e anywhere on
> the line.

What about M-x man RET ls RET and the "line" can be
rationalized away?

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Emanuel Berg via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> [2021-05-31 02:10]:
> Jean Louis wrote:
> 
> >> This shows the man page for ls(1):
> >> 
> >>   (man "ls")
> >
> > User friendliness lacking.
> >
> > C-x C-e on the end of sexp is not same as M-e anywhere on
> > the line.
> 
> What about M-x man RET ls RET and the "line" can be
> rationalized away?

You still have to understand what means "embedded Lisp", that does not
involve M-x. Imagine a text of 10 pages the interactive manual. That
is what eev can do, including GNU Hyperbole, those are similar
systems. 


-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Jean Louis wrote:

> You still have to understand what means "embedded Lisp",
> that does not involve M-x. Imagine a text of 10 pages the
> interactive manual

Imagine a text of 10 pages the interactive manual?

Embedded Lisp is an invisible button?

But I like the same Elisp ready and available everywhere...

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Eduardo Ochs]

On Sun, 30 May 2021 at 20:03, Jean Louis <bugs@gnu.support> wrote:
>
> I would underline it and enable mouse hyperlinks as well. Yes,
> Eduardo? Why not...

Hi Jean Louis,

I tried to implement something like that in the early 2000s, but the
code that I managed to write was ugly, buggy, and only highlighted a
few constructions. But font locking was much more primitive then...

I think that the right way to do that now would be to start by writing
a sandboxed tutorial - like this one here

  http://angg.twu.net/eev-intros/find-elisp-intro.html
  (find-elisp-intro)

that would teach people how font locking works, and how to use tools
like font-lock-studio. Then on top of that I could try to implement
some kinds of font locking for eev, and by doing that people would
treat my code as something meant to be explored and extended instead
of as something that is "just crap"...

  [[]], E.

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Eduardo Ochs <eduardoochs@gmail.com> [2021-05-31 03:35]:
> On Sun, 30 May 2021 at 20:03, Jean Louis <bugs@gnu.support> wrote:
> >
> > I would underline it and enable mouse hyperlinks as well. Yes,
> > Eduardo? Why not...
> 
> Hi Jean Louis,
> 
> I tried to implement something like that in the early 2000s, but the
> code that I managed to write was ugly, buggy, and only highlighted a
> few constructions. But font locking was much more primitive then...
> 
> I think that the right way to do that now would be to start by writing
> a sandboxed tutorial - like this one here
> 
>   http://angg.twu.net/eev-intros/find-elisp-intro.html
>   (find-elisp-intro)
> 
> that would teach people how font locking works, and how to use tools
> like font-lock-studio. Then on top of that I could try to implement
> some kinds of font locking for eev, and by doing that people would
> treat my code as something meant to be explored and extended instead
> of as something that is "just crap"...

Maybe it could be a button with regexp so when regexp is found that
sexp becomes a button that is to be executed by (ee-eval-sexp-eol
&optional ARG)

That is the core idea but I don't know in this moment how to make
button by using regexp.

-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Tomas Hlavaty]

On Mon 31 May 2021 at 00:16, Emanuel Berg via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> wrote:
> Jean Louis wrote:
>
>> This is line before the sexp (find-man "man")
>
> Yeah but just eval this:
>
>   (man "ls")

Many emacs commands are deficient in important way and Eduardo
identified and codified his observation in eev.  For example, many
commands jump to a buffer but do not allow me to jump to a specific
place in the buffer.  eev fixes this.

For example, this jumps to the place where -h switch is described:

(find-man "ls" "-h")

The example you provided does not have this.

There are other things that eev can do.

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Jean Louis wrote:

> But it could as well open it, instead jump to the heading.
> It could jump to edit the note, or to read the PDF, or watch
> movie. Only that attributes are defined in the object
> itself, not in the Lisp function.

Yes you can use it to go to different places but we do that
with Emacs all the time already because otherwise we wouldn't
even be able to use it...

So maybe it is an interface to do that?

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Emanuel Berg via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> [2021-05-31 01:20]:
> Jean Louis wrote:
> 
> > But it could as well open it, instead jump to the heading.
> > It could jump to edit the note, or to read the PDF, or watch
> > movie. Only that attributes are defined in the object
> > itself, not in the Lisp function.
> 
> Yes you can use it to go to different places but we do that
> with Emacs all the time already because otherwise we wouldn't
> even be able to use it...
> 
> So maybe it is an interface to do that?

Interface yes. In dired we jump, but you cannot jump or get a list of
PDFs all related to specific subject, or tagged, or related to people,
groups, activities, you name it. Richer attributes, variety of
properties, rich associations, unlimited tags, those are lacking in
the file system.

Then there is no central reporting of software to user... software
installs itself and does not tell to user where is the config
file. Either one has to read manual, or try to search
manually. Instead installations could report to user by some
meaningful structural way what they did to the file system and that
such information becomes easily available to user: search for program
name, get all hyperlinks to all files or events caused by that program
(as event). 


-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Emanuel Berg via Users list for the GNU Emacs text editor]

Jean Louis wrote:

> Interface yes. In dired we jump, but you cannot jump or get
> a list of PDFs all related to specific subject, or tagged,
> or related to people, groups, activities, you name it.
> Richer attributes, variety of properties, rich associations,
> unlimited tags, those are lacking in the file system.

Hm... any example other than ls -h?

> Then there is no central reporting of software to user...
> software installs itself and does not tell to user where is
> the config file. Either one has to read manual, or try to
> search manually. Instead installations could report to user
> by some meaningful structural way what they did to the file
> system and that such information becomes easily available to
> user: search for program name, get all hyperlinks to all
> files or events caused by that program (as event).

OK, personally I don't like to search for things but sure
sometimes it is good to have around...

-- 
underground experts united
https://dataswamp.org/~incal

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Emanuel Berg via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> [2021-05-31 02:01]:
> OK, personally I don't like to search for things but sure
> sometimes it is good to have around...

I would maybe implant the chip with free software in my cerebral
center so that Emacs does what I want. 

Until then I have to at least enter some descriptive queries to find
what I mean. 

File system may have bookmarks, but I have not seen any sophisticated
bookmarking system in any of file managers I have ever tried. Emacs is
one that allows more sophisticated bookmarking. Other file managers
literally suck on that.

Lifting it all to one layer more, then one can note anything in the
same system and tag any type of information with tags, attributes,
properties, time stamps, etc. This includes physical books and DVDs
located in the house or other items. It is activity similar to
cataloguing, ordering. If every item is ordered at the creation time
it is then a breeze to find it later.


-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Christopher Dimech <dimech@gmx.com> [2021-05-30 05:11]:
> I wonder how you call the buffer optional parameters
> 
> C-u 8 C-u 5 M-x rcd-temp-buffer

Just C-u then I choose the mode on mini buffer completion.

It is bound to F5, C-u F5, choose your mode or add other modes. 

It would be possible, and it worked before so that I could do: C-1
equivalent to C-u 1 and choose mode by number, but now I use
completion.



-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

How users start programming in Emacs Lisp...

[Christopher Dimech]

> Sent: Sunday, May 30, 2021 at 5:46 PM
> From: "Jean Louis" <bugs@gnu.support>
> To: "Christopher Dimech" <dimech@gmx.com>
> Cc: help-gnu-emacs@gnu.org
> Subject: Re: How users start programming in Emacs Lisp...
>
> * Christopher Dimech <dimech@gmx.com> [2021-05-30 05:11]:
> > I wonder how you call the buffer optional parameters
> >
> > C-u 8 C-u 5 M-x rcd-temp-buffer
>
> Just C-u then I choose the mode on mini buffer completion.
>
> It is bound to F5, C-u F5, choose your mode or add other modes.


F5 is generally undefined.  Do you have a function attached to it?


> It would be possible, and it worked before so that I could do: C-1
> equivalent to C-u 1 and choose mode by number, but now I use
> completion.
>
>
>
> --
> Jean
>
> Take action in Free Software Foundation campaigns:
> https://www.fsf.org/campaigns
>
> Sign an open letter in support of Richard M. Stallman
> https://stallmansupport.org/
>
>

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Christopher Dimech <dimech@gmx.com> [2021-05-30 13:33]:
> 
> > Sent: Sunday, May 30, 2021 at 5:46 PM
> > From: "Jean Louis" <bugs@gnu.support>
> > To: "Christopher Dimech" <dimech@gmx.com>
> > Cc: help-gnu-emacs@gnu.org
> > Subject: Re: How users start programming in Emacs Lisp...
> >
> > * Christopher Dimech <dimech@gmx.com> [2021-05-30 05:11]:
> > > I wonder how you call the buffer optional parameters
> > >
> > > C-u 8 C-u 5 M-x rcd-temp-buffer
> >
> > Just C-u then I choose the mode on mini buffer completion.
> >
> > It is bound to F5, C-u F5, choose your mode or add other modes.
> 
> 
> F5 is generally undefined.  Do you have a function attached to it?

That function `rcd-temp-buffer' I have put on F5

Thus to get new scratch buffer with any mode, I do:

C-u F5 and I choose it

How users start programming in Emacs Lisp...

[Christopher Dimech]

> Sent: Sunday, May 30, 2021 at 10:35 PM
> From: "Jean Louis" <bugs@gnu.support>
> To: "Christopher Dimech" <dimech@gmx.com>
> Cc: help-gnu-emacs@gnu.org
> Subject: Re: How users start programming in Emacs Lisp...
>
> * Christopher Dimech <dimech@gmx.com> [2021-05-30 13:33]:
> >
> > > Sent: Sunday, May 30, 2021 at 5:46 PM
> > > From: "Jean Louis" <bugs@gnu.support>
> > > To: "Christopher Dimech" <dimech@gmx.com>
> > > Cc: help-gnu-emacs@gnu.org
> > > Subject: Re: How users start programming in Emacs Lisp...
> > >
> > > * Christopher Dimech <dimech@gmx.com> [2021-05-30 05:11]:
> > > > I wonder how you call the buffer optional parameters
> > > >
> > > > C-u 8 C-u 5 M-x rcd-temp-buffer
> > >
> > > Just C-u then I choose the mode on mini buffer completion.
> > >
> > > It is bound to F5, C-u F5, choose your mode or add other modes.
> >
> >
> > F5 is generally undefined.  Do you have a function attached to it?
>
> That function `rcd-temp-buffer' I have put on F5
>
> Thus to get new scratch buffer with any mode, I do:
>
> C-u F5 and I choose it

I can see your interim buffer working.  Very neat.  How does one play with name?

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Christopher Dimech <dimech@gmx.com> [2021-05-30 14:09]:
> > C-u F5 and I choose it
> 
> I can see your interim buffer working.  Very neat.  How does one
> play with name?

How exactly do you wish to play with the name? Which name? Is it
buffer name?


-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

How users start programming in Emacs Lisp...

[Christopher Dimech]

> Sent: Sunday, May 30, 2021 at 11:19 PM
> From: "Jean Louis" <bugs@gnu.support>
> To: "Christopher Dimech" <dimech@gmx.com>
> Cc: help-gnu-emacs@gnu.org
> Subject: Re: How users start programming in Emacs Lisp...
>
> * Christopher Dimech <dimech@gmx.com> [2021-05-30 14:09]:
> > > C-u F5 and I choose it
> >
> > I can see your interim buffer working.  Very neat.  How does one
> > play with name?
>
> How exactly do you wish to play with the name? Which name? Is it
> buffer name?

The first optional parameter "name", which looks like it is the buffer name.

When I use "C-u F5" you can only set the mode, but if name is already set,
the code suggests that it will use it.  But does not, because the let
variable "buffer" is not set.

The code uses

(generate-new-buffer "*RCD TEMPORARY BUFFER*")

making the name hard-coded.

Then when I call another temporary buffer, I get a numeric value enclosed in
<>, to get *RCD TEMPORARY BUFFER*<2>

> --
> Jean
>
> Take action in Free Software Foundation campaigns:
> https://www.fsf.org/campaigns
>
> Sign an open letter in support of Richard M. Stallman
> https://stallmansupport.org/
>

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Christopher Dimech <dimech@gmx.com> [2021-05-30 16:55]:
> > How exactly do you wish to play with the name? Which name? Is it
> > buffer name?
> 
> The first optional parameter "name", which looks like it is the
> buffer name.

Sorry, I was using that long time without observing.

> When I use "C-u F5" you can only set the mode, but if name is
> already set, the code suggests that it will use it.  But does not,
> because the let variable "buffer" is not set.

There is main name and sub-name.

Here now you can customize it:

;;;; ↝ RCD TEMPORARY BUFFERS

(defvar rcd-temp-buffer-mode-history nil)

;; You may customize the main name here:
(defvar rcd-temp-buffer-name "RCD TEMPORARY BUFFER")

;; You may customize the modes you wish to get asked with prefix C-u:
(defvar rcd-temp-buffer-modes '("adoc-mode" "emacs-lisp-mode" "lisp-mode" "markdown-mode"
				"org-mode" "sql-mode" "fundamental-mode" "html-mode"))

(defun rcd-temp-buffer (&optional name mode)
  (interactive "p")
  (let* ((format (concat "*" rcd-temp-buffer-name "%s%s*"))
	 (buffer (if name (format format ": " name) (format format "" ""))))
    (switch-to-buffer (generate-new-buffer buffer))
    (if current-prefix-arg
	(let* ((mode (completing-read
		      "Mode: "
		      rcd-temp-buffer-modes nil t nil 'rcd-temp-buffer-mode-history)))
	  (funcall (intern mode)))
      (funcall (intern (or mode "fundamental-mode"))))))

(defun rcd-temp-buffer-destroy-em ()
  (interactive)
  (kill-matching-buffers "RCD TEMPORARY BUFFER"))



-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

How users start programming in Emacs Lisp...

[Christopher Dimech]

---------------------
Christopher Dimech
General Administrator - Naiad Informatics - GNU Project (Geocomputation)
- Geophysical Simulation
- Geological Subsurface Mapping
- Disaster Preparedness and Mitigation
- Natural Resource Exploration and Production
- Free Software Advocacy


> Sent: Monday, May 31, 2021 at 3:54 AM
> From: "Jean Louis" <bugs@gnu.support>
> To: "Christopher Dimech" <dimech@gmx.com>
> Cc: help-gnu-emacs@gnu.org
> Subject: Re: How users start programming in Emacs Lisp...
>
> * Christopher Dimech <dimech@gmx.com> [2021-05-30 16:55]:
> > > How exactly do you wish to play with the name? Which name? Is it
> > > buffer name?
> > 
> > The first optional parameter "name", which looks like it is the
> > buffer name.
> 
> Sorry, I was using that long time without observing.
> 
> > When I use "C-u F5" you can only set the mode, but if name is
> > already set, the code suggests that it will use it.  But does not,
> > because the let variable "buffer" is not set.
> 
> There is main name and sub-name.
> 
> Here now you can customize it:
> 
> ;;;; ↝ RCD TEMPORARY BUFFERS
> 
> (defvar rcd-temp-buffer-mode-history nil)
> 
> ;; You may customize the main name here:
> (defvar rcd-temp-buffer-name "RCD TEMPORARY BUFFER")
> 
> ;; You may customize the modes you wish to get asked with prefix C-u:
> (defvar rcd-temp-buffer-modes '("adoc-mode" "emacs-lisp-mode" "lisp-mode" "markdown-mode"
> 				"org-mode" "sql-mode" "fundamental-mode" "html-mode"))
> 
> (defun rcd-temp-buffer (&optional name mode)
>   (interactive "p")
>   (let* ((format (concat "*" rcd-temp-buffer-name "%s%s*"))
> 	 (buffer (if name (format format ": " name) (format format "" ""))))
>     (switch-to-buffer (generate-new-buffer buffer))
>     (if current-prefix-arg
> 	(let* ((mode (completing-read
> 		      "Mode: "
> 		      rcd-temp-buffer-modes nil t nil 'rcd-temp-buffer-mode-history)))
> 	  (funcall (intern mode)))
>       (funcall (intern (or mode "fundamental-mode"))))))
> 
> (defun rcd-temp-buffer-destroy-em ()
>   (interactive)
>   (kill-matching-buffers "RCD TEMPORARY BUFFER"))
> 

I am having some problem figuring out what the following does, having format 
repeated twice.

(format format ": " name) 

 
> -- 
> Jean
> 
> Take action in Free Software Foundation campaigns:
> https://www.fsf.org/campaigns
> 
> Sign an open letter in support of Richard M. Stallman
> https://stallmansupport.org/
> 
>

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Christopher Dimech <dimech@gmx.com> [2021-05-30 20:22]:
> I am having some problem figuring out what the following does, having format 
> repeated twice.
> 
> (format format ": " name)

In Lisp at first place comes usually the function, but other list
elements are arguments to the function.

You could inspect `format' function with {C-h f format RET} as it
tells you that you apply it as:

format is a built-in function in ‘C source code’.

(format STRING &rest OBJECTS)

Format a string out of a format-string and arguments.
The first argument is a format control string.
The other arguments are substituted into it to make the result, a string.

The STRING is format-string, for example "%s" which means that %s will
be replaced with the argument or one of OBJECTS.

(format "%s" "Hello") ⇒ "Hello"

(format "Hello %s" "John") ⇒ "Hello John"

And the format-string which comes at second place is in my case named
also `format' why not.

(let ((format-string "Hello %s"))
  (format format-string "John")) ⇒ "Hello John"

or like this:

(let ((format "Hello %s"))
  (format format "John")) ⇒ "Hello John"

It will stop being confusing when you fully understand what is
list in Lisp and that functions come first and everything else
are arguments. This may not be best technical explanation, it is
just practical.


-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Christopher Dimech <dimech@gmx.com> [2021-05-30 20:22]:
> I am having some problem figuring out what the following does, having format 
> repeated twice.
> 
> (format format ": " name)

It could be all simpler, it just adds the sub-name to the main name.

M-x rcd-temp-buffer would create *RCD TEMPORARY BUFFER: 1*

but (rcd-temp-buffer "Lisp") would create *RCD TEMPORARY BUFFER: Lisp*

Myself I don't know why I made it so complex, but it just works and I
use temporary or scratch buffers that way often.

Simpler way to open temporary buffer is just:

C-x b NAME-OF-YOUR-BUFFER

but when function is tied to key binding it becomes simple, press F5
or other key how you bind it, and you are already in clean empty new
temporary buffer. Or invoke C-u prefix to be asked for the mode.

As Eduardo mentioned maybe it is good to keep those notes, but because
in my mind there is distinction on what is temporary and what is not,
for me it is fine that way as I use the database and it is trivial to
make a function to just open quickly buffer, write anything and have
it saved for future.

So I made this one...

(defun hyperscope-quick-emacs-lisp ()
  (interactive)
  (let* ((id (hlink-add-generic (concat "Emacs Lisp: " (rcd-timestamp-literate)) "" 50 33))
	 (template (rcd-db-get-entry "hlinktypes" "hlinktypes_template" 50 hs-db)))
    (when template
      (rcd-db-update-entry "hyobjects" "hyobjects_text" id template hs-db))
    (hyperscope-edit-with-mode id "hyobjects_text")))

The "name" of the note should be something quick:

(concat "Emacs Lisp: " (rcd-timestamp-literate)) ⇒ "Emacs Lisp: Sunday, May 30 2021, 22:21:26"

Function `hlink-add-generic' just adds generic object with type 50
(Emacs Lisp in description, text and report of the object) with the
parent node 33 which is "Emacs Lisp" set or category.

A type can have a template, why not, it is inserted as value of the
column "hyobjects_text", and finally edited in the last line.

Automatic saving is not a big deal, and automatic revision system
also.

What really matters is integration that brings speed to user without
thinking, and so the workflow is:

1. Press F5, edit Emacs Lisp (forget about anything else)

When editing database stuff, then things like byte compiling will not
work as it is not tied to buffer, but is not impossible to byte
compile and keep what is compiled in the database. I did not manage to
make it.

I am aware that little of this makes sense to people who edit mostly
files. Some functionality can be for files:

;;;; ↝ RCD TEMPORARY BUFFERS

(defvar rcd-temp-buffer-mode-history nil)
(defvar rcd-temp-file-directory "~/tmp/")
(defvar rcd-temp-buffer-name "RCD TEMPORARY BUFFER")
(defvar rcd-temp-buffer-modes '(("adoc-mode" . "adoc")
				("emacs-lisp-mode" . "el")
				("lisp-mode" . ".lisp")
				("markdown-mode" . ".md")
				("org-mode" . "org")
				("sql-mode" . "sql")
				("fundamental-mode" . "txt")
				("html-mode" . "html")))

(defun rcd-temp-buffer (&optional name mode)
  (interactive "p")
  (let* ((format (concat "*" rcd-temp-buffer-name "%s%s*"))
	 (buffer (if name (format format ": " name) (format format "" ""))))
    (switch-to-buffer (generate-new-buffer buffer))
    (if current-prefix-arg
	(let* ((mode (completing-read
		      "Mode: "
		      (map-keys rcd-temp-buffer-modes) nil t nil
		      'rcd-temp-buffer-mode-history)))
	  (funcall (intern mode)))
      (funcall (intern (or mode "fundamental-mode"))))))

(defun rcd-temp-file (&optional name mode)
  "Quickly open temporary file.
Using C-u as prefix will ask you for the mode of the file and
will influence the extension.

NAME may be provided programmatically.
MODE may be provided as string programmatically."
  (interactive)
  (let* ((mode (or mode
		   (if current-prefix-arg
		       (let* ((mode (completing-read
				     "Mode: "
				     (map-keys rcd-temp-buffer-modes) nil t nil
				     'rcd-temp-buffer-mode-history)))
			 mode)
		     "fundamental-mode")))
	 (file (concat rcd-temp-file-directory
		       (or name (format-time-string "%A-%B-%e-%Y-%T."))
		       (cdr (assoc-string mode rcd-temp-buffer-modes)))))
    (find-file file)
    (save-buffer)
    (auto-save-mode 1)
    (funcall (intern mode))))

(defun rcd-temp-buffer-destroy-em ()
  (interactive)
  (kill-matching-buffers "RCD TEMPORARY BUFFER"))


Then calling `rcd-temp-file' with C-u prefix will create and save the
file with chosen mode, it will automatically generate name based on
the time stamp and it will be in the chosen mode, like:

/home/data1/protected/tmp/Sunday-May-30-2021-22:44:11.sql

Defining a key globally:

(global-set-key [f5] 'rcd-temp-file)

That could be one way to just press a key like F5 and to create a
note with the timestamp on a file system without thinking of its
file name, opening of file, saving, etc.


-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

How users start programming in Emacs Lisp...

[Christopher Dimech]

I would like to be able to decide the name from the mini-buffer.
How can that be done?


----- Christopher Dimech

Society has became too quick to pass judgement and declare someone Persona Non-Grata, 
the most extreme form of censure a country can bestow. 

In a new era of destructive authoritarianism, I support Richard Stallman.  Times of great 
crisis are also times of great opportunity. I call upon you to make this struggle yours as well !

https://stallmansupport.org/     https://www.fsf.org/     https://www.gnu.org/


> Sent: Monday, May 31, 2021 at 7:48 AM
> From: "Jean Louis" <bugs@gnu.support>
> To: "Christopher Dimech" <dimech@gmx.com>
> Cc: help-gnu-emacs@gnu.org
> Subject: Re: How users start programming in Emacs Lisp...
>
> * Christopher Dimech <dimech@gmx.com> [2021-05-30 20:22]:
> > I am having some problem figuring out what the following does, having format 
> > repeated twice.
> > 
> > (format format ": " name)
> 
> It could be all simpler, it just adds the sub-name to the main name.
> 
> M-x rcd-temp-buffer would create *RCD TEMPORARY BUFFER: 1*
> 
> but (rcd-temp-buffer "Lisp") would create *RCD TEMPORARY BUFFER: Lisp*
> 
> Myself I don't know why I made it so complex, but it just works and I
> use temporary or scratch buffers that way often.
> 
> Simpler way to open temporary buffer is just:
> 
> C-x b NAME-OF-YOUR-BUFFER
> 
> but when function is tied to key binding it becomes simple, press F5
> or other key how you bind it, and you are already in clean empty new
> temporary buffer. Or invoke C-u prefix to be asked for the mode.
> 
> As Eduardo mentioned maybe it is good to keep those notes, but because
> in my mind there is distinction on what is temporary and what is not,
> for me it is fine that way as I use the database and it is trivial to
> make a function to just open quickly buffer, write anything and have
> it saved for future.
> 
> So I made this one...
> 
> (defun hyperscope-quick-emacs-lisp ()
>   (interactive)
>   (let* ((id (hlink-add-generic (concat "Emacs Lisp: " (rcd-timestamp-literate)) "" 50 33))
> 	 (template (rcd-db-get-entry "hlinktypes" "hlinktypes_template" 50 hs-db)))
>     (when template
>       (rcd-db-update-entry "hyobjects" "hyobjects_text" id template hs-db))
>     (hyperscope-edit-with-mode id "hyobjects_text")))
> 
> The "name" of the note should be something quick:
> 
> (concat "Emacs Lisp: " (rcd-timestamp-literate)) ⇒ "Emacs Lisp: Sunday, May 30 2021, 22:21:26"
> 
> Function `hlink-add-generic' just adds generic object with type 50
> (Emacs Lisp in description, text and report of the object) with the
> parent node 33 which is "Emacs Lisp" set or category.
> 
> A type can have a template, why not, it is inserted as value of the
> column "hyobjects_text", and finally edited in the last line.
> 
> Automatic saving is not a big deal, and automatic revision system
> also.
> 
> What really matters is integration that brings speed to user without
> thinking, and so the workflow is:
> 
> 1. Press F5, edit Emacs Lisp (forget about anything else)
> 
> When editing database stuff, then things like byte compiling will not
> work as it is not tied to buffer, but is not impossible to byte
> compile and keep what is compiled in the database. I did not manage to
> make it.
> 
> I am aware that little of this makes sense to people who edit mostly
> files. Some functionality can be for files:
> 
> ;;;; ↝ RCD TEMPORARY BUFFERS
> 
> (defvar rcd-temp-buffer-mode-history nil)
> (defvar rcd-temp-file-directory "~/tmp/")
> (defvar rcd-temp-buffer-name "RCD TEMPORARY BUFFER")
> (defvar rcd-temp-buffer-modes '(("adoc-mode" . "adoc")
> 				("emacs-lisp-mode" . "el")
> 				("lisp-mode" . ".lisp")
> 				("markdown-mode" . ".md")
> 				("org-mode" . "org")
> 				("sql-mode" . "sql")
> 				("fundamental-mode" . "txt")
> 				("html-mode" . "html")))
> 
> (defun rcd-temp-buffer (&optional name mode)
>   (interactive "p")
>   (let* ((format (concat "*" rcd-temp-buffer-name "%s%s*"))
> 	 (buffer (if name (format format ": " name) (format format "" ""))))
>     (switch-to-buffer (generate-new-buffer buffer))
>     (if current-prefix-arg
> 	(let* ((mode (completing-read
> 		      "Mode: "
> 		      (map-keys rcd-temp-buffer-modes) nil t nil
> 		      'rcd-temp-buffer-mode-history)))
> 	  (funcall (intern mode)))
>       (funcall (intern (or mode "fundamental-mode"))))))
> 
> (defun rcd-temp-file (&optional name mode)
>   "Quickly open temporary file.
> Using C-u as prefix will ask you for the mode of the file and
> will influence the extension.
> 
> NAME may be provided programmatically.
> MODE may be provided as string programmatically."
>   (interactive)
>   (let* ((mode (or mode
> 		   (if current-prefix-arg
> 		       (let* ((mode (completing-read
> 				     "Mode: "
> 				     (map-keys rcd-temp-buffer-modes) nil t nil
> 				     'rcd-temp-buffer-mode-history)))
> 			 mode)
> 		     "fundamental-mode")))
> 	 (file (concat rcd-temp-file-directory
> 		       (or name (format-time-string "%A-%B-%e-%Y-%T."))
> 		       (cdr (assoc-string mode rcd-temp-buffer-modes)))))
>     (find-file file)
>     (save-buffer)
>     (auto-save-mode 1)
>     (funcall (intern mode))))
> 
> (defun rcd-temp-buffer-destroy-em ()
>   (interactive)
>   (kill-matching-buffers "RCD TEMPORARY BUFFER"))
> 
> 
> Then calling `rcd-temp-file' with C-u prefix will create and save the
> file with chosen mode, it will automatically generate name based on
> the time stamp and it will be in the chosen mode, like:
> 
> /home/data1/protected/tmp/Sunday-May-30-2021-22:44:11.sql
> 
> Defining a key globally:
> 
> (global-set-key [f5] 'rcd-temp-file)
> 
> That could be one way to just press a key like F5 and to create a
> note with the timestamp on a file system without thinking of its
> file name, opening of file, saving, etc.
> 
> 
> -- 
> Jean
> 
> Take action in Free Software Foundation campaigns:
> https://www.fsf.org/campaigns
> 
> Sign an open letter in support of Richard M. Stallman
> https://stallmansupport.org/
>

Re: How users start programming in Emacs Lisp...

[Jean Louis]

* Christopher Dimech <dimech@gmx.com> [2021-05-31 23:31]:
> I would like to be able to decide the name from the mini-buffer.
> How can that be done?

Here is the set of improved functions:

- your main buffer name is in variable `rcd-temp-buffer-name'; your
  main buffer name should be something unique, descriptive so that it
  can be destroyed easily (when necessarily) or followed up;

- run M-x rcd-temp-buffer-ask-name or bind it to key if you wish to
  get asked for sub-name

- use C-u prefix to get asked for mode

- if you have many temporary buffers you maybe wish to browse through
  such buffers, because they got their main name, the function M-x
  rcd-temp-buffer-next will go through such. Bind it to a simple key
  and you can press key and browse through temporary buffers quicker. 


;;;; ↝ RCD TEMPORARY BUFFERS

(defvar rcd-temp-buffer-mode-history nil)
(defvar rcd-temp-file-directory "~/tmp/")
(defvar rcd-temp-buffer-name "RCD TEMPORARY BUFFER")
(defvar rcd-temp-buffer-modes '(("adoc-mode" . "adoc")
				("emacs-lisp-mode" . "el")
				("lisp-mode" . ".lisp")
				("markdown-mode" . ".md")
				("org-mode" . "org")
				("sql-mode" . "sql")
				("fundamental-mode" . "txt")
				("html-mode" . "html")))

(defun rcd-temp-buffer (&optional name mode)
  "Generate new temporary buffer."
  (interactive "p")
  (let* ((format (concat "*" rcd-temp-buffer-name "%s%s*"))
	 (buffer (if name (format format ": " name) (format format "" ""))))
    (switch-to-buffer (generate-new-buffer buffer))
    (if current-prefix-arg
	(let* ((mode (completing-read
		      "Mode: "
		      (map-keys rcd-temp-buffer-modes) nil t nil
		      'rcd-temp-buffer-mode-history)))
	  (funcall (intern mode)))
      (funcall (intern (or mode "fundamental-mode"))))))

(defun rcd-temp-buffer-ask-name ()
  "Generate new temporary buffer by asking for buffer name."
  (interactive)
  (rcd-temp-buffer
   (read-from-minibuffer "Buffer name: ")))

(defun rcd-temp-file (&optional name mode)
  "Quickly open temporary file.
Using C-u as prefix will ask you for the mode of the file and
will influence the extension.

NAME may be provided programmatically.
MODE may be provided as string programmatically."
  (interactive)
  (let* ((mode (or mode
		   (if current-prefix-arg
		       (let* ((mode (completing-read
				     "Mode: "
				     (map-keys rcd-temp-buffer-modes) nil t nil
				     'rcd-temp-buffer-mode-history)))
			 mode)
		     "fundamental-mode")))
	 (file (concat rcd-temp-file-directory
		       (or name (format-time-string "%A-%B-%e-%Y-%T."))
		       (cdr (assoc-string mode rcd-temp-buffer-modes)))))
    (find-file file)
    (save-buffer)
    (funcall (intern mode))))

(defvar rcd-temp-buffer-list nil)

(defun rcd-temp-buffer-next ()
  (interactive)
  (unless rcd-temp-buffer-list
    (setq rcd-temp-buffer-list (reverse (rcd-list-matching-buffers rcd-temp-buffer-name))))
  (let ((rcd-buffer (pop rcd-temp-buffer-list))
	(buffer (current-buffer)))
    (if rcd-buffer
	(if (buffer-live-p rcd-buffer)
	    (switch-to-buffer rcd-buffer)
	  (rcd-temp-buffer-next))
      (message "No temporary buffers"))))

(defun rcd-temp-buffer-destroy-em ()
  (interactive)
  (kill-matching-buffers "RCD TEMPORARY BUFFER"))

(defun rcd-list-matching-buffers (query)
  "Return list of matching buffers."
  (let ((list))
    (mapc (lambda (buffer)
	    (when (string-match query (buffer-name buffer))
	      (push buffer list)))
	  (buffer-list))
    list))


-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: Fortran Topics (outline-minor-mode, require, fixed format)

[Jean Louis]

* ludvig-faddeev@gmx.com <ludvig-faddeev@gmx.com> [2021-05-29 23:09]:
> We want to know how to set up three things.
> 
> outline-minor-mode oriented
> 
> 1. How to include headings and subheadings for fortran (fixed and free format)
> 2. Code structure hiding (subroutine, function)
> 3. Setting up new heading lists (outline-regexp,
> outline-heading-alist)

First read the manual, evaluate the following: (info "(emacs)
Fortran")

outline-minor-mode is universal and applies to any "mode" or without
mode it will create outlines depending of your settings.

Then I would first suggest you use:

{M-x customize-group RET outlines RET} to customize the following:


Hide Outline Minor Mode Cycle: Boolean: Toggle  on (non-nil)
    State : SAVED and set.
   Enable cycling of headings in ‘outline-minor-mode’. More

Hide Outline Minor Mode Highlight: Choice: Value Menu Append outline faces to major mode faces
    State : SAVED and set.
   Highlight headings in ‘outline-minor-mode’ using font-lock keywords. More

Hide Outline Minor Mode Prefix: Key sequence: C-c C-d
    State : SAVED and set.
   Prefix key to use for Outline commands in Outline minor mode. More

Learn by reading the settings, clicking on "More"

Then do following:

{C-h v outline-regexp RET} and read about that variable, so in Fortran
the comment is ! maybe you wish to add it there. Customize it, but if
you don't know how, let us know. 

Maybe like this: (setq outline-regexp "[!\f]+") but I cannot be sure
as Fortran I don't know.

Next:

{C-h v outline-heading-alist RET}

Inspect it.

Then decide what and how your headings should be structured? If you
don't state that, it is impossible to tell.

Then good source of information is also here:
https://www.emacswiki.org/emacs/OutlineMinorMode

Maybe you wish headings with

!
!!
!!!
!!!!

So question is what exactly you wish? Outline minor mode is not a
magic mode, it is universal and will do what you want, but you need to
tell it by customizing variables. 

I think it should be:

(setq outline-heading-alist '(("!" . 1) ("!!" . 2) ("!!!" . 3)))

But my attempt to make it work is not well. I am missing something.

After setting that, I did M-x outline-minor-mode twice and it worked. 


-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

P.S. I am not sending copy to those many email addresses as some of
them already fails as non existent.

Re: Fortran Topics (outline-minor-mode, require, fixed format)

[Emanuel Berg via Users list for the GNU Emacs text editor]

Jean Louis wrote:

> outline-minor-mode is universal and applies to any "mode" or
> without mode it will create outlines depending of
> your settings.

Yeah, that's what I said even without knowing it. See?
I'm smart.

Proposition: Get back into the game and stop repeating you
want this for Fortran - it is bad for your karma.

-- 
underground experts united
https://dataswamp.org/~incal

Re: Fortran Topics (outline-minor-mode, require, fixed format)

[Jean Louis]

* Emanuel Berg via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> [2021-05-29 23:53]:
> Jean Louis wrote:
> 
> > outline-minor-mode is universal and applies to any "mode" or
> > without mode it will create outlines depending of
> > your settings.
> 
> Yeah, that's what I said even without knowing it. See?
> I'm smart.
> 
> Proposition: Get back into the game and stop repeating you
> want this for Fortran - it is bad for your karma.

(⌐■_■) but outline-minor-mode could benefit from a user function that
sets it up for user how user wants it.

Serious issue is that 2 important variables: `outline-regexp' and
`outline-heading-alist' are not customizable by using M-x
customize-group

Additionally both of them should be customizable per mode. Don't you
think so?

Then user could set:

1. outline-regexp-per-mode per mode in M-x customize-group

2. outline-heading-alist-per-mode per mode in M-x customize-group and this
   variable could be used to set outline-heading-alist per mode. 

And that solves the problem. Some defaults could be then set for
various already present modes in Emacs, and compatibility with
previous user settings would remain.

-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: Fortran Topics (outline-minor-mode, require, fixed format)

[Emanuel Berg via Users list for the GNU Emacs text editor]

Jean Louis wrote:

> And that solves the problem. Some defaults could be then set
> for various already present modes in Emacs, and
> compatibility with previous user settings would remain.

If you say you solved the OP's problem, on behalf of this
whole list that calls for a reward - said and done:

  https://dataswamp.org/~incal/vidz/fighting-fit-new-school.mp4

Facts for fans:

  https://dataswamp.org/~incal/vidz/incal-vidz.txt

Editor employed to create trippy ASCII art effect: Emacs

-- 
underground experts united
https://dataswamp.org/~incal

Re: Fortran Topics (outline-minor-mode, require, fixed format)

[Jean Louis]

* Emanuel Berg via Users list for the GNU Emacs text editor <help-gnu-emacs@gnu.org> [2021-05-30 00:28]:
> Jean Louis wrote:
> 
> > And that solves the problem. Some defaults could be then set
> > for various already present modes in Emacs, and
> > compatibility with previous user settings would remain.
> 
> If you say you solved the OP's problem, on behalf of this
> whole list that calls for a reward - said and done:
> 
>   https://dataswamp.org/~incal/vidz/fighting-fit-new-school.mp4

That was hypothetical. Problem is only in accessibility of user
settings. 

I cannot see video due to limited mobile Internet bandwidth, if you
could transform it to ANSI video, thanks. (◍•ᴗ•◍)

> Facts for fans:
> 
>   https://dataswamp.org/~incal/vidz/incal-vidz.txt
> 
> Editor employed to create trippy ASCII art effect: Emacs

"No way" for blind users (I hope it is politically correct):

 __ \   _ \  \ \  \   / _` | |   | 
 |   | (   |  \ \  \ / (   | |   | 
_|  _|\___/    \_/\_/ \__,_|\__, | 
                            ____/  

-- 
Jean

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

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/

Re: Fortran Topics (outline-minor-mode, require, fixed format)

[Stefan Monnier via Users list for the GNU Emacs text editor]

ludvig-faddeev@gmx.com [2021-05-29 22:08:46] wrote:
> We want to know how to set up three things.
> outline-minor-mode oriented
> 1. How to include headings and subheadings for fortran (fixed and free format)
> 2. Code structure hiding (subroutine, function)
> 3. Setting up new heading lists (outline-regexp, outline-heading-alist)

Next time you repeat the question, please add "code folding" in
the list.  It's sorely missing,


        Stefan

Re: Fortran Topics (outline-minor-mode, require, fixed format)

[Stefan Monnier via Users list for the GNU Emacs text editor]

Stefan Monnier via Users list for the GNU Emacs text editor [2021-05-29 22:04:44] wrote:
> ludvig-faddeev@gmx.com [2021-05-29 22:08:46] wrote:
>> We want to know how to set up three things.
>> outline-minor-mode oriented
>> 1. How to include headings and subheadings for fortran (fixed and free format)
>> 2. Code structure hiding (subroutine, function)
>> 3. Setting up new heading lists (outline-regexp, outline-heading-alist)
> Next time you repeat the question, please add "code folding" in
       ^^^^
       times

Oops, sorry 'bout that,


        Stefan