Computing Folks of the industry:

please spread the debunking of the truncating line business of the
XXXXing unix-loving XXXXheads, as outlines here:
http://xahlee.org/UnixResource_dir/...ncate_line.html

if this myth-debunking is known widely enough, there wouldn't be any
more line truncating business.

emacs community has always been a thinking community as opposed to the
unix criminals. However by historical happenstance, the emacs of GNU's
Not Unix is essentially a program for unixes, so unavoidable it has to
deal with and inherit some of the ill shits of unix, if for nothing but
to be practical.

However, as of today, emacs don't really have reason to have arrow-down
behavior to be dependent on the hard-coded line wraps. I want the next
emacs version's down-arrow behavior to be fixed. (and optionally as
another mode to move by EOL.)

The reason for this change is easy. For those habituated with hard
wrapped lines, this would cause no difference. However, for those who
have lines that return at logical places, this would be an improvement.
(This is the intuitive way, and all non-geek editors behave this way,
even most editors or IDEs designed for programing.)

The need in this change is significant. By the current behavior of
down-arrow by EOL char, it discourages logical line breaking,
encourages hard-coded line breaking, and engenders the huge and
wide-spread problems as a consequence (as partially detailed in the url
given above): Programs posted online are broken, the who-said-what
quoting systems are a mess to process and comprehend, and needless
complex programs that processes and re-process the hard-wrapped
lines... And also it seeds the bad notions by creation of a generation
of imperative languages based on hard-line wraps (such as many
languages's line comment; and cannot be nested), and the mis-directed
habit in IT of sizing software by EOL-counting. (both of these are
hindrances to functional programing.) Further, in programing there's
large chapters and energy spent on what's called "coding style", which
refers to the petty issue of when and how to press a return so the code
looks pretty. This ubiquitous "coding style" activity is helped by the
hard-wrap habit of thinking, which created these EOL-centric language
syntaxes in the first place. (when coding in a programing language, the
programer should never have to enter returns for the sake of
display-formatting. The language's syntax and the editor should be able
to _easily_ format the code on the fly by a simple parsing. 99.9999% of
EOL in codes today are there manually entered by programer so as to
make it "readible". And as a consequence of these EOL-centric languages
is that programing are focused on code by the lines, instead of logical
units. (a example of a language that is not EOL-centric is Mathematica,
which actually does 3D math typesetting on the fly as well as
auto-formatting the code with respect to line-wrap for display. Similar
languages are LISPs, but they did not push this idea further. (That is
to say, in LISP communities, they on occasion still do and talk about
the petty issues of manual return-pressing.)))

I hope the above is some elucidation on the hard-wrap and
line-truncation business. Please spread the info.

Xah
xah@xahlee.org
http://xahlee.org/PageTwo_dir/more.html

[ Post a follow-up to this message ]