i realized kinda interesting thought today

you know when you read language like c, your way
is probably read from bottom to top (i say probably coz
im not a master in reading other people codes still - but
logically this is a way ) i mean you must know what
bottom definitions do then you read what mid levels
definition do then you know what top level definitions
do

this is kinda unfortunate as biggest dose of
understanding (the most overwiev (flybird view)
part of a program is in top definition level

obviously if you use good naming you may inform
reader what those things do without always need
to decrypt it what it really do - but how it work
practically proably wary

i also remember some talk with bartc whan he emphases
he want to read line of given code from top to bottom so
i shouldnt add something that will make force him to check
definition (he talked not on naming though but on syntax
construction as far as i remember)

this is generally good remark (bartc righteus need)
as some will anderstood it more generally as note thet readability
from bottom to top is important
though in case of syntax it seem to me that not allowing it
this way (i mean redefining some syntaxes on bot making reader
needed to check in bottom what it is) would make language
'stiff' so its not a way to go (hovever i would need to check it yet)

note hovever that this bottom to top readability may be
obtained (in some degrees) as i already said in the way of naming
and experience, more to say imagine that language will mature to
this extent that given world will be filled by meaning allowin
you to know that if you write draw it will draw in some expected
way, if you will write move it will move in some expected way you know
this mean that programming language will become like natural language
but not in gramatic way/sense but in thsi way that in present programming
languages you define 'words' (or terms) of this language whose words are 'empty' and redefined (are more like forms of words than words) when in real
language the words carry the meaning - if you say cat its a cat (not a 3letter label when you can put anything)

this simply mean than if language will mature it probably will mature this way that some stable names (those things that today are usualy function names) will carry stable actions and liek in language you learn 10k 20k or 50 k words programmers will learn hundreds or few tousands function names by heart, and those function names will carry stable meaning

On Tuesday, 8 February 2022 at 10:44:54 UTC, fir wrote:
> i realized kinda interesting thought today
>
> you know when you read language like c, your way
> is probably read from bottom to top (i say probably coz
> im not a master in reading other people codes still - but
> logically this is a way ) i mean you must know what
> bottom definitions do then you read what mid levels
> definition do then you know what top level definitions
> do
>
If you are writing a module, should you put the high level calls at the top
and the low-level calls lower down? Or should you put the low level calls
at the top and the high level calls last?
The advantage of doing it the second way is that if you don't export the
lower level functions, you don't need prototypes. Also, it reveals mututal
dependency, which is usually a poor design decision.
The advantage of the first way is that non-programming documents are
usually provided as overview first, then details, then minor footnotes.
That matches the way most readers like to absorb information.

środa, 9 lutego 2022 o 11:28:54 UTC+1 Malcolm McLean napisał(a):
> On Tuesday, 8 February 2022 at 10:44:54 UTC, fir wrote:
> > i realized kinda interesting thought today
> >
> > you know when you read language like c, your way
> > is probably read from bottom to top (i say probably coz
> > im not a master in reading other people codes still - but
> > logically this is a way ) i mean you must know what
> > bottom definitions do then you read what mid levels
> > definition do then you know what top level definitions
> > do
> >
> If you are writing a module, should you put the high level calls at the top
> and the low-level calls lower down? Or should you put the low level calls
> at the top and the high level calls last?
> The advantage of doing it the second way is that if you don't export the
> lower level functions, you don't need prototypes. Also, it reveals mututal
> dependency, which is usually a poor design decision.
> The advantage of the first way is that non-programming documents are
> usually provided as overview first, then details, then minor footnotes.
> That matches the way most readers like to absorb information.

when i was writing here of reading top-bottom of bottom top i didnt mean top botom in file
but in a tree of function calls (main it here on top and functions like SetPixel of printf on bot)

i was writing that reading other people code begining from top is/would be better (if you want to understand how the program work the overal scheme is in top part) but c kinda enforces reading
begining from bot to top (becouse bot are non dependant on anything else from your code so you could understand and check waht it exactly do without knowing the resto of code) .. i mean enforces but im not sure how many people in fact do read code this way...normal reading i think goes on "names" not on real code transformations

and what i write about is also thet present languages are like not a languages but a gramatics of languages becouse functions (which are like words in languages) in present languages are not a words who carry well defined meaning but are now only forms to fill in ...in mature languiage
in future you will probably not define a 'words' but know what they do and use them and i mean
relation among names like, i dont know, "write" "draw" "put_sprite" will be fixed same way as word "cat" in normal language is fixed

(this is kinda interesting remark imo for thoise who are interested in things..i mean interesting is observation that when you define words in language it is not quite language, it is language 'under production' ..in language you got words defined)

środa, 9 lutego 2022 o 18:25:44 UTC+1 fir napisał(a):
> środa, 9 lutego 2022 o 11:28:54 UTC+1 Malcolm McLean napisał(a):
> > On Tuesday, 8 February 2022 at 10:44:54 UTC, fir wrote:
> > > i realized kinda interesting thought today
> > >
> > > you know when you read language like c, your way
> > > is probably read from bottom to top (i say probably coz
> > > im not a master in reading other people codes still - but
> > > logically this is a way ) i mean you must know what
> > > bottom definitions do then you read what mid levels
> > > definition do then you know what top level definitions
> > > do
> > >
> > If you are writing a module, should you put the high level calls at the top
> > and the low-level calls lower down? Or should you put the low level calls
> > at the top and the high level calls last?
> > The advantage of doing it the second way is that if you don't export the
> > lower level functions, you don't need prototypes. Also, it reveals mututal
> > dependency, which is usually a poor design decision.
> > The advantage of the first way is that non-programming documents are
> > usually provided as overview first, then details, then minor footnotes.
> > That matches the way most readers like to absorb information.
> when i was writing here of reading top-bottom of bottom top i didnt mean top botom in file
> but in a tree of function calls (main it here on top and functions like SetPixel of printf on bot)
>
> i was writing that reading other people code begining from top is/would be better (if you want to understand how the program work the overal scheme is in top part) but c kinda enforces reading
> begining from bot to top (becouse bot are non dependant on anything else from your code so you could understand and check waht it exactly do without knowing the resto of code) .. i mean enforces but im not sure how many people in fact do read code this way...normal reading i think goes on "names" not on real code transformations
>
> and what i write about is also thet present languages are like not a languages but a gramatics of languages becouse functions (which are like words in languages) in present languages are not a words who carry well defined meaning but are now only forms to fill in ...in mature languiage
> in future you will probably not define a 'words' but know what they do and use them and i mean
> relation among names like, i dont know, "write" "draw" "put_sprite" will be fixed same way as word "cat" in normal language is fixed
>
> (this is kinda interesting remark imo for thoise who are interested in things..i mean interesting is observation that when you define words in language it is not quite language, it is language 'under production' ..in language you got words defined)

in this sense C is not a language, its a language form, C will be language only if you define "words" (specific functions) in it ...

(if you would define big dose of words like 20k it would be big versatile language (esp if such words will be massively known and accepted)...in turn if you define 30 words in it weird way and you or other 2 people will only know that it would be small freak language..etc

in short: language need words who have fixed meaning (also should be wider known and not have some disadvantages stoping it from practical usage)

środa, 9 lutego 2022 o 11:28:54 UTC+1 Malcolm McLean napisał(a):
> On Tuesday, 8 February 2022 at 10:44:54 UTC, fir wrote:
> > i realized kinda interesting thought today
> >
> > you know when you read language like c, your way
> > is probably read from bottom to top (i say probably coz
> > im not a master in reading other people codes still - but
> > logically this is a way ) i mean you must know what
> > bottom definitions do then you read what mid levels
> > definition do then you know what top level definitions
> > do
> >
> If you are writing a module, should you put the high level calls at the top
> and the low-level calls lower down? Or should you put the low level calls
> at the top and the high level calls last?
> The advantage of doing it the second way is that if you don't export the
> lower level functions, you don't need prototypes. Also, it reveals mututal
> dependency, which is usually a poor design decision.
> The advantage of the first way is that non-programming documents are
> usually provided as overview first, then details, then minor footnotes.
> That matches the way most readers like to absorb information.

as what you ask i use bottom/low functions upper in file and more top the more down in file but this is not quite realeted to what i was writing about