Re: AWS Coding Styles (and about boring plain-linear text files in the end)

["Yannick Duchêne (Hibou57)" <yannick_duchene@yahoo.fr>]

Le Wed, 19 Jan 2011 15:52:14 +0100, J-P. Rosen <rosen@adalog.fr> a écrit:
> What I meant is that the sentences in journal are quite predictable, and
> if you miss some information, you can trust that the brain will
> reconstruct it correctly. Moreover, it is optimized for speed of reading.
>
> Reading a program should be optimized for accuracy of understanding, and
> making sure that no misinterpretation can happen. I claim these are
> different goals.

To confirm this, and also in reply to Dmitry. There are at least two  
differences in formal language vs natural language.

Dmitry,

The natural language is known to be redundant and these redundancies vary.  
Ex, you have in french, a tiny word meaning the plural, “les”, and when it  
is associated to a word, this peer also get another mark, meaning the  
plural too, “s” (to keep it simple). If ever a word got the “s” while it  
is not associated to “les”, or is associated to “les” while it does not  
hold the “s”, you may say, “ouch, there must be an error here”. If the  
latter occurs, how could you say if the word is plural or not ? You may  
think natural language dos not help a lot here and semantic of Ada is far  
above… humm, not sure: at least the natural language gave you an  
opportunity to feel there is an error. This is to what the redundancy  
about the plural is often useful to (and many other strange things behave  
the same way). The reader or the audience may also be able to correct  
using some other inference to guess what the status of the word was  
intended to be.

The second example is about to be implicit. There is a more or less  
constant context in natural language, which is a consequence of a more or  
less constant environment I suppose (our expression in our language is in  
reference to our environment, for some numerous  parts). This implicit  
helps to feel possible holes the speech/text may contains. Well, this is  
not real a formal way of doing things, and to help, many checks (among  
ones the one exposed above) are involved.

With a language like Ada (or Lisp, or Python or whatever), while very  
nice, none of the above applies: an error is an error and there is nothing  
which gonna make it somewhat obvious to your eyes. Of course, there are  
spelling mistakes in identifiers, but a statically checked language like  
Ada already do this job for you at compile time. The error you have to  
deal with are more pernicious and deals with consequences (this is not the  
same kind of interpretation as a natural language which is more  
declarative… but I do not mean it is declarative the same way declarative  
programing languages are).

In short: not self-check opportunity, no implicit and different kind of  
consequences in the end.

Reading Ada source and reading a news-paper is indeed like comparing  
Halley's Comet and the Earth.

Now, what checks did you applied while reading me ? What implicit truths  
did you had in mind for you inferences and understanding ? And above all,  
how did you interpreted this in the whole ? You see ? ;) Would be funny to  
see, but we may even never ever see. If you did not interpreted this the  
way I wanted to mean it, you will not crash, I will not crash, and we will  
probably recover (may not be consciously), re-sync in many ways, and many  
other funny behaviors. That's just a third example of the difference  
between this kind of natural language and formal languages.

Just see how natural language text are laid out: not the same at all, its  
mainly flow like (and in the area of text layout, we indeed talk about  
“flow”). This layout difference is the expression of different needs and  
requirements to read.


(hope this was meaningful enough)


-- 
Si les chats miaulent et font autant de vocalises bizarres, c’est pas pour  
les chiens.

“I am fluent in ASCII” [Warren 2010]