keywords "this", "self", "returned" for adda

 20.10.28: adda/lexicon/this, self, returned:

a discussion about adding keywords to the language.

allowed characters in identifiers

8.22: adda/lexicon/allowed characters in identifiers:
. if the allowed characters in an identifier
could include the dot,
then there could be confusion in places,
as to whether the dot was declaring a var:
eg, what if you have the name x.F.int,
and then -- forgetting you did that --
decided later to define F.type ?
. now x.F is ambiguous:
are you declaring x to be F.type?
or are you referring to x.F.int ?
. therefore, the allowed identifiers are
first character is a letter
or the character (_);
and, subsequent characters are alphanums
or the characters (') (_) (-);
anthing else gets put in a box:
eg, [x.F].int; .

benefits of unique context operator

8.19: adda/lexicon/benefits of unique context operator:
[8.20: intro
. in 2012.4, this "(::) was presented as a context operator
but it didn't give a specific reason:

"( confusing having syntax"(type`value)
when (`) already has a specific meaning: (x`f); ). ]

. even more than confusing,
it's name`space limiting:
if you have the syntax ( type`attribute ),
along with ( type`method ),
then the type authors are limited in
what they can name their methods
because it could clash with type attributes; [8.20:
eg, for enums there is an attribute named first;
eg, for bible.type: {last, first},
bible`first = last; -- this type's first value is "(last);
but if the context operation uses the same symbol,
then ( bible`first ) could mean either
the first value of the bible enumeration,
or the bible value named "(first).
. by having a separate context operator (eg, ::),
we can say ( bible`first = bible::last ).]

8.19: 11.15 .. 16: review the syntax:

obj.type(select a variant of this type)
-- declares obj to be of this type;
obj`= value -- object initialization;
type::value -- fully-qualified enumeration value;

obj.component -- public ivar;
type::.component -- public ivar's default initial value;
obj#(component expression) -- public ivar;
type::#(expr) -- public ivar's default initial value;

type.component -- public class var;
type#(component expression) -- public class var;

obj`body/local -- private ivars;
type`body/local -- private class vars;

obj`message(...);  -- instance message call;
obj`message`body -- instance message's body;
type::`message`body -- instance message's body;
type::`message -- instance message uninstantiated
( practically the same as type::`message`body );
type`attribute -- class message call;
function(obj) -- call to function of instance
(may or may not belong to an obj's type's interface);
type::subprogram -- full-qualified subprogram call;

type::function`body -- access function's body;
type`body/subprogram -- private class subprogram call;
obj`body/subprogram -- private instance subprogram call;
obj(expr) -- obj callable? apply('obj, expr);
function obj -- call with this obj

. notice there are separate namespaces for
{ value and function names
, .components
, `messages }; because,
components are found only after a dot,
and messages only after a backquote;
whereas, the namespace for value
is shared by that for functions;
otherwise, the parser would have problems:
both values and functions start with a name
but only functions expect the next lexel
to be the argument of that function:
# function x -> apply function to x;
# value x -> syntax error
( unless x is a binary operator
or value is numeric and x is a dimension ).
. therefore, for each unqualified name
it must be typed unambiguously as
either a function or a value, not both .

11.15: mis:
"(review the syntax:

type::value -- fully-qualified instance value
type::`message -- access message's body
type::function(...) -- access function's body
obj`body/local -- private ivars;
type`body/local -- private class vars;
type`attribute -- class message call;
...

) . sometimes it is using (type::x) to mean eval x,
but other times don't eval?
and then this:
type`body/local -- private class vars;
?
. the body of the function is within
the body of the type:
type`body/function
and the way to refer to the function uneval'd,
is to ask for the function's body:
type`body/function`body .
. but if the function is also visible from the interface
we could also write:
type::function`body .

11.16: clarification:
"( review the syntax:

type.component -- public class var;
obj.component -- public ivar;
type::.component -- public ivar's default initial value

) . an interface definition has syntax for
both class and instance public vars,
and these are accessed similarly,
being dotted with their respective objects:
obj.component -- public instance var;
type.component -- public class var .
. if you hadn't defined an instance yet,
and still wanted to refer to an instance's component,
that would be done with the type's context operator:
type::.component;
and, since there was no instance involved,
the only meaning it could logically have
is being the component's default initial value .

value or symbol literals

6.21:  adda/lexicon/$symbol can indicate
literal symbol just like quotes mean literal string:
[7.2:
. there are 3 categories of symbols:
# names composed of digits are literal values of type number;
# names preceded by double-quote are literal values of type character string;
# names preceded by single-quote are unevaled symbols
(references to a symbol that was previously declared);
# names preceded by ($)  are declaring literal values of type symbol;
(it's not a variable or constant representing some other value).
. in english we would tend to put a word in quotes to mean this,
but in a programming language, we want to reserve quotes for
values of type character string .
. this use for $ was first mentioned as
a namespace for value literals .]

double-equal to mean prolonged equality

10.12: adda/lexicon/==:
. the == could be like the japanese way of
2-trees representing many trees: a forest .
. 2 equals would say the values are
equal for many moments,
ie, they are pointers to the same obj; [10.13:
or they are part of a notify&update pattern .
it could also be used as a special form of
assignment stmt:
whatever you're getting access to,
you have some way of maintaining synchronization,
as would occur if using aliases .]

icons of the alphabet

12.23: adds/icons of the alphabet:
. abc's look like the very basic mechanisms
whose names begin with such letters:
Angle(A is icon of angle arc between hinge plates)
Bisect(graphical counting or dividing),
Circumfrence, Diameter,
Extend (greek E means summation)
Front (arrow points at front surface of a drafting view
-- vs the top surface),
Gyration (revolving starts from right angle),
Hinge (H can be plates hinged),
Iatric(healed, parts assembled
-- I is a clocking of H)
Join(J has a hook for joining)
Kaleidoscope (K shows both V and V's mirror image)
Ligature (bonding of multiple indep'dimensions
-- symbolized by L, a right angle).
Multiply (M is a clocking of E, summation)
Not(N is the same shape as set`not: ~)
Oscillation (O is loop like cycles, oscillations),
Post-Oscillation or Product
(P is icon of dropping out of a loop)
Quality (what's under Oscillation? its basis or control)
Radical (Oscillation's side affects)
Specialization (S looks like yin-yang formations
-- specializing in complementary differences)
Top (arrow points at top surface of a drafting view)
Union (U looks like a collecting cup)
Vacillation (V is side view of wave, VVVV)
Wall (W is a counter-clocking of E, summation
-- stop additions)
Xiphoid (Greek xiphos: sword)
Yes (what's under Vacillation?
-- basis or control of V, energy)
Zero (Z is a clocking of N, not(this): not anything)

culturomics

12.16: news.adds/culturomics:

Quantitative Analysis of Culture Using Millions of Digitized Books

"( We constructed a corpus of digitized texts
containing [5 million books]
about 4% of all books ever printed.

Analysis of this corpus enables us to investigate
cultural trends quantitatively.
We survey the vast terrain of "culturomics",
focusing on linguistic and cultural phenomena
that were reflected in the English language
between 1800 and 2000.
We show how this approach can provide insights about
fields as diverse as lexicography,
the evolution of grammar, collective memory,
the adoption of technology, the pursuit of
fame, censorship, and historical epidemiology.)

Google Tool Explores 'Genome' Of English Words

. To coincide with the publication of the Science paper,
Google's ngrams web app shows how often
a word or phrase has appeared over time
in its scanned literature .
Dr Jean-Baptiste Michel a psychologist in Harvard's
Program for Evolutionary Dynamics,
and Dr Erez Lieberman Aiden
have developed the search tool .

. 8,500 new words enter the English language every year
and the lexicon grew by 70% between 1950 and 2000.
But 52% these words do not appear in dictionaries.
– the majority of words used in English books .

terminology

11.30: web.adds/engl/a word for study of sensible terminology:

. instead of the word "(engl),

I was hoping for a replacement that meant

study and design of sensible terminology .

Etymology

. the derivation of a word.

2. an account of the history of a particular word or element of a word.

3. the study of historical linguistic change,

esp. as manifested in individual words.

Origin:

1398, from Gk. etymologia, from etymon "true sense"

(neut. of etymos "true," related to eteos "true")

+ logos "word." In classical times, of meanings; later, of histories.

Latinized by Cicero as veriloquium.

1350Ð1400; ME: L etymologia: Gk etymolog’a,

equiv. to etymol—g(os) studying the true meanings and values of words

(Žtymo(s) true (see etymon ) + l—gos word, reason) + -ia -y 3

lexis:

1955Ð60; : Gk lŽxis speech, diction, word, text,

equiv. to lŽg(ein) to speak, recount

(akin to l—gos account, word, L legere to read;

see logos, lection ) + -sis -sis

the vocabulary of a language, as distinct from its grammar;

the total stock of words and idiomatic combinations of them in a language;

lexicon.

lexigram:

a symbol that represents a word

lexicology:

The branch of linguistics that deals with the lexical component of language.

study of the formation, meaning, and use of words

and of idiomatic combinations of words.

lexicography:

1. the writing, editing, or compiling of dictionaries.

2. the principles and procedures involved in

writing, editing, or compiling dictionaries.

lexicon (plural: lexica):

a wordbook or dictionary, esp. of Greek, Latin, or Hebrew.

2. the vocabulary of a particular language, field, social class, person, etc.

3. inventory or record

4. Linguistics.

a. the total inventory of morphemes in a given language.

b. the inventory of base morphemes plus their combinations with derivational morphemes.

lexical:

1. of or pertaining to the words or vocabulary of a language,

esp. as distinguished from its grammatical and syntactical aspects.

2. of, pertaining to, or of the nature of a lexicon.

lexeme:

n. The fundamental unit of the lexicon of a language.

Find, finds, found, and finding are forms of the English lexeme find.

unifying {english, math}`capitalization rules

10.15: adda/unifying {english, math}`capitalization rules:

. english and math do use capitalization in a similar way:

capitals are for enclosures holding multiple values or objects,

and a personal name is a sort of set

because it has no particular definition;

instead, it references the infinite set of

whatever or whoever has been assigned that name;

whereas a lowercase name refers to a single definition .

reserved words

10.7: adda/reserved words:

. instead of reserved words,

just qualify system names as belonging to system .

. in some lang's there exist implicit namespaces,

eg, names of rec`fields can be the same as locals

because a field name always occurs in the form rec` .

. are there syntactic categories that could represent namespace?

eg, can a scope reuse a type's name as an obj's name ?

can they coexist (eg, int.sys`int)

or would that require an override? .

[10.10:

. you could qualify the name with it's type:

eg, int.type, vs int.int .

]

. it might be laborous to prove complicated symantics;

users might also resent complication

even if simplifying meant less freedom .

[10.11: could have modes {user`controls, system`controls} ]

. at least familiar symbols should be reserved

so as to keep things defined as they are in english/math .

. types can include package location;

eg, sys`int ?

the point of global types is to avoid the need for

specifying packages;

eg, when you declare x.int,

that implicitely finds the package int.type

and imports its operators .

. if do want non-global pkg's imported, and their names clash

(ie, 2 authors have given the same name to their sharable library)

then use a rename on one of them .

. keep in mind the obj' view of connecting compilation units:

it may seem busy or confusing

but adda shouldn't rule out qualified type names .

adda's lexicon

10.2: adda/lexicon/!:

. if (!) means {unique, constant},

it can also mean the literals of a type-def;

because literals are symbolic constants;

eg, type = <

!:{...}, oper's: ...,

>

. here are parameterized enum's

(ie, functions can name const values (enums)):

!{.(x in ..., y in ...), f(x), g(x,y), ... } .

mis.adda/lexicon/!!:

10.2:

. the first draft of the above had thought they had opposite meanings,

so then I thought [!!] should be a shorthand for [causes variation] .

10.16:

. use exponents like x!!y

-- wanted x!y but may want to keep x! as postfix for factorial .

adda/lexicon/!!:

10.4:

. following the example of unix,

where [//] is related to [/]:

{root of internet, root of local network};

and, [..] is related to [.]:

{ parent.directory, current.directory }

what is related to constant [!]

such that [!!] would be meaningful?

. it could mean constant at a higher level,

where if a type implies the use of a pointer,

then a [!] would simply mean that the paramater is not out.mode,

while a [!!] reassures you that

if the parameter provides access to externals,

then none of those externals will be modified either .

10.23:

. with (x)! having a sort of power function, (1*2* ... x),

(x!!y) could make sense as the binary power function x*^y .

adda/lexicon/[?!]

10.9: adda/syntax/absolutely:

. many times you want to insure

that a condition exists;

so you test for it;

and, make it so, if needed .

. that routine can symbolized by

following a question with an exclamation point .

eg,

var = value ?! --. no? var`= value .

file exist?! --. no? create it .

10.8:

adda/lexicon/taking double-quotes literally:

. rather than use "("()) or ""() to indicate string literal,

use '() to represent single nestable quotes;

then use "() as a short hand for '('()) .

10.9: adda/lexicon/num`log#base:

. try to recall various intuitive ways of representing log symbol:

log#b(x) should be x//b ?

if x**b = x*^b means x* x* ...* x#b ,

then doesn't x//b = x/^b rather than log#b(x) ?

better was a later idea of [b*^?=](x) .

adda/lexicon/num`modulus:

. remainder or modulus = x ~| y --. the complement of div .

10.11: adda/lexicon/xor operator:

. xor was once thought to be the ~=,

but generalizing to sets of any universe,

xor is the unique existence operator, (aka the multiop"[or!]);

so, if or's symbol is \() -- short for \/,

then xor could be \! .

. for a multiop ~= to be true,

each arg must have a unique value,

so in the case of truth.var's,

it's defined only as a biop, not a multiop .

10.11: adda/shift operations:

. to follow exponent example,

shift is should use ^ for the number of shiftings .

. like 10**-1 = 1/10,

there should be one shift operator,

and it's param's sign should determine the shift's direction .

10.12:

adda/lexicon/[don't eval] vs [don't parse]:

if "() is the same as '('()) can you mix them?

. say you're working with unicode where there are real quotes,

ie, they different left and right symbols

which we can simulate in ascii with "( )" and '( )' .

so then,

can you do "( ... ') ... )' ?

. no, the ' and " have 2 diffn't jobs:

'() says

[parse this character string into symbols but don't eval it],

"() says

[don't even parse this; leave it as a character string] .

eg,

a function`literal is '()

and it may include a nested function`literal,

so there is an example of '( '(...) ...)

not being the same as "() .

. if, however, you have only one quote character

because for instance you want to reserve ' as the apostrophe,

then you could reuse the double-quote for both:

"(don't eval)

""(don't parse) .

adda/lexicon/[?] as truth.type`symbol:

. why not use ?.type as type truth? ...

adda/lexicon/[.!] constant of type specified by init:

. x.! can mean the type isn't known until init',

but whatever it is, it's constant after that .

10.20: adda/lexicon/[::]:

. operator"[::] may be useful as a filename clarifier;

eg, filename::owner`create-time

. it looks like a colon -- which adda reserves as the label indicator

and param'association by labeling .

. it says a filename can be identified by owner`create-time,

and that the id is labeled by the given filename .

--

. c++ uses it to show class membership: class::attribute,

which is really a possessive relation eg, class`attribute .

--

. math uses it to show a relational equality:

a:b :: c:d

[9.21: . what this really does is clarify how [:].symbol is used;

it really means

relationship(a,b) = relationship(c,d) . ]

10.20: adda/lexicon/[:]/breaks from url syntax:

. I'm trying to stay with url syntax,

but url uses [:].symbol like it's a field separator

as for time format: (hour:minutes) .

. here is the full url:

protocol://pass@domain:port/

where pass is (username:password)

. the port is optional because although both a domain and port are needed,

there are default ports per protocol .

. the domain identifies only a network node address,

but the actual data also needs a mailbox number

as each service provided by the node needs its own mail box .

"( 65,535 TCP Ports and another 65,535 UDP ports.

each app running a service on the same internet node

needs a binding to its own port,

) -- http://www.bleepingcomputer.com/tutorials/tutorial38.html

. hearsay has it that designer of url regrets the choice of syntax,

later preferring

com/serverroute/www/

to

//www.serverroute.com/

[10.21:

. it treats the internet as if it was a superfolder

where each node is a file,

with file`type being somewhat similar to datatype

in telling you what services you can expect to get

from objects of that type .

. the later way treats a node as if it were

a mounted volume; just like in unix,

where you can have multiple drives look like

one filesystem

by equating each with some subfolder

of the system's filesystem .

so that the new sytem belonging to the whole world,

would have a root of ( protocol:node`type/)

while the root node would be (/) .

. I do agree partially:

//serverroute.com/www/ ... or

//serverroute.com#www/

so that nodes are completely like files

with all the type info being part of the dotted suffix

and then dotted prefixes get treated like the

subfolders or array selectors they actually are .

] .

10.21: adda/lexicon/decimal point as abbreviation:

. notice how the dot as decimal is like the period as abbreviator:

int.frac = int + frac/10*^n for frac`length = n .

mis.adda/lexicon/string single.quotes not nestable:

10.24:

. notice that one reason english will use "" for quotes,

is that single quotes are mismatched,

with the the closing.single-quote being reused as an apostrophe .

12.9: adda/syntax/apply:

. arg @ f @ g -- syntax like pipes and the familiar email .

. how is email like a function?

name @ [set of id's] returns a named id .

12.13: adda/syntax/why pointers use subfolder notation:

. how is pointer concept equal to a subfolder?

root points at item can be record or single

ptr/ -- returns all items;

then if ptr is a superfoldr and points at a subfolder

it returns a record,

and if you mention a record member name,

then that works like a function,

it returns just the object that was named .

punctuation

6.14: engl/{punctuation, punctual}:

. punct-: to a point,

. punctual: occurring precisely at the expected point in time .

. punctuation:

a word condensed to a single point or character;

an extension to the alphabet that represents a word rather than a word component

as in the oriental character sets,

where there are thousands of punctuations .

. punctuation in english, however, reserves such punctual words

for expressing the non-verbal elements of speech .

math-, cyber-, auto-, -netics, -matics

6.12: engl/{math-, cyber-, auto-, -netics, -matics}:

greek:

auto.matos: self.acting --. matter (actions of the material) .

manthanein: learn

mathemat-: science --. math.mat: learn.actions .

kubernetes: steersman; kubernan: to steer.

--. kubern: controling .

12pm, 12am

6.8: engl/1200am:

. 12:00 has really got 2names: {0pm, 1200am}, ...

but they are calling noon 12pm .

[11.29:

. the sequences for 2 versions are

am-pm: 11:59am, 12pm, 1pm ... 11:59pm, 12am, ...

24-hr: 11:59, 12, 13, ... 23:59, 0, ...

. it should start at 0,

so that when transitioning from am to pm, at noon,

the noon should either stay AM until the amount down-cycles;

ie, 11:59am, 12:59am, 1:00 pm;

or, if wanting to call noon pm,

then don't start the clock with 12, use 0 instead: 11:59am, 0:00pm

11.30:

. there is a confusion of sequence,

because am is preceded by pm,

but for each of those intervals,

they start with a high number, 12;

and then bump down to 1, before starting upward again .

. the way it makes sense for clock`high to have both {0, 12} values

is noticing that an hour after 11 is a 12th hour;

ie, you might want to have a 1, 2,.. number of hours gone by,

rather than know the time point in reals: 0, 0.01, ... .

web"how biz makes sense of time:

http://www.worldtimezone.com/wtz-names/wtz-am-pm.html

A.M.a.m. Ante Meridiem Latin = "before midday" before noon

PM p.m. Post Meridiem Latin = "after midday" after noon

* Terms 12 a.m. and 12 p.m. cause confusion

as neither the "12 am" nor the "12 pm" designation is technically correct.

* It advisable to use 12 noon and 12 midnight where clarity is required.

* To avoid ambiguity, airlines, railroads, and insurance companies use

12:01am for an event beginning the day,

11:59pm for ending it.

]