Ada requires too much typing!

Ada requires too much typing!

[Peter C. Chapin]

This is just an observation on the difference between two communities.

I've been recently using Scala for a project (I'd rather use Ada, but it's
hard for me to justify the cost of converting... alas). Scala is a
functional/OO hybrid language that targets the JVM. It prides itself on,
among other things, its concise syntax. Not surprisingly the Scala community,
as evidenced by the posts on a Scala newsgroup, regard conciseness as an
important feature for a programming language. I agree that conciseness can in
some cases improve readability. However, I also believe that it can obscure a
lot of important detail and make it hard to understand the execution cost of
the code. Perhaps because of my experience with Ada, or perhaps because of my
basic personality, I'm not necessarily a fan of extreme conciseness.

However, the argument that I see some people putting forth on the Scala group
is that conciseness is good because it saves typing. I really can't
understand that. How hard is it to type?

One of the people on that group posted this comment related to the fact that
Java requires public/private access specifiers on methods whereas Scala uses
public by default. Thus in the "common" case of a public method you don't
have to type the word 'public'...

<quote>
The whole "I will make you do extra work coding just so you can demonstrate
to me that you're not being lazy" attitude of Java is perhaps useful in some
situations, but we already have Java for that.  I don't think adopting that
attitude of making you do busywork would be an asset for Scala.

  --Rex
</quote>

Hmmm... "busywork"... interesting. I can only imagine what this person, or
others in that community, would have to say about Ada... or SPARK!

Peter

Re: Ada requires too much typing!

[Ludovic Brenta]

Peter C. Chapin wrote on comp.lang.ada:
> <quote>
> The whole "I will make you do extra work coding just so you can demonstrate
> to me that you're not being lazy" attitude of Java is perhaps useful in some
> situations, but we already have Java for that.  I don't think adopting that
> attitude of making you do busywork would be an asset for Scala.
>
>   --Rex
> </quote>
>
> Hmmm... "busywork"... interesting. I can only imagine what this person, or
> others in that community, would have to say about Ada... or SPARK!

Interpreting an rephrasing Rex's words: "Scala is for lazy
programmers; non-lazy ("serious"?) programmers should use Java." If he
really thinks Java is for the non-lazy ("serious"?) programmers, then
he needs a reality check. If Scala is for lazy programmers, then I'd
rather not have anything to do with it or with said programmers :)

Also interesting is his word "coding". In his mind, Java and Scala are
both for "coding", not for "writing" or "designing" or "explaining" a
program. In this light I can understand him; since both languages can
only convey "code", verbosity is of little value indeed.

Ada, by contrast, is not for "coders", it is for software engineers.
Ada program text (as opposed to "source code") carries a lot of
information about the design and intent of the program; about the whys
and wherefores and not just about the hows. *This* is the value of
verbosity.

Like I said earlier: sloppy programmers avoid Ada, therefore Ada helps
avoid sloppy programmers.

--
Ludovic Brenta.

Re: Ada requires too much typing!

[Peter Hermann]

Ludovic Brenta <ludovic@ludovic-brenta.org> wrote:
> Like I said earlier: sloppy programmers avoid Ada, therefore Ada helps
> avoid sloppy programmers.
> 
> --
> Ludovic Brenta.

(-:
www.ihr.uni-stuttgart.de/fileadmin/user_upload/autoren/ph/ada/resources_on_ada.html#quote
:-)

Ludovic: should I remove the "to"?

Re: Ada requires too much typing!

[Ludovic Brenta]

Peter Hermann wrote on comp.lang.ada:
> Ludovic Brenta <ludo...@ludovic-brenta.org> wrote:
> > Like I said earlier: sloppy programmers avoid Ada, therefore Ada helps
> > avoid sloppy programmers.
>
> > --
> > Ludovic Brenta.
>
> (-:www.ihr.uni-stuttgart.de/fileadmin/user_upload/autoren/ph/ada/resourc...
> :-)
>
> Ludovic: should I remove the "to"?

Yes, you should. And thanks for making believe I'm famous :)

--
Ludovic Brenta.

Re: Ada requires too much typing!

[Pascal Obry]

Ludovic,

> Like I said earlier: sloppy programmers avoid Ada, therefore Ada helps
> avoid sloppy programmers.

Agreed 100%, that's probably the easiest way to attract only sane
programmers on your project :) I've done that, it works!

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|    http://www.obry.net  -  http://v2p.fr.eu.org
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver keys.gnupg.net --recv-key F949BD3B

Re: Ada requires too much typing!

[Yannick Duchêne (Hibou57)]

Le Wed, 26 May 2010 15:29:31 +0200, Ludovic Brenta  
<ludovic@ludovic-brenta.org> a écrit:
> Also interesting is his word "coding". In his mind, Java and Scala are
> both for "coding", not for "writing" or "designing" or "explaining" a
> program.
We meet on this feeling : we should be writing, not coding (“coding”, this  
word hearts my eyes/hears)

Was pleasant to read this :)

-- 
There is even better than a pragma Assert: a SPARK --# check.

Re: Ada requires too much typing!

[Jeffrey R. Carter]

Peter C. Chapin wrote:
> 
> However, the argument that I see some people putting forth on the Scala group
> is that conciseness is good because it saves typing. I really can't
> understand that. How hard is it to type?

The important point is that in the real world, code is written once, but read 
many times. I'm sure this is just as true with Scala as it is with every other 
language. So saving typing at the cost of making it harder to read is a false 
economy. Any project where money is involved should take that into consideration.

As Preben Randhol put it, "Saving keystrokes is the job of the text editor, not 
the programming language."

-- 
Jeff Carter
"Mr. President, we must not allow a mine-shaft gap!"
Dr. Strangelove
33

Re: Ada requires too much typing!

[Warren]

Jeffrey R. Carter expounded in news:htjce2$31g$1@tornado.tornevall.net:

> Peter C. Chapin wrote:
>> However, the argument that I see some people putting forth on the
>> Scala group is that conciseness is good because it saves typing. I
>> really can't understand that. How hard is it to type?
> 
> The important point is that in the real world, code is written once,
> but read many times. I'm sure this is just as true with Scala as it is
> with every other language. 

Not so (snickers) - Perl is read once, rewritten many times.

Even the perl code's author can't remember how it worked,
3 months later ;-)

Warren

Re: Ada requires too much typing!

[Adam Beneschan]

On May 27, 10:10 am, Warren <ve3...@gmail.com> wrote:
> Not so (snickers) - Perl is read once, rewritten many times.
>
> Even the perl code's author can't remember how it worked,
> 3 months later ;-)

That's why Perl, and many other computer languages, provide features
called "comments".  But I suspect our friend Rex would think that the
purpose of comments is just busywork to prove to some evil IT
supervisor that his employees aren't lazy.  :)

                                   -- Adam

Re: Ada requires too much typing!

[Warren]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1034 bytes --]

Adam Beneschan expounded in news:c86a76ae-5b25-4c13-a026-5439a57803f6
@k25g2000prh.googlegroups.com:

> On May 27, 10:10�am, Warren <ve3...@gmail.com> wrote:
>> Not so (snickers) - Perl is read once, rewritten many times.
>>
>> Even the perl code's author can't remember how it worked,
>> 3 months later ;-)
> 
> That's why Perl, and many other computer languages, provide features
> called "comments".  But I suspect our friend Rex would think that the
> purpose of comments is just busywork to prove to some evil IT
> supervisor that his employees aren't lazy.  :)
> 
>                                    -- Adam

I once had the, ahem, pleasure of fixing a summer student's
program after he left to resume his education. He obviously
did not understand what comments where for. They were mostly
like this one:

-- The next statement adds 1 to the current value of I

I = I + 1

Yikesy! The comments not only didn't help but
they got in the way of reading the code (not
to mention that variables were also poorly named).

Warren

Re: Ada requires too much typing!

[BrianG]

Jeffrey R. Carter wrote:
> Peter C. Chapin wrote:
>>
>> However, the argument that I see some people putting forth on the 
>> Scala group
>> is that conciseness is good because it saves typing. I really can't
>> understand that. How hard is it to type?
> 
> The important point is that in the real world, code is written once, but 
> read many times. I'm sure this is just as true with Scala as it is with 
> every other language. So saving typing at the cost of making it harder 
> to read is a false economy. Any project where money is involved should 
> take that into consideration.
> 
> As Preben Randhol put it, "Saving keystrokes is the job of the text 
> editor, not the programming language."
> 
Forget text editors, saving keystrokes is the job of the computer.  And 
I've got just the computer for "Rex":  a Sinclair ZX-81.  Each key on 
the (chicklet) keyboard has a (BASIC) keyword.  Rather than typing out 
G-O-T-O, you only type G and the computer fills in the rest.  It's also 
context-sensitive, so you get the minimum typing to get the program you 
want (as long as you're not an experienced typer and type out the 
keywords anyway).

Better yet - a computer I used in college had a hexadecimal keyboard, 
where you typed in machine code.  Think of it:  no verbosity, no 
"comments", no carriage returns; just raw hex.  What could be more 
"efficient"?

--Bg
-- If writing programs were more important than reading them, we'd be 
programming with invisible ink.  We wouldn't need a monitor.  We 
wouldn't need to save the source code - compile it and you have the 
executable/object, what more do you need?

Re: Ada requires too much typing!

[Dmitry A. Kazakov]

On Sat, 29 May 2010 20:49:09 -0400, BrianG wrote:

> -- If writing programs were more important than reading them, we'd be 
> programming with invisible ink.

Mean this:

http://en.wikipedia.org/wiki/Whitespace_%28programming_language%29

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Ada requires too much typing!

[Yannick Duchêne (Hibou57)]

Le Sun, 30 May 2010 09:27:58 +0200, Dmitry A. Kazakov  
<mailbox@dmitry-kazakov.de> a écrit:
>> -- If writing programs were more important than reading them, we'd be
>> programming with invisible ink.
>
> Mean this:
>
> http://en.wikipedia.org/wiki/Whitespace_%28programming_language%29

I like the quote on the homepage:
http://compsoc.dur.ac.uk/whitespace/

> What are the advantages of Whitespace?
>
> Some things which are difficult in other languages are made much
> easier in Whitespace. For example, literate programming is simply a
> matter of writing your helpful comments in between program
> instructions.
Dear friends, we have our UML killer.

Have a Merry Christmas

-- 
There is even better than a pragma Assert: a SPARK --# check.
--# check C and WhoKnowWhat and YouKnowWho;
--# assert Ada;
--  i.e. forget about previous premises which leads to conclusion
--  and start with new conclusion as premise.

Re: Ada requires too much typing!

[Simon Wright]

"Yannick Duchêne (Hibou57)" <yannick_duchene@yahoo.fr> writes:

>> What are the advantages of Whitespace?
>>
>> Some things which are difficult in other languages are made much
>> easier in Whitespace. For example, literate programming is simply a
>> matter of writing your helpful comments in between program
>> instructions.

I see there is an Emacs mode -- life is complete

http://compsoc.dur.ac.uk/whitespace/tools.php

Re: Ada requires too much typing!

[BrianG]

Simon Wright wrote:
> "Yannick Duchêne (Hibou57)" <yannick_duchene@yahoo.fr> writes:
> 
>>> What are the advantages of Whitespace?
>>>
>>> Some things which are difficult in other languages are made much
>>> easier in Whitespace. For example, literate programming is simply a
>>> matter of writing your helpful comments in between program
>>> instructions.
> 
> I see there is an Emacs mode -- life is complete
> 
> http://compsoc.dur.ac.uk/whitespace/tools.php

But what about a translator to-from Ada?
Could you 'polyglot' the same program for added security? :-)

--IN A WORLD WHERE I FEEL SO SMALL,
-- I CAN'T STOP THINKING BIG.

Re: Ada requires too much typing!

[Adam Beneschan]

On May 26, 5:57 am, "Peter C. Chapin" <pcc482...@gmail.com> wrote:
> This is just an observation on the difference between two communities.
>
> I've been recently using Scala for a project (I'd rather use Ada, but it's
> hard for me to justify the cost of converting... alas). Scala is a
> functional/OO hybrid language that targets the JVM. It prides itself on,
> among other things, its concise syntax. Not surprisingly the Scala community,
> as evidenced by the posts on a Scala newsgroup, regard conciseness as an
> important feature for a programming language. I agree that conciseness can in
> some cases improve readability. However, I also believe that it can obscure a
> lot of important detail and make it hard to understand the execution cost of
> the code. Perhaps because of my experience with Ada, or perhaps because of my
> basic personality, I'm not necessarily a fan of extreme conciseness.
>
> However, the argument that I see some people putting forth on the Scala group
> is that conciseness is good because it saves typing. I really can't
> understand that. How hard is it to type?

not hard 4 u obvsly but we dealng w generation hu thnks "lengthy
essay" means sumth 2 long 2 fit in2 Twitter msg

                          -- a

Re: Ada requires too much typing!

[Georg Bauhaus]

On 26.05.10 14:57, Peter C. Chapin wrote:

> One of the people on that group posted this comment related to the fact that
> Java requires public/private access specifiers on methods whereas Scala uses
> public by default. Thus in the "common" case of a public method you don't
> have to type the word 'public'...

In this particular case of writing "public" or not, there is an
interesting point. If you allow defaults, then omitting access
specifiers should mean "public", not anything else. The reason
is that this default forces programmers to get their publicly
announced subprograms right, semantically, to be called by just
anyone.

Ideally, of course. I don't know whether lazy use of a keyboard
enables programmers to use the few seconds to get the interface right.

Ada in a sense makes specifying access (syntactically) simpler:
everything before "private" is public, without mention.
That leaves a question: is specifying access using visibility
rules and child packages artistry? ;-)

Anyway, if understanding text requires more than linear
reading, there are arguments in favor of conciseness.
UML or any other "bird's eye view" tool show the usefulness
of seeing relations between pieces of source text in one place.

Re: Ada requires too much typing!

[Yannick Duchêne (Hibou57)]

Le Wed, 26 May 2010 19:20:00 +0200, Georg Bauhaus  
<rm.dash-bauhaus@futureapps.de> a écrit:
> Anyway, if understanding text requires more than linear
> reading, there are arguments in favor of conciseness.
> UML or any other "bird's eye view" tool show the usefulness
> of seeing relations between pieces of source text in one place.
Did you ever heard about Literate Programming ? What do you think about it  
in this area ? (possibly with editor support for that)

-- 
There is even better than a pragma Assert: a SPARK --# check.

Re: Ada requires too much typing!

[Simon Wright]

"Yannick Duchêne (Hibou57)" <yannick_duchene@yahoo.fr> writes:

> Did you ever heard about Literate Programming ? What do you think
> about it in this area ? (possibly with editor support for that)

Your earlier remarks about LP reminded me of nuweb
(http://sourceforge.net/projects/nuweb/) and my desire to write more
extensive unit tests for the Booch Components
(http://sourceforge.net/projects/booch95/). 

nuweb-related work so far at http://public.me.com/simon.j.wright,
subdirectory lp/ - bc_tests.w is the web source, .pdf the readable
version of it, the .gpr and .ad[bs] files are the generated code.

One thing I find is that LP is fine for the overall description BUT you
have to get down to the detail at some point and there comes a time when
it really doesn't justify a lot of explanation. As an example, section
4.1 in bc_tests.pdf isn't too bad but sections 4.2, 4.3 and 4.4 are just
boring.

Of course writing unit tests for several different versions of the same
concept is going to be boring anyway!

Re: Ada requires too much typing!

[Georg Bauhaus]

On 5/26/10 9:33 PM, Yannick Duchêne (Hibou57) wrote:
> Le Wed, 26 May 2010 19:20:00 +0200, Georg Bauhaus
> <rm.dash-bauhaus@futureapps.de> a écrit:
>> Anyway, if understanding text requires more than linear
>> reading, there are arguments in favor of conciseness.
>> UML or any other "bird's eye view" tool show the usefulness
>> of seeing relations between pieces of source text in one place.
> Did you ever heard about Literate Programming ? What do you think about
> it in this area ? (possibly with editor support for that)
>

There even was/is a WEB adaptation for Ada 83
with all the features of the original WEB.
Like the other WEB systems, it can help with PERFORM-like
subdivisions, but not act as a replacement for "powerful"
operators (APL style), or with seeing call chains, say. (The tools
to show the latter are all outside the language, I think.)
    Being able to give detailed procedures as to how an operation
is to be performed (Ada) comes at a price (more things
to specify). Program planners who would rather leave the
programming to the engineers might then say "not my job!"
and go on with writing algorithms very concisely,
not using Ada ;-)  Understanding an algorithm might
be easier without the details...


Hypothesis: Compiler makers don't like the literate programming
tools out there.  Reason: Literate Programming makes your
programming language appear to be less than perfect for
structuring. :-)


IIRC, Robert Dewar once explained how Jean Ichbiah used
Word for writing about Ada and then called macros to
copy Ada text from the Word document to some external file.

Re: Ada requires too much typing!

[Fritz Wuehler]

Like anything you need to strike a balance. As many people know, Ada was
designed to be read. It is one of the best in that regard, probably only
COBOL comes close and it's not nearly as powerful.

Extremes in the the direction of terseness are APL and Perl. They can be
impossible to read. Sometimes even reading code you wrote last week is
hard. I'm sure there are others but those two come to mind at the moment.

People mostly lack discipline and gravitate towards lazy practices. C++
coders often call Ada (if they even hear about it) verbose. It's silly, but
I really don't care. It's their problem, not ours. Sloppy code can be
written in any language, and unfortunately it's proven in practice. Still,
sloppy code in some languages is easier to understand than others, but Ada
makes it harder than average to write sloppy code that's also wrong.

There's also the matter of aesthetics. Most programming languages
(especially C and Java and their offspring) are just ugly. I prefer ALGOL
and its derivatives, in my view they're prettier, cleaner, and better. To
each his own, but don't expect me to read your crap if you code it in C,
C++, or Java!

Re: Ada requires too much typing!

[Yannick Duchêne (Hibou57)]

Le Thu, 27 May 2010 04:07:19 +0200, Fritz Wuehler  
<fritz@spamexpire-201005.rodent.frell.theremailer.net> a écrit:
> Extremes in the the direction of terseness are APL and Perl. They can be
> impossible to read. Sometimes even reading code you wrote last week is
> hard. I'm sure there are others but those two come to mind at the moment.
Sed scripts ?

-- 
There is even better than a pragma Assert: a SPARK --# check.

Re: Ada requires too much typing!

[Warren]

Fritz Wuehler expounded in
news:0620a415e6bbc1a5629e906e27bec5cb@msgid.frell.theremailer.net: 

> Like anything you need to strike a balance. As many people know, Ada
> was designed to be read. ..
> 
> People mostly lack discipline and gravitate towards lazy practices.
> C++ coders often call Ada (if they even hear about it) verbose. It's
> silly, but I really don't care. It's their problem, not ours. Sloppy
> code can be written in any language, and unfortunately it's proven in
> practice.

I don't mind C++ too much, until you start looking at 
"templates". To me, the "templates" idea seemed like
a bag on the side to solve the generic problem. C/C++ 
already had substantial syntax up to that point. 
Then templates was shoe-horned into the compiler and
the linker was mangled to make it all work. Even 
more, I find myself with a gag reflex whenever 
I look at STL use.

Ada's generics are also somewhat tricky (the subject of
generics is complex), but it seems an order of magnitude 
cleaner and simpler to understand. Certainly using 
instantiated code is far simpler. Also for the end reader,
it is far easier to read, with generics.

> Still, sloppy code in some languages is easier to understand
> than others, but Ada makes it harder than average to write sloppy code
> that's also wrong. 

One feature I love is the enumerated type in Ada. As long as
you code each when clause in a case statement and avoid "when
others =>", it makes extending an application a breeze. You can
then add one new element to that enumerated type and then the 
compiler will point out every point in the project that needs 
your attention.

> There's also the matter of aesthetics. Most programming languages
> (especially C and Java and their offspring) are just ugly.

I've been using C for almost my entire career. So when it is
properly formatted, it doesn't look ugly to me. But I have 
seen a lot of ugly C/C++ code. The worst example was an XMODEM
(I'm dating myself) program using macros to make the C code
look like PASCAL!! It was macro'd to death. I finally ran it
through cpp and refactored it, in order to make it useful. 
That original code probably still exists somewhere out on 
the net (maybe SIMTEL archives?)  Scary that.

I do find that reading someone else's Ada code is far breezier 
than C/C++/java code. IMO, C# has made it extra ugly with 
the new syntax embedded in it. I like Ada's sparse use
of symbols (no {} or [] for example).

> I prefer
> ALGOL and its derivatives, in my view they're prettier, cleaner, and
> better. To each his own, but don't expect me to read your crap if you
> code it in C, C++, or Java!

Perl is the worst. You'd have to pay me well to look at someone's
perl code. ;-)

Warren

Re: Ada requires too much typing!

[Colin Paul Gloster]

On Wed, 26 May 2010, Peter C. Chapin sent:

|-----------------------------------------------------------------------------|
|"[..]                                                                        |
|                                                                             |
|[..]                                                                         |
|[..] Not surprisingly the Scala community,                                   |
|as evidenced by the posts on a Scala newsgroup, regard conciseness as an     |
|important feature for a programming language. I agree that conciseness can in|
|some cases improve readability. However, I also believe that it can obscure a|
|lot of important detail and make it hard to understand the execution cost of |
|the code. [..]"                                                              |
|-----------------------------------------------------------------------------|

Passing a parameter to an Ada subprogram can look like choosing an
element of an Ada array, with a very different execution cost.

|-----------------------------------------------------------------------------|
|"[..]                                                                        |
|                                                                             |
|However, the argument that I see some people putting forth on the Scala group|
|is that conciseness is good because it saves typing. I really can't          |
|understand that. How hard is it to type?                                     |
|                                                                             |
|[..]"                                                                        |
|-----------------------------------------------------------------------------|

Not very.

Re: Ada requires too much typing!

[Yannick Duchêne (Hibou57)]

Le Thu, 03 Jun 2010 18:54:57 +0200, Colin Paul Gloster  
<Colin_Paul_Gloster@acm.org> a écrit:

Box design: (c) Peter C. Chapin.
+---------------------------------------------------------+
| " Passing a parameter to an Ada subprogram can look     |
| like choosing an element of an Ada array, with a very   |
| different execution cost. "                             |
+---------------------------------------------------------+
That's another area and not part of language semantic (readability refers  
to meaning, semantic).

And you will nor see difference of execution cost between two different  
functions.


-- 
There is even better than a pragma Assert: a SPARK --# check.
--# check C and WhoKnowWhat and YouKnowWho;
--# assert Ada;
--  i.e. forget about previous premises which leads to conclusion
--  and start with new conclusion as premise.

Re: Ada requires too much typing!

[Yannick Duchêne (Hibou57)]

Le Thu, 03 Jun 2010 18:09:38 +0200, Yannick Duchêne (Hibou57)  
<yannick_duchene@yahoo.fr> a écrit:

> Box design: (c) Colin Paul Gloster.
(was confused with names)


-- 
There is even better than a pragma Assert: a SPARK --# check.
--# check C and WhoKnowWhat and YouKnowWho;
--# assert Ada;
--  i.e. forget about previous premises which leads to conclusion
--  and start with new conclusion as premise.

Re: Ada requires too much typing!

[Nicolas Cóilin Paul de Gloucester]

[-- Attachment #1: Type: TEXT/PLAIN, Size: 540 bytes --]

On Thu, 3 Jun 2010, Yannick Duchêne (Hibou57) sent:

|---------------------------------------|
|"> Box design: (c) Colin Paul Gloster."|
|---------------------------------------|

Nicolas Cóilin Paul de Gloucester to you.

Actually I did not invent it, but thank you for a bit of fun.

|---------------------------------------|
|"(was confused with names)"            |
|---------------------------------------|

Francophones had been historically noted for being confused by names,
not least of all Gaelic names.

Bye,
me

Re: Ada requires too much typing!

[Ludovic Brenta]

Nicolas Cóilin Paul de Gloucester wrote:
> On Thu, 3 Jun 2010, Yannick Duchêne (Hibou57) sent:
>
> |---------------------------------------|
> |"> Box design: (c) Colin Paul Gloster."|
> |---------------------------------------|

This box design is a nuisance to me; I don't want to have to teach
emacs how to fill a boxed paragraph in gnus; M-q fills paragraphs
beginning with most quoting characters (>, !, |, etc.) correctly but
not boxed ones. In Google Groups, boxed paragraphs are ugly when in
proportional font.

> Nicolas Cóilin Paul de Gloucester to you.
>
> Actually I did not invent it, but thank you for a bit of fun.
>
> |---------------------------------------|
> |"(was confused with names)"            |
> |---------------------------------------|
>
> Francophones had been historically noted for being confused by names,
> not least of all Gaelic names.

That's your fault. How many different names or spellings thereof do
you post under? Just in the past 24 hours I've seen variations like:

Colin Paul Gloster
Nicolas Cóilin Paul Gloucester
Nicolas Collin Paul de Gloucester
Nicolas Cóilin Paul de Gloucester
Nicholas Cóilin Paul de Gloucester

So, is your name really a regexp? Is this one in extended syntax
correct?
(Nich?olas)|(C[óo]l?lin) Paul (de)? Glo(uce)?ster

How about just "Paul" which seems to be the only constant?

--
Ludovic Brenta.

Off-topic: subthread of: "Re: Ada requires too much typing!"

[Colin Paul Gloster]

[-- Attachment #1: Type: TEXT/PLAIN, Size: 3177 bytes --]

For people hoping that this subthread has something to do with Ada: it
does not.



On Fri, 4 Jun 2010, Ludovic Brenta sent:

"Nicolas Cóilin Paul de Gloucester wrote:
> On Thu, 3 Jun 2010, Yannick Duchêne (Hibou57) sent:
>
> |---------------------------------------|
> |"> Box design: (c) Colin Paul Gloster."|
> |---------------------------------------|

This box design is a nuisance to me;"



It can be difficult to please everyone all the time.



" I don't want to have to teach
emacs how to fill a boxed paragraph in gnus; M-q fills paragraphs
beginning with most quoting characters (>, !, |, etc.) [..]
[..]"




They are not quoting characters. One is a symbol for greater than. One
is an exclamation mark. One looks like a line segment in many fonts
but is often denoted by two line segments on a keyboard.




"> Nicolas Cóilin Paul de Gloucester to you.
>
> Actually I did not invent it, but thank you for a bit of fun.
>
> |---------------------------------------|
> |"(was confused with names)"            |
> |---------------------------------------|
>
> Francophones had been historically noted for being confused by names,
> not least of all Gaelic names.

That's your fault."



I do not like to be blamed for things done by people who died hundreds
of years before I ever existed. It is not my fault that despite
transliterating a Greek sigma to an s, Francophones omit the s when
trying to pronounce Nicolas.

It is not my fault that Normans (well, ex-Normans now since they died
hundreds of years ago) after an invasion thought that it would be a
cute form of integration with local people to misuse the name Cóilin
as an alternative to Colin when talking about someone (anyone) named
Nicholas. How about blaming me for Nicola in English being pronounced
differently (and being for a different gender) than Nicola in Italian,
or for Nicola in Italian being pronounced differently than Nicolas?

Would you like to blame me for Francophones confusing the Latin name
Margaret (shown here spelt in English) with Daisy? How about blaming
me for the time (when I was alive) when a Dutch newspaper (which I
never worked nor wrote for) identified someone called Margaret with an
English adaptation of a Gaelic form of the name in an otherwise
Dutch article?




" How many different names"




I only ever post under one name.



" or spellings thereof do
you post under? Just in the past 24 hours I've seen variations like:

Colin Paul Gloster
Nicolas Cóilin Paul Gloucester
Nicolas Collin Paul de Gloucester
Nicolas Cóilin Paul de Gloucester
Nicholas Cóilin Paul de Gloucester"


A few.



"So, is your name really a regexp?"


I do not own the name. It existed long before I did.



" Is this one in extended syntax
correct?
(Nich?olas)|(C[óo]l?lin) Paul (de)? Glo(uce)?ster"


No.



"How about just "Paul""


No. Just restricting it to English, Paul can be spelt as Paley. Still
restricting it to English, Paul can be spelt with none of P; a; and u.




" which seems to be the only constant?"



The name is constant.

From,
me

Re: Ada requires too much typing!

[Nicholas Collin Paul de Gloucester]

[-- Attachment #1: Type: TEXT/PLAIN, Size: 1558 bytes --]

On Thu, 3 Jun 2010, Yannick Duchêne (Hibou57) sent:

|-----------------------------------------------------------------------|
|"Le Thu, 03 Jun 2010 18:54:57 +0200, Colin Paul Gloster                |
|<Colin_Paul_Gloster@acm.org> a écrit:                                  |
|                                                                       |
|[..]                                                                   |
|+---------------------------------------------------------+            |
|| " Passing a parameter to an Ada subprogram can look     |            |
|| like choosing an element of an Ada array, with a very   |            |
|| different execution cost. "                             |            |
|+---------------------------------------------------------+            |
|[..]                                                                   |
|                                                                       |
|And you will nor see difference of execution cost between two different|
|functions."                                                            |
|-----------------------------------------------------------------------|

Actually, you would. Different functions would have different bodies
would tend to have different execution costs. Aside from that, inlined
functions would tend to cost differently than other functions.

However, I had not been posting re different functions. I posted re
utilizing an array and utilizing a subprogram. These can look
identical but cost very differently.