[Oberon] Easier typing of capital letter keywords in Oberon

[Lars O]

Eric Scharff wrote:
> So, in my tinkering with both Native Oberon and Project Oberon 2013, I
> have to say I really like Oberon (the language), but as a newbie, the
> environment is tricky. The most obvious thing for me is that Oberon
> doesn't seem to recognize my caps lock key. Â I know it sounds trivial,
> but it's leading to a huge ergonomic issue for me. typing PROCEDURE or
> INTEGER (and the other keywords) while holding down the shift key is
> extremely uncomfortable. Typing <caps-lock>integer<caps-lock) would be an
> improvement (all lower case typing), but still has extra keystrokes.
> Really, I'd like to type all of the capitalized keywords in lower case,
> and then apply a filter to my document to automatically capitalize, and
> run such a trigger when I Edit.

This sounds like my exact experiences with Oberon. Holding down shift key
and typing long verbose CAPS locks words is a huge turn off to lots of
people, despite Samuel A. Falvo's pathetic claims that it doesn't bother
him and shouldn't bother anyone else. It's not just having to use caps
lock key on keyboard, it's also the long verbose PROCEDURE word itself,
which could easily be shortened to PROC or PRO. Some languages shorten
FUNCTION to FN or FUNC or DEFUN.  I prefer FN, FUNC, or FUN. (without caps
lock, thanks very much).

This is a reason why lots of people are using Golang because you don't
have to use pathetic verbosity just to get work done... Or why a lot of
people chose C instead of Pascal or Ada.

There are programmers who claim that you spend not very much typing out
code, and more time thinking, therefore verbosity is a non issue. That's
like arguing you don't spend much time opening your garage door each day,
therefore there is no need to install a electric garage door opener which
saves you a few seconds each day. It's not just about the time, but the
absolute pain in the butt it is to type out words when you are
programming. Programming should be enjoyable, not a pain in the butt. 
When I whip out Golang functions it's simple and quick. Ada, Cobol,
Pascal, Oberon... becomes a pain, especially since Oberon also requires
END PROCEDURENAME instead of just "end;".

In C like languages such as GoLang the problem becomes the shift key
strokes and strain required to type out { } so some people remap their
keyboards so they don't have to use the shift key as much. Or in Lisp the
brackets ( ) are annoying because you have to hit shift key each time.. so
people remap keyboard... But remapping the keyboard is a pain in the butt
too, and when you use a different computer or a friends computer, your
keyboard mapping is non standard and you forget. Everyone starts having
non standard keyboards it and becomes a huge pain.

So the easiest language to type out without shift key strains would be
something such as:

prog

  pro do-something;
  b
    out('hello world');
  e;

b
  do-something;
e.

But you see you are still caught with the shift key on the brackets ( ) in
the out() call which requires obnoxious shift key.

CamelCaps or BiCaptitalization is even obnoxious because of the shift key
strains.... which is why lisp's dashes are interesting.

Golang decides to use thisStyle instead of ThisStyle to save one extra
shift key on the first letter, which is nice, and only solves 30-50
percent of the problem in a lot of functionNames.

There is no perfect language, but I am certain that PROCEDURE is too
obnoxious to type, as is BEGIN and END which just get in the way. Folks
like Dijkstra argue that shortening your code with terse coding contests
is a bad thing.. but I have a question:  in Math we use shortforms all the
time such as + = - / * ..... Why shouldn't PROCEDURE also have a shortform
PRO, or PROC?  Why shouldn't BEGIN also have a shortform? Or would you
rather type out PLUS, MINUS, MULTIPLY, DIVIDE each time in your
mathematical texts instead of using well known shortform symbols? COBOL
anyone? Can we learn from the mistakes of COBOL and ADA, mr Dijkstra and
mr. Wirth?  How much is a shortform worth, Wirth? A nickel?