this title is a joka but, by Crom, the remark i made abot the
thing objects are not objects but knots/webs is valuable

as i noticed say you got slog 'object'

its the rectangular amount of ram (say 500x100 500 lines by 100 chars)

it has main function Slog("text "); and function DrawSlog();
it also has a function ResetSlog(); making it 'reset' so new flogs will
fill up slog from the begining

if you provide jour internel pack of such objects they do not
provide a program per se becouse whats damn problematic is fact that
you must put this objects together like a pices of web in your code and
this is damn problematic imo

i dont know solution to this things but it seems that languages
need something that i personally call (im not sure if right)
aspect programming pattarn (i would need to check up if this name fits
but as problem needs name i will take this one at leas temporarely)

it is you define in code some well rreckognized points then some
methods of given obejcts you may "pin" to those points locally
in your object code thus greatly reducing mess..becouse if you do so
you got like whole code of given module contained in this module
like you got no calls to it (!) from outside you only have 'pin' points

i think it could decrease mess, also decrease this very idiotic code
jumping.. hovever i dont know how well it would work in practice
but theoretically its quite interesting

in such case of this log i think if it has its ram
ant 4 methids InitSlog() Slog() DrawSlog() ResetSlog()
three of them are the pin-nature ones , and the main is free one
this you cannot pin.. but better some than none

how it should look like?

if you have a module/file with slog

i think something like this could be used

init_game += SlogInit();
draw_frame_late += DrawSlog();
new_frame += ResetSlog();

something like that (with some more fit syntax)

and then just definitions

SlogInit()
{

}

digression
{
//as to this above even though slog uses static array like char
slog[500][100] i think it should be maybe put in init

SlogInit()
{
module_scope char slog[500][100];
}

so maybe initialising even static ram could be defferred
(thus function would need to see this (well some could put function definitions inside it too

SlogInit()
{
module_scope char slog[500][100];

printf("\n debugging: slog initialised...");

DrawSlog() [}
ResetSlog() {}
Slog(char* text) {}
}

and remove tha name and braces {} ;c treating the init mathod like
language keyword and define module name by filaname it contains or adding

module slog;

at the top (thats a digression)

}

digression on initialisation of modules not important but the pin_points
after my thoughts about insane code jumping problem i probably fid as
strictly needed in practice

on the cilent side just one need to define those pin oints

DrawFrame()
{
draw_frame:

ClearFrame();

draw_frame_late: //pinpoint

}

UpdateFrame()
[
new_frame : //pinpoint

slog("hello new frame");

}


gameLoop()
{
UpdateFrame();
DrawFrame();
}

void main()
{
init_game: //pin point


SetupWindow(GameLoop);


}


something like that





--- PyGate Linux v1.5.19
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

as to modules c need some concept of modules/objects
(in previos post when i use name object i mean this proper normal sense
of it not c++ like crap)

the concept of module is natural, its a number of function and
data that make separate entity and is also related to things that are in
one separate file

hovever how to denote them is unclear (to me )

there are at least 3 options, one id to treat a file as module
say

clog.c file and its contents is module

second is use such

module slog
//...


module screen

/....

module window


the definition of nex module ends the previous

and there is also

module slog
{

}


probably the worst but as an option probably may stand

also i think as i said module needs some kayword or something that wpuld
work like this keyword which will initialise it.. that is helpfull to initialise it and maybe deinitialise it saving ram or maybe put it in
some context only

also module should prbably have freestanding code like


module slog
{

printf("\n module started ");

tab[100][100]
int foo() {}
int boo() {}

}

it also should prbably take arguments to initialise it according to
runtime parameters




module slog (int size_x, int size_y)
{

printf("\n module started ");

tab[size_y][size_x]
int foo() {}
int boo() {}

}

probbaly those pinpoints should be established in this freestanding space

module slog (int size_x, int size_y)
{

printf("\n module started ")

run_frame += run

tab[size_y][size_x]
int foo() {}
int boo() {}
int run() {}


}

so client side would have at least trace of this module is installed
on his side of code







--- PyGate Linux v1.5.19
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

fir pisze:

as to modules c need some concept of modules/objects
(in previos post when i use name object i mean this proper normal sense
of it not c++ like crap)

the concept of module is natural, its a number of function and
data that make separate entity and is also related to things that are in
one separate file

hovever how to denote them is unclear (to me )

there are at least 3 options, one id to treat a file as module
say

clog.cÿ file and its contents is module

second is use such

module slog
//...

module screen

/....

module window

the definition of nex module ends the previous

and there is also

module slog
{

}

probably the worst but as an option probably may stand

also i think as i said module needs some kayword or something that wpuld work like this keyword which will initialise it.. that is helpfull to initialise it and maybe deinitialise it saving ram or maybe put it in
some context only

also module should prbably have freestanding code like

module slog
{

ÿ printf("\n module started ");

ÿ tab[100][100]
ÿint foo() {}
ÿint boo() {}

}

it also should prbably take arguments to initialise it according to
runtime parameters

module slog (int size_x, int size_y)
{

ÿ printf("\n module started ");

ÿ tab[size_y][size_x]
ÿint foo() {}
ÿint boo() {}

}

probbaly those pinpoints should be established in this freestanding space

module slog (int size_x, int size_y)
{

ÿ printf("\n module started ")

run_frame += run

ÿ tab[size_y][size_x]
ÿint foo() {}
ÿint boo() {}
ÿint run() {}

}

so client side would have at least trace of this module is installed
on his side of code

so in fact it is shown that module is in fact function but with
someadditional properties, and that function is in fact structure sometimes


like

module foo()
{
int x,y,z; //only freestanding data

}

this is also saying as you usually not instal functions so
maybe not need for them but if you instal overall module over them
still possibly better to instal the father module



--- PyGate Linux v1.5.19
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

fir pisze:

fir pisze:

as to modules c need some concept of modules/objects
(in previos post when i use name object i mean this proper normal sense
of it not c++ like crap)

the concept of module is natural, its a number of function and
data that make separate entity and is also related to things that are
in one separate file

hovever how to denote them is unclear (to me )

there are at least 3 options, one id to treat a file as module
say

clog.cÿ file and its contents is module

second is use such

module slog
//...


module screen

/....

module window


the definition of nex module ends the previous

and there is also

module slog
{

}


probably the worst but as an option probably may stand

also i think as i said module needs some kayword or something that
wpuld work like this keyword which will initialise it.. that is
helpfull to initialise it and maybe deinitialise it saving ram or
maybe put it in some context only

also module should prbably have freestanding code like


module slog
{

ÿÿ printf("\n module started ");

ÿÿ tab[100][100]
ÿÿint foo() {}
ÿÿint boo() {}

}

it also should prbably take arguments to initialise it according to
runtime parameters




module slog (int size_x, int size_y)
{

ÿÿ printf("\n module started ");

ÿÿ tab[size_y][size_x]
ÿÿint foo() {}
ÿÿint boo() {}

}

probbaly those pinpoints should be established in this freestanding space

module slog (int size_x, int size_y)
{

ÿÿ printf("\n module started ")

run_frame += run

ÿÿ tab[size_y][size_x]
ÿÿint foo() {}
ÿÿint boo() {}
ÿÿint run() {}


}

so client side would have at least trace of this module is installed
on his side of code

so in fact it is shown that module is in fact function but with someadditional properties, and that function is in fact structure sometimes

like

module foo()
{
ÿÿ int x,y,z;ÿ //only freestanding data

}

this is also saying as you usually not instal functions so
maybe not need for them but if you instal overall module over them
still possibly better to instal the father module

so in fact concept of function (and structure) is gone you only have
modules (?)

but the modules can be named with a word to chose becouse i could for
example use world structure and thus it would be "hyperstructural c"
not "hypermodular c" as i used to call it..im not sure which name
is better maybe even hyperstructural is better name (i will see yet)


? ya!

--- PyGate Linux v1.5.19
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

fir pisze:

fir pisze:

fir pisze:

as to modules c need some concept of modules/objects
(in previos post when i use name object i mean this proper normal sense
of it not c++ like crap)

the concept of module is natural, its a number of function and
data that make separate entity and is also related to things that are
in one separate file

hovever how to denote them is unclear (to me )

there are at least 3 options, one id to treat a file as module
say

clog.cÿ file and its contents is module

second is use such

module slog
//...


module screen

/....

module window


the definition of nex module ends the previous

and there is also

module slog
{

}


probably the worst but as an option probably may stand

also i think as i said module needs some kayword or something that
wpuld work like this keyword which will initialise it.. that is
helpfull to initialise it and maybe deinitialise it saving ram or
maybe put it in some context only

also module should prbably have freestanding code like


module slog
{

ÿÿ printf("\n module started ");

ÿÿ tab[100][100]
ÿÿint foo() {}
ÿÿint boo() {}

}

it also should prbably take arguments to initialise it according to
runtime parameters




module slog (int size_x, int size_y)
{

ÿÿ printf("\n module started ");

ÿÿ tab[size_y][size_x]
ÿÿint foo() {}
ÿÿint boo() {}

}

probbaly those pinpoints should be established in this freestanding
space

module slog (int size_x, int size_y)
{

ÿÿ printf("\n module started ")

run_frame += run

ÿÿ tab[size_y][size_x]
ÿÿint foo() {}
ÿÿint boo() {}
ÿÿint run() {}


}

so client side would have at least trace of this module is installed
on his side of code

so in fact it is shown that module is in fact function but with
someadditional properties, and that function is in fact structure
sometimes


like

module foo()
{
ÿÿÿ int x,y,z;ÿ //only freestanding data

}

this is also saying as you usually not instal functions so
maybe not need for them but if you instal overall module over them
still possibly better to instal the father module

so in fact concept of function (and structure) is gone you only have
modules (?)

but the modules can be named with a word to chose becouse i could for example use world structure and thus it would be "hyperstructural c"
not "hypermodular c" as i used to call it..im not sure which name
is better maybe even hyperstructural is better name (i will see yet)

? ya!

some thoughts yet

as it seen that this instaling should be generally dynamical then it
would need work in such codes like


if(a<2) install slog ;

this means some things

1) one your empty main module should accept freestanding code
(as in python afir)

main.c

print "hello"

no need of main(0 function, more: it seems logical error to have it


well some may say if function is non existant then

main { print "hello" }

is the same

2) yet some other thughts who escaped me..it was something as yu would
need instal this things than maybe syntax for it shpuld be skimpy,
im not sure...it seems that it should be skimpy or non existant but it
needs probably be also notable to see what is being installed (?)

you would need to instal clib for example

main {
instal clib ///????
print "hello"
}

i also wonder if not that you use standard cpu and ram should not be
denoted probably as some 'class' of demands this program has which would
adress the portability topic

? ya!




--- PyGate Linux v1.5.19
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

fir pisze:

i also wonder if not that you use standard cpu and ram should not be
denoted probably as some 'class' of demands this program has which would adress the portability topic

? ya!

its interesting how this installing cpu could be

maybe something like

instal int

int is assumed to have typical int operations like

int a b c

a=b+c/23

foo(int x, int y)
{

}


and so on

ram probbably need to be assumed as int without ram probably not much sense

same with float and chars

though if some will define module

module std_costem
{
instal int float char
}

then come could

instal std_costam








--- PyGate Linux v1.5.19
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)