programing-language
sensorial-concept-Mcs (lagPrgm)

McsHitp-creation:: {2019-06-29},

overview of lagPrgm

description::
· programing-language is a-language (= mapping method) that maps information-processing by humans or machines (archetype) to information-processing by machines (algorithm).

name::
* Mcs.filMcsLprgm.last.html!⇒lagPrgm,
* Mcs.dirTchInf/filMcsLprgm.last.html!⇒lagPrgm,
* Mcs.Lpgm!⇒lagPrgm,
* Mcs.lagCmr.001-programing!⇒lagPrgm,
* Mcs.lagCmr.programing!⇒lagPrgm,
* Mcs.lagPrgm'(programing-language)!⇒lagPrgm,
* Mcs.lagPrgm, {2019-07-04},
* Mcs.lagPrograming!⇒lagPrgm,
* Mcs.language.programing!⇒lagPrgm,
* Mcs.programing--computer-language!⇒lagPrgm,
* Mcs.programing-language!⇒lagPrgm,

nameGreek::
* McsEll.γλώσσα-προγραμματισμού,

01_tech of lagPrgm

description::
·

name::
* Mcs.lagPrgm'01_tech,

01_machine of lagPrgm

description::
· the-machine could-be a-physical-one, a-virtual-machine, or an-imaginary-machine.

name::
* Mcs.lagPrgm'01_machine,
* Mcs.lagPrgm'machine,
* Mcs.machine-of-lagPrgm,

02_input|archetype of lagPrgm

description::
· lagPrgm-archetype is a-document describing information-processing as done by humans or other machines.

name::
* Mcs.lagPrgm'02_input!⇒lagPrgm'archo,
* Mcs.lagPrgm'archetype!⇒lagPrgm'archo,
* Mcs.lagPrgm'input!⇒lagPrgm'archo,
* Mcs.lagPrgm'archo,
* Mcs.archetype-of--programing-language!⇒lagPrgm'archo,
* Mcs.input-of-lagPrgm!⇒lagPrgm'archo,

code of archetype

description::
· archo-code is any part of an-archetype.
· in a-source-language the-archo-code is human-code.

name::
* Mcs.lagPrgm'archo'code!⇒lagPrgm'archo-code,
* Mcs.lagPrgm'archo'input!⇒lagPrgm'archo-code,
* Mcs.lagPrgm'archo-code,
* Mcs.input-code--of-lagPrgm!⇒lagPrgm'archo-code,

domain of archetype

description::
· domain of lagPrgm is the-set of all archetypes that are-mapped to algorithms.

name::
* Mcs.lagPrgm-domain,
* Mcs.lagPrgm'archo'domain,
* Mcs.domain-of-lagPrgm,

03_output|algo of lagPrgm

description::
· Calgo is A-DOCUMENT describing an-archetype as done by a-machine that understands this doc.

name::
* Mcs.lagPrgm'03_output!⇒Calgo,
* Mcs.Calgorithm!⇒Calgo,
* Mcs.lagPrgm'algo!⇒Calgo,
* Mcs.lagPrgm'model!⇒Calgo,
* Mcs.lagPrgm'output!⇒Calgo,
* Mcs.Calgo, {2020-05-05},
* Mcs.Calgo'(computer-algo)!⇒Calgo, {2020-05-05},
* Mcs.algorithm-of--programing-language!⇒Calgo,
* Mcs.computer-algo!⇒Calgo, {2020-05-05},
* Mcs.output-of--programing-language!⇒Calgo,
* Mcs.programing-algo!⇒Calgo, {2020-05-05},

02_node of Calgo

description::
· algo-node of lagPrgm is any identifiable part of Calgo.

name::
* Mcs.Calgo'02_node!⇒Calgo'node,
* Mcs.Calgo'node!⇒Calgo'node,
* Mcs.lagPrgm-node!⇒Calgo'node, {2019-07-05},

specific::
* unit,
* word,
* semantic-unit,
* phrase,
* sentence,
* section,

03_unit-node of Calgo

description::
· algo-unit is any indivisible part of an-algo.
· bits, chars.

name::
* Mcs.Calgo'03-unit-node,
* Mcs.Calgo'node.unit,
* Mcs.Calgo'unit-node,
* Mcs.Calgo-unit,
* Mcs.lagPrgm'output-unit,
* Mcs.lagPrgm'unit,
* Mcs.lagPrgm-unit,

04_word-node of Calgo

description::
· output-word of lagPrgm is a-structure of units, that denote nothing in archetype, the-language uses to create more compound algo-structures.

name::
* Mcs.Calgo'04_word-node,
* Mcs.Calgo'word-node,
* Mcs.Calgo'node.word,
* Mcs.Calgo-word,
* Mcs.lagPrgm'output-word,
* Mcs.lagPrgm'word,
* Mcs.lagPrgm-word,

specific::
* identifier,
* keyword,

word.identifier

description::
· lagPrgm-indentifer is a-word, created by a-programer, that is-used to be-associated with algo-structures.

name::
* Mcs.identifier-of-lagPrgm,
* Mcs.lagPrgm-identifier,
* Mcs.lagPrgm-word.identifier,
* Mcs.lagPrgm-word.name,

word.keyword

description::
· algo-keyword of lagPrgm is a-word reserved by the-language to be-used to create more compound algo-structures.

name::
* Mcs.keyword-of-lagPrgm,
* Mcs.Calgo'keyword,
* Mcs.lagPrgm-keyword,

05_semantic-unit-node of Calgo

description::
· semantic-unit of lagPrgm[a] is an-indivisible part of its[a] algo that DENOTES archo-code.

name::
* Mcs.Calgo'05_semantic-unit-node!⇒Calgo'Sunt,
* Mcs.Calgo'semantic-unit-node!⇒Calgo'Sunt,
* Mcs.Calgo'node.semantic-unit!⇒Calgo'Sunt,
* Mcs.Calgo'Sunt,
* Mcs.lagPrgm-Sunt⇒Calgo'Sunt,
* Mcs.semantic-unit--of-lagPrgm!⇒Calgo'Sunt,

Sunt.named

description::
· named--semantic-unit is a-semantic-unit associated with a-name.

name::
* Mcs.Calgo'Sunt.named,
* Mcs.named--semantic-unit---of--programing-language,
* Mcs.variable-of--programing-language,

Sunt.namedNo

description::
· namedNo--semantic-unit is a-semantic-unit NOT associated with a-name.

name::
* Mcs.Calgo'Sunt.namedNo,

Sunt.function (f) of lagPrgm

description::
· algo-function of lagPrgm that denotes info processing of archetype.
===
"generally, functions are clearer and easier to maintain if each function is responsible for only one idea[process]."
[https://doc.rust-lang.org/book/ch12-02-reading-a-file.html]

name::
* Mcs.lagPrgm'function!⇒lagPrgm-f,
* Mcs.lagPrgm-f,

06_phrase-node of Calgo

description::
· algo-phrase is a-structure of simpler algo-structures that denote INCOMPLETE relations or processes ( 3 + 5 ).

name::
* Mcs.Calgo'06_phrase-node,
* Mcs.Calgo'phrase-node,
* Mcs.Calgo'node.phrase,
* Mcs.lagPrgm-phrase,

07_sentence-node of Calgo

description::
· algo-sentence is a-structure of simpler algo-structures that denote COMPLETE relations or processes ( 3 + 5 = 8 ).
· a-sentence can-have as part other simpler sentences.

name::
* Mcs.Calgo'07_sentence-node,
* Mcs.Calgo'sentence-node,
* Mcs.Calgo'node.sentence,
* Mcs.lagPrgm-sentence,

08_section-node of Calgo

description::
· algo-section is whole constructs of sentences or comments.

name::
* Mcs.Calgo'08_section-no!⇒Calgo'section,
* Mcs.Calgo'node.section!⇒Calgo'section,
* Mcs.Calgo'section,
* Mcs.lagPrgm-section!⇒Calgo'section,

specific::
* comment,
* titled-section,
* titledNo-section,

section.TITLED of lagPrgm

description::
·

name::
* Mcs.Calgo'titled-section,
* Mcs.Calgo'section.titled,

section.TITLED.NO of lagPrgm

description::
·

name::
* Mcs.Calgo'paragraph,
* Mcs.Calgo'section.paragraph,
* Mcs.Calgo'section.titledNo,

09_root-node of Calgo

description::
· algo-root is the-outermost structure of the-syntax-tree.

name::
* Mcs.Calgo'09_root-node,
* Mcs.Calgo'root-node,
* Mcs.lagPrgm'root-node,

10_license of Calgo

name::
* Mcs.Calgo'10_license,

description::
"software license is a legal instrument (usually by way of contract law, with or without printed material) governing the use or redistribution of software. Under United States copyright law, all software is copyright protected, in both source code and object code forms, unless that software was developed by the United States Government, in which case it cannot be copyrighted.[1] Authors of copyrighted software can donate their software to the public domain, in which case it is also not covered by copyright and, as a result, cannot be licensed.
A typical software license grants the licensee, typically an end-user, permission to use one or more copies of software in ways where such a use would otherwise potentially constitute copyright infringement of the software owner's exclusive rights under copyright."
[{2020-05-05} https://en.wikipedia.org/wiki/Software_license]

11_human of Calgo

name::
* Mcs.Calgo'11_human,
* Mcs.Calgo'human,

description::
·

12_evaluation of Calgo

name::
* Mcs.Calgo'12_evaluation,
* Mcs.Calgo'evaluation,

description::
·

MISC-ATTRIBUTE of Calgo

code of Calgo

description::
· code of Calgo is any PART of an algo.

name::
* Mcs.Calgo'code!⇒lagPrgm-code,
* Mcs.lagPrgm-code,
* Mcs.code-of-lagPrgm!⇒lagPrgm-code,
* Mcs.output-code--of-lagPrgm!⇒lagPrgm-code,

specific::
* machine-code,
* assembly-code,
* virtual-code,
* source-code,

codomain of Calgo

description::
· codomain of lagPrgm is the-set of all algorithms that produces.

name::
* Mcs.Calgo'codomain,
* Mcs.lagPrgm'codomain,
* Mcs.lagPrgm-codomain,

file of Calgo

description::
· the-algos are-stored in files.

name::
* Mcs.Calgo'file,

structure of Calgo

name::
* Mcs.Calgo'structure,

syntax-tree of Calgo

description::
· the-structure of an-algo is a-whole-part-tree of units, semantic-units, sentences, sections, ie output-structures.
· this structure we call syntax-tree.

name::
* Mcs.Calgo'syntax-tree,
* Mcs.syntax-tree--of-Calgo,

DOING of Calgo

name::
* Mcs.Calgo'doing,

specific::
* writting,
* translating,
* executing,

13_service of Calgo

description::
· service of Calgo is the-main-functing of the-algo.

name::
* Mcs.Calgo'13_service,
* Mcs.Calgo'service,
* Mcs.Calgo'main-functing,
* Mcs.service-Calgo,

addressWpg::
* {2019-08-22} Sean-Fleming, https://www.weforum.org/agenda/2019/08/this-us-city-put-an-algorithm-in-charge-of-its-school-bus-routes-and-saved-5-million,

14_installing of Calgo

name::
* Mcs.Calgo'14_installing,
* Mcs.Calgo'installing,

description::
·

15_using of Calgo

name::
* Mcs.Calgo'15_using,
* Mcs.Calgo'using,

description::
·

executing of Calgo

description::
· algo-executing is the-process of doing the-algo by a-machine.
· like cooking is the-process of doing a-cooking-recipe.

name::
* Mcs.executing-of--Calgo,
* Mcs.Calgo'executing,
* Mcs.Calgo'running,
* Mcs.running-of--Calgo,

16_developing of Calgo

name::
* Mcs.Calgo'16_devoloping,

description::
·

evoluting of Calgo

name::
* Mcs.Calgo'evoluting,

description::
·

Calgo.SPECIFIC of lagPrgm

name::
* Mcs.Calgo.specific,

specific::
* machine-algo,
* binary-algo,
* assembly-algo,
* bytecode-algo,
* source-algo,

Calgo.LIBRARY of lagPrgm

description::
· a-library of a-lagPrgm is an-algo which HAS-NO an-executing-entry-point.

name::
* Mcs.lagPrgm'library!⇒Clibrary,
* Mcs.lagPrgm-library!⇒Clibrary,
* Mcs.Clibrary, {2020-05-05},
* Mcs.Clibrary'(computer-library), {2020-05-05},
* Mcs.Calgo.library!⇒Clibrary,
* Mcs.library-of-lagPrgm!⇒Clibrary,

specific::
* machine-library,
* assembly-library,
* bytecode-library,
* source-library,

Calgo.PROGRAM (link) of lagPrgm

04_evaluation of lagPrgm

description::
· every lagPrgm has its cons and pros as everything.

name::
* Mcs.lagPrgm'04_evaluation,
* Mcs.lagPrgm'evaluation,

specific::
* benefit-of-lagPrgm,
* benefitNo-of-lagPrgm,

05_tool of lagPrgm

description::
· any program, used to work with the-language, write, execute, debug, analyze, test the-code.

name::
* Mcs.lagPrgm'05_tool!⇒lagPrgm'tool,
* Mcs.lagPrgm'tool!⇒lagPrgm'tool,
* Mcs.lagPrgm'tool,

tool.SPECIFIC

name::
* Mcs.lagPrgm'tool,

specific::
* compiler,
* interpreter,
* transpiler,
* runtime-system,
* code-analyzer,
* editor,
* package-manager,
* task-runner-tool,
* testing-tool,

tool.compiler

description::
· compiler is a-program that translates a-source-algo to machine-algo or bytcode-algo.

name::
* Mcs.compiler-of-lagPrgm,
* Mcs.lagPrgm'compiler,
* Mcs.lagPrgm'tool.compiler,

compilation of compiler

description::
· compilation of lagPrgm is the-process by which a-compiler translates a-source-algo to a-machine-algo.

name::
* Mcs.compilation-of-lagPrgm,
* Mcs.lagPrgm'compilation,

tool.interpreter

description::
"In computer science, an interpreter is a computer program that directly executes instructions written in a programming or scripting language, without requiring them previously to have been compiled into a machine language program."
[https://en.wikipedia.org/wiki/Interpreter_(computing)]

name::
* Mcs.interpreter-of-lagPrgm,
* Mcs.lagPrgm-interpreter,
* Mcs.lagPrgm'tool.interpreter,

06_human of lagPrgm

description::
· any human related with a-lagPrgm.

name::
* Mcs.lagPrgm'06_human!⇒lagPrgm'human,
* Mcs.lagPrgm'human!⇒lagPrgm'human,
* Mcs.human.lagPrgm!⇒lagPrgm'human,
* Mcs.lagPrgm'human,

human.programer

description::
· programer is a-human that knows a-lagPrgm[a] and uses it[a].

name::
* Mcs.lagPrgm'programer,
* Mcs.lagPrgm'human.programer,
* Mcs.programer-of-lagPrgm,

07_organization of lagPrgm

description::
·

name::
* Mcs.lagPrgm'07_organization,
* Mcs.lagPrgm'organization,

MISC-ATTRIBUTE of lagPrgm

name::
* Mcs.lagPrgm'attMisc,

cross-platform-support of lagPrgm

description::
·

name::
* Mcs.lagPrgm'cross-platform-support,

expressivity of lagPrgm

description::
· expressivity of lagPrgm is its ability to easily map its archetype.

name::
* Mcs.lagPrgm'expressivity,

safty of lagPrgm

description::
·

name::
* Mcs.lagPrgm'safty,

speed of lagPrgm

description::
·

name::
* Mcs.lagPrgm'speed,

Infrsc of lagPrgm

name::
* Mcs.lagPrgm'Infrsc,

addressWpg::
* https://tomassetti.me/resources-create-programming-languages/,
* http://beadslang.com/,

documentation of lagPrgm

name::
* Mcs.lagPrgm'documentation,

description::
·

specification of lagPrgm

name::
* Mcs.lagPrgm'specification,

description::
·

DOING of lagPrgm

name::
* Mcs.lagPrgm'doing!⇒lagPrgm-doing,
* Mcs.lagPrgm-doing,

doing.SPECIFIC

name::
* Mcs.lagPrgm-doing.specific,

specific::
* installing-lagPrgm,
* updating-lagPrgm,
* uninstalling-lagPrgm,
* creating-lagPrgm,
* evoluting-lagPrgm,
* learning-lagPrgm,
* main-functing-lagPrgm,

main-functing of lagPrgm

description::
· the-main-functing of a-programing-language is to express information-processing for machines.

name::
* Mcs.lagPrgm'main-functing,

creating of lagPrgm

description::
· the-process of writing an-alog using the-lagPrgm.

name::
* Mcs.lagPrgm'creating,

creating.TDD of lagPrgm

description::
"This software development technique follows these steps:
1. Write a test that fails and run it to make sure it fails for the reason you expect.
2. Write or modify just enough code to make the new test pass.
3. Refactor the code you just added or changed and make sure the tests continue to pass.
4. Repeat from step 1!"
[https://doc.rust-lang.org/book/ch12-04-testing-the-librarys-functionality.html]

name::
* Mcs.lagPrgm'Tdd,
* Mcs.lagPrgm'test-driven-development-process,
* Mcs.test-driven-development-process--of-lagPrgm,

translating of lagPrgm

description::
· translating of lagPrgm1 to Lpgm2 is the-process of mapping the-output of lagPrgm1 to the-output of lagPrgm2.

name::
* Mcs.lagPrgm'translating,
* Mcs.translating--programing-language,

evoluting of lagPrgm

name::
* Mcs.lagPrgm'evoluting,

{time.1952}::
=== first compiled-language:
"In the 1960s, high-level programming languages using a compiler were commonly called autocodes. Examples of autocodes are COBOL and Fortran.
The first autocode and its compiler were developed by Alick Glennie in 1952 for the Mark 1 computer at the University of Manchester and is considered by some to be the first compiled programming language."
[http://en.wikipedia.org/wiki/Imperative_programming]

GENERIC of lagPrgm

generic-tree::
* computer-language,
* language,
...
* entity,

lagPrgm.SPECIFIC

name::
* Mcs.lagPrgm.specific,

specific::
* functional-lagPrgm,
* high-level--lagPrgm,
* low-level--lagPrgm,
* object-oriented--lagPrgm,
* procedural-lagPrgm,
===
* actor-based,
* array,
* aspect-oriented,
* class-based,
* concatenative,
* concurrent,
* dataflow,
* declarative,
* domain-specific,
* dynamic,
* esoteric,
* event-driven,
* extensible,
* functional,
* imperative,
* logic,
* macro,
* metaprogramming,
* multi-paradigm,
* object-based,
* object-oriented,
* pipeline,
* procedural,
* prototype-based,
* reflective,
* rule-based,
* scripting,
* stack-based,
* synchronous,
* tactile,
* templating,

* assembly,
* compiled,
* interpreted,
* machine,

* low-level,
* high-level,
* very-high-level,

* first-generation,
* second-generation,
* third-generation,
* fourth-generation,
* fifth-generation,

* non-English-based,
* visual,
[{2020-05-08} https://en.wikipedia.org/wiki/Template:Types_of_programming_languages]

lagPrgm.specifics-division.on-machine

description::
· a-specifics-division on the-machine that understands and runs the-algo.
* machine-lagPrgm,
* assembly-lagPrgm,
* virual-code--lagPrgm,
* source-code--lagPrgm,
===
* low-level (machine, assembly, bytcode),
* high-level (source),

name::
* Mcs.lagPrgm.specifics-division-on-machine,

lagPrgm.specifics-division.on-time-of-creation

description::
* {2015} WebAssembly,
* {2012} TypeScript,
* {2011} Dart,
* {2011} Opa,
* {2011} Roy,
* {2010} Rust,
* {2009} CoffeeScript,
* {2009} Go,
* {2007} Clojure,
* {2005} Haxe,
* {2003} Scala,
* {2000} XL,
* {1996} OCaml,
* {1995} Java,
* {1995} JavaScript,
* {1995} Mercury,
* {1995} PHP,
* {1995} Ruby,
* {1993} Lua,
* {1993} R,
* {1991} Python,
* {1991} Qbasic,
* {1987} Perl,
* {1987} Self,
* {1985} Cool,
* {1979} C++,
* {1979} Rexx,
* {1977} Awk,
* {1974} SQL,
* {1973} ML,
* {1972} C,
* {1972} Prolog,
* {1972} Smalltalk,
* {1970} Pascal,
* {1967} Logo,
* {1965} Simula,
* {1964} Apl,
* {1964} Basic,
* {1959} Cobol,
* {1958} Lisp,
* {1957} Fortran,
* {1954} IPL,

name::
* Mcs.lagPrgm.specifics-division.on-time-of-creation,

lagPrgm.specifics-division.on-domain

description::
· on domain:
* domain-specific--lagPrgm,
* general-purpose--lagPrgm,

name::
* Mcs.lagPrgm.specifics-division.on-domain,

lagPrgm.machine-code

description::
· machine-language is a-programing-language with output machine-code that a-real-machine understands.

name::
* Mcs.Lmchn!⇒lagMchn, {2019-07-02},
* Mcs.lagMchn'(machine-language)!⇒lagMchn,
* Mcs.lagPrgm.machine!⇒lagMchn,
* Mcs.machine-lagPrgm!⇒lagMchn,
* Mcs.machine-programing-language!⇒lagMchn,
* Mcs.lagMchn,
* Mcs.lagPrgm.machine!⇒lagMchn,
* Mcs.language.machine!⇒lagMchn,
* Mcs.machine-code--language!⇒lagMchn,
* Mcs.machine-language!⇒lagMchn,
* Mcs.programing-language.macnine!⇒lagMchn,

algo (output) of lagMchn

description::
· machine-algo of a-lagMchn is an-algo a-real-machine understands.

name::
* Mcs.Calgo.machine!⇒lagMchn-algo,
* Mcs.lagMchn-algo,
* Mcs.machine-algo!⇒lagMchn-algo,
* Mcs.machine-doc!⇒lagMchn-algo,

machine-code of lagMchn

description::
· machine-code is code a-real-machine understands (today binary-code).

name::
* Mcs.lagMchn'machine-code,
* Mcs.lagMchn-algo'machine-code,
* Mcs.lagPrgm-code.machine,
* Mcs.machine-code,

specific::
* binary-code,
* trinary-code,

lagMchn.TRINARY-CODE

description::
· trinary-language is a-machine-language with output trinary-code that a-real-machine understands.

name::
* Mcs.Ltnr!⇒lagTnr, {2019-07-02},
* Mcs.Ltnr'(trinary-language)!⇒lagTnr,
* Mcs.trinary-lagPrgm!⇒lagTnr,
* Mcs.trinary-programing-language!⇒lagTnr,
* Mcs.lagMchn.trinary!⇒lagTnr,
* Mcs.lagPrgm.trinary!⇒lagTnr,
* Mcs.lagTnr, {2019-07-16},
* Mcs.language.trinary!⇒lagTnr,
* Mcs.programing-language.trinary!⇒lagTnr,

algo (output) of lagTnr

trinary-code of lagTnr

description::
· trinary-code is code written in 3 digits a-trinary-machine understands.

name::
* Mcs.lagPrgm-code.trinary,
* Mcs.lagTnr'trinary-code,
* Mcs.lagTnr-algo'trinary-code,
* Mcs.trinary-code,

lagPrgm.binary-code

description::
· binary-language is a-machine-language with output binary-code that a-real-machine understands.

name::
* Mcs.binary-code-language!⇒lagPrgmBnr,
* Mcs.binary-lagPrgm!⇒lagPrgmBnr,
* Mcs.binary-programing-language!⇒lagPrgmBnr,
* Mcs.lagPrgmBnr,
* Mcs.lagPrgmBnr'(binary--programing-language)!⇒lagPrgmBnr,
* Mcs.lanMchn.binary!⇒lagPrgmBnr,
* Mcs.lanPgm.binary!⇒lagPrgmBnr,
* Mcs.language.binary!⇒lagPrgmBnr,
* Mcs.programing-language.binary!⇒lagPrgmBnr,

algo (output) of lagPrgmBnr

description::
· binary-algo is a-machine-algo written in binary-code.

name::
* Mcs.bin-algo!⇒lagPrgmBnr-algo,
* Mcs.binary-algo!⇒lagPrgmBnr-algo,
* Mcs.binary-doc!⇒lagPrgmBnr-algo,
* Mcs.lagPrgmBnr-algo,
* Mcs.Calgo.binary!⇒lagPrgmBnr-algo,

binary-code of lagPrgmBnr

description::
· binary-code is code written in 0 and 1, bits.

name::
* Mcs.lagPrgm-code.binary,
* Mcs.binary-lagPrgm-code,
* Mcs.object-code,

lagPrgm.assembly-code

description::
· assembly-language is a-programing-language with output assembly-code that is-translated to machine-code.

name::
* Mcs.Lasm!⇒lagAsm,
* Mcs.assembly-code--language!⇒lagAsm,
* Mcs.assembly-lagPrgm!⇒lagAsm,
* Mcs.lagAsm,
* Mcs.lagAsm'(assembly-language)!⇒lagAsm,
* Mcs.lagPrgm.assembly!⇒lagAsm,

archetype (input) of lagAsm

description::
· lagAsm-archetype is an-input document we want to be-mapped to assembly-doc.

name::
* Mcs.lagAsm'archetype,

algo (output) of lagAsm

description::
· lagAsm-algo is a-document[a] describing a-lagAsm-archetype which[a] is-translated to machine-code to be-executed by a-machine.

name::
* Mcs.assembly-doc!⇒lagAsm-algo,
* Mcs.Calgo.assembly!⇒lagAsm-algo,
* Mcs.Lasm-algo,
* Mcs.assembly-algo!⇒lagAsm-algo,

assembly-code of lagAsm

description::
· assembly-code is code written with mnemonics very close to machine-code.

name::
* Mcs.lagPrgm-code.assembly,
* Mcs.assembly-code,

lagPrgm.virtual-code

description::
· virtual-language is a-programing-language with output bytecode-code that a-virtual-machine understands.

name::
* Mcs.Lbtcd!⇒lagBtcd,
* Mcs.bytecode-lagPrgm!⇒lagBtcd,
* Mcs.bytecode-language!⇒lagBtcd,
* Mcs.lagBtcd,
* Mcs.lagBtcd'(bytecode-language)!⇒lagBtcd,
* Mcs.lagPrgm.bytecode!⇒lagBtcd,
* Mcs.virtual-code--language!⇒lagBtcd,

algo (input) of lagBtcd

description::
· bytecode-algorithm is an-algo a-bytecode-machine understands.
· it[a] is-written in bytecode.

name::
* Mcs.bytecode-algo!⇒lagBtcd-algo,
* Mcs.Calgo.bytecode!⇒lagBtcd-algo,
* Mcs.lagBtcd-algo,

virtual-code of lagVtl

description::
· virtual-code is code written in 0 and 1, that a-virtual-machine understands.

name::
* Mcs.lagPrgm-code.bytecode,
* Mcs.lagPrgm-code.virtual-code,
* Mcs.bytecode-of-lagPrgm,
* Mcs.virtual-code,

lagPrgm.source-code

description::
· source-language is a-programing-language with output source-code that a-source-machine understands.

name::
* Mcs.Lsrc!⇒lagSrc,
* Mcs.lagSrc,
* Mcs.lagPrgm.source!⇒lagSrc,
* Mcs.source-code--language!⇒lagSrc,
* Mcs.source-lagPrgm!⇒lagSrc,

nameGreek::
* McsEll.πηγαία--γλώσσα-προγραμματισμού,

archetype (input) of lagSrc

description::
· archetype of lagSrc is a-document describing information-processing as done by humans.

name::
* Mcs.lagSrc'archetype!⇒lagSrc-archetype,
* Mcs.lagSrc-archetype,

generic-tree::
* archetype-of-lagPrgm,

archo-code of archetype of lagSrc

description::
· archo-code of lagSrc is any human-code part of archetype.

name::
* Mcs.lagSrc-archetype'archo-code,
* Mcs.lagSrc-archo-code,

generic-tree::
* archo-code-of-lagPrgm,

domain of archetype of lagSrc

description::
· domain of lagSrc[a] is the-set of all archetypes that mapped with it[a].

name::
* Mcs.lagSrc-algo'domain,

generic-tree::
* domain-of-lagPrgm,

algorithm (output) of lagSrc

description::
· source-algorithm is an-algo a-source-machine understands.
· it[a] is-written in source-code.

name::
* Mcs.Calgo.source!⇒lagSrc-algo,
* Mcs.lagSrc'algo!⇒lagSrc-algo,
* Mcs.lagSrc-algo,
* Mcs.source-algo!⇒lagSrc-algo,

nameGreek::
* McsEll.πηγαίος-αλγόριθμος,

generic-tree::
* algorithm-of-lagPrgm,

encoding of lagSrc-algo

description::
· the-output of a-lagSrc is digital-text and therefore uses a-character-encoding.

name::
* Mcs.encoding-of--lagSrc-output,
* Mcs.lagSrc'output-encoding,
* Mcs.lagSrc-algo'encoding,

source-code of lagSrc-algo

description::
· source-code[a] of lagPrgm[b] is code written in human readable format.
· it[a] is any part of its[b] algo.

name::
* Mcs.lagPrgm-code.source,
* Mcs.lagSrc'source-code,
* Mcs.lagSrc-algo'source-code,
* Mcs.source-code,

codomain of lagSrc-algo

description::
· codomain of lagSrc is the-set of all algorithms that produces.

name::
* Mcs.lagSrc'codomain,
* Mcs.lagSrc-algo'codomain,

syntax-tree of lagSrc-algo

description::
· syntax-tree of lagSrc[a] is the-whole-part-tree of output-structures of its[a] algo.

name::
* Mcs.lagSrc'output-syntax-tree,
* Mcs.lagSrc-algo'syntax-tree,

file of lagSrc-algo

description::
· the-algos are-stored in files.

name::
* Mcs.lagSrc'output-file,
* Mcs.lagSrc-algo'file,

Calgo'node of lagSrc

description::
· output-structure of lagSrc[a] is any identifiable part of its[a] algo.

name::
* Mcs.lagSrc'output-node!⇒lagSrc-node,
* Mcs.lagSrc'output-structure!⇒lagSrc-node,
* Mcs.lagSrc-algo'structure!⇒lagSrc-node,
* Mcs.lagSrc-node,

specific::
* unit-node,
* word-node,
* semantic-unit-node,
* phrase-node,
* sentence-node,
* section-node,
* root-node,
===
* named-node,
* namedNo-node,

node.named of lagSrc-algo

description::
· named-node of lagSrc is a-node[a] with an-identifier associated with it[a].

name::
* Mcs.named--lagSrc-node,
* Mcs.lagSrc-node.named,

node.namedNo of lagSrc-algo

description::
· namedNo-node of lagSrc is a-node[a] without an-identifier associated with it[a].

name::
* Mcs.namedNo--agSrc-node,
* Mcs.lagSrc-node.namedNo,

Calgo'unit of lagSrc

description::
· output-unit of lagSrc[a] is any indivisible part of its[a] algo.

name::
* Mcs.lagSrc'output-unit,
* Mcs.lagSrc'unit,
* Mcs.lagSrc-algo'unit,
* Mcs.lagSrc-node.unit,
* Mcs.lagSrc-unit,

generic-tree::
* unit-of-lagPrgm,

specific::
* white-space,

Calgo'word of lagSrc

description::
· output-word of lagSrc is a-structure of units the-language uses to create more compound algo-structures.

name::
* Mcs.lagSrc'output-word!⇒lagSrc-word,
* Mcs.lagSrc'word!⇒lagSrc-word,
* Mcs.lagSrc-algo'word!⇒lagSrc-word,
* Mcs.lagSrc-node.word!⇒lagSrc-word,
* Mcs.lagSrc-word,

generic-tree::
* word-of-lagPrgm,

specific::
* identifier,
* keyword,

word.identifier of lagSrc

description::
· identifier of lagSrc is a-word, not a-keyword, that folows concrete rules to be-constructed and used to construct named-algo-nodes.

name::
* Mcs.identifier-of-lagSrc!⇒lagSrc-identifier,
* Mcs.lagSrc'identifier!⇒lagSrc-identifier,
* Mcs.lagSrc-identifier,
* Mcs.lagSrc-word.identifier!⇒lagSrc-identifier,

naming-convention of identifier

description::
· source-code-languages use misc naming conventsions to form identifiers.

name::
* Mcs.lagSrc'naming-convention!⇒lagSrc-naming-convention,
* Mcs.lagSrc-identifier'naming-convention!⇒lagSrc-naming-convention,
* Mcs.lagSrc-naming-convention,

specific::
* camel-case--naming-convention,
* snake-case--naming-convention,
* Hungarian-case--naming-convention,

naming-convention.Hungarian of lagSrc

description::
· Hungarian--naming-convention of lagSrc is the-convention of writing identifiers with a-prefix denoting the-type or other attribute of the-identifier.
· the-name of the-notation[a] is a-reference to its[a] inventor Charls-Simonyi's nation of origin, Hungary.
· Hungarian-people's-names are "reversed" compared to most other European-names, the-family-name precedes the-given-name.
[https://en.wikipedia.org/wiki/Hungarian_notation]

name::
* Mcs.Hungarian--lagSrc-naming-convention,
* Mcs.lagSrc-naming-convention.Hungarian,

naming-convention.camel-case of lagSrc

description::
· camel-case--naming-convention of lagSrc is the-convention of writing multi-word identifier with no space but with capital the-first letter of words, eg camelCase or CamelCase.
[https://en.wikipedia.org/wiki/Camel_case]

name::
* Mcs.camel-case--lagSrc-naming-convention,
* Mcs.lagSrc-naming-convention.camel-case,

naming-convention.snake-case of lagSrc

description::
· snake-case--naming-convention of lagSrc is the-convention of writing multi-word identifiers separated with the-underscore-(_ LOW-LINE)-char.
[https://en.wikipedia.org/wiki/Snake_case]

name::
* Mcs.lagSrc-naming-convention.snake-case,
* Mcs.snake-case--lagSrc-naming-convention,

word.keyword of lagSrc

description::
· source-keyword is a-word reserved by the-language to construct algo-nodes.

name::
* Mcs.keyword-of-lagSrc,
* Mcs.lagSrc-keyword,
* Mcs.lagSrc-word.keyword,
* Mcs.lagSrc-word.reserved,
* Mcs.source-keyword--of-lagSrc,

Calgo'semantic-unit of lagSrc

description::
· semantic-unit of lagSrc[a] is an-indivisible part of its[a] algo that DENOTES archo-code.

name::
* Mcs.lagSrc'semantic-unit!⇒lagSrc-Sunt,
* Mcs.lagSrc-algo'semantic-unit!⇒lagSrc-Sunt,
* Mcs.lagSrc-node.semantic-unit!⇒lagSrc-Sunt,
* Mcs.lagSrc-semantic-unit!⇒lagSrc-Sunt,
* Mcs.lagSrc-Sunt,

generic-tree::
* sem-unit-of-lagPrgm,

Sunt.SPECIFIC of lagSrc

description::
* compound--lagSrc-Sunt,
* compoundNo--lagSrc-Sunt,
* instance--lagSrc-Sunt,
* instanceNo--lagSrc-Sunt,
* named--lagSrc-Sunt,
* namedNo--lagSrc-Sunt,

name::
* Mcs.lagSrc-Sunt.specific,

Sunt.character (ch) of lagSrc

description::
· character is a-SINGLE written-human-unit.
· strings are a-collection of characters.
· in binary-code Java uses 16 bit to represent them, Rust 32 bit.

name::
* Mcs.lagSrc'character!⇒lagSrc-ch,
* Mcs.lagSrc-Sunt.character!⇒lagSrc-ch,
* Mcs.lagSrc-ch,

specific::
* Rust-character,

Sunt.string (s) of lagSrc

description::
· strings are containers of human-written-code-(text).

name::
* Mcs.lagSrc'string!⇒lagSrc-s,
* Mcs.lagSrc-Sunt.string!⇒lagSrc-s,
* Mcs.lagSrc-s,

specific::
* C++-string,
* Javascript-string,
* Rust-string,

Sunt.boolean (b) of lagSrc

description::
· booleans of lagSrc are the-two Sunits true and false that denote the-same this with the-same human-code.

name::
* Mcs.lagSrc'boolean!⇒lagSrc-b,
* Mcs.lagSrc-Sunt.boolean!⇒lagSrc-b,
* Mcs.lagSrc-b,

Sunt.number (n) of lagSrc

description::
· source-number of lagSrc is a-Sunt that denotes human-numbers.

name::
* Mcs.lagSrc'number!⇒lagSrc-n,
* Mcs.lagSrc-Sunt.number!⇒lagSrc-n,
* Mcs.lagSrc-n,

number.SPECIFIC of lagSrc

description::
* integer-number,
* integerNo-number,
* signed-number,
* signedNo-number,
===
* C++-number,
* Rust-number,

name::
* Mcs.lagSrc-n.specific,

Sunt.function (f) of lagSrc

description::
· source-function of lagSrc is a-semantic-unit that PROCESS information.

name::
* Mcs.lagSrc'function!⇒lagSrc-f,
* Mcs.lagSrc-Sunt.function!⇒lagSrc-f,
* Mcs.lagSrc-f,

lagSrc-f.SPECIFIC

description::
* operator,

name::
* Mcs.lagSrc-f.specific,

lagSrc-f.operator

description::
· source-operator of lagSrc is a-special-function with syntax like math-operators.

name::
* Mcs.lagSrc'operator!⇒lagSrc-opr,
* Mcs.lagSrc-f.operator!⇒lagSrc-opr,
* Mcs.lagSrc-opr,

lagSrc-opr.SPECIFIC

description::
* unary-operator,
* binary-operator,
* ternary-operator,
===
* arithmetic-operator,
* logical-operator,
* relational-operator,
* C++-operator,
* Javascript-operator,
* Rust-operator,

name::
* Mcs.lagSrc-opr.specific,

Sunt.instance (literal) of lagSrc

description::
· literal--semantic-unit of lagSrc is an-individual Sunt.

name::
* Mcs.lagSrc'literal,
* Mcs.lagSrc-Sunt.instance,
* Mcs.lagSrc-Sunt.literal,

Sunt.instanceNo of lagSrc

description::
· type--semantic-unit of lagSrc is a-generic Sunt.

name::
* Mcs.lagSrc'type,
* Mcs.lagSrc-Sunt.instanceNo,
* Mcs.lagSrc-Sunt.type,

Sunt.named of lagSrc

description::
· named-Sunt of lagSrc is a-semantic-unit associated with an-identifier.

name::
* Mcs.lagSrc-Sunt.named,

identifier of named-Sunt (link)

value of named-Sunt

description::
· value of lagSrc is the-semantic-unit associated with an-identifier.

name::
* Mcs.lagSrc-named-Sunt'value,

Sunt.namedNo of lagSrc

description::
·

name::
* Mcs.lagSrc-Sunt.namedNo,

Calgo'phrase of lagSrc

description::
· output-phrase of lagSrc is a-structure of simpler algo-structures that denote INCOMPLETE relations or processes ( 3 + 5 ).

name::
* Mcs.lagSrc'output-phrase,
* Mcs.lagSrc'phrase,
* Mcs.lagSrc-algo'phrase,
* Mcs.lagSrc-node.phrase,
* Mcs.lagSrc-phrase,

generic-tree::
* phrase-of-lagPrgm,

Calgo'sentence of lagSrc

description::
· source-sentence of lagSrc is a-structure of algo-nodes that denotes COMPLETE relations or processes ( 3 + 5 = 8 ).

name::
* Mcs.lagSrc'output-sentence,
* Mcs.lagSrc'sentence,
* Mcs.lagSrc-algo'sentence,
* Mcs.lagSrc-node.sentence,
* Mcs.lagSrc-sentence,

generic-tree::
* sentence-of-lagPrgm,

sentence.SPECIFIC of lagSrc

description::
* definition-sentence,

name::
* Mcs.lagSrc.specific,

sentence.definition of lagSrc

description::
· definition is a-sentence that uniquely creates instances of semantic-units.

name::
* Mcs.lagSrc-sentence.definition,

specific::
* assignment-definition,
* function-definition,

Calgo'section of lagSrc

description::
· output-section of lagSrc is a-structure of sentences or comments.

name::
* Mcs.lagSrc'output-section,
* Mcs.lagSrc'section,
* Mcs.lagSrc-algo'section,
* Mcs.lagSrc-node.section,
* Mcs.lagSrc-section,

generic-tree::
* section-of-lagPrgm,

specific::
* comment,
* titled-section,
* titledNo-section,

section.block of lagSrc

description::
· source-block is a-sequence of sentences, usually denoted with left and right curly-brackets-{}.

name::
* Mcs.lagSrc-block,

Calgo'root of lagSrc

description::
· root of lagSrc[a] is the-outermost structure of its[a] output-syntax-tree.

name::
* Mcs.lagSrc-algo'root,
* Mcs.lagSrc-node.root,
* Mcs.lagSrc-root,

Calgo.SPECIFIC of lagSrc

description::
* library--Lsrc-algo,
* program--Lsrc-algo,

name::
* Mcs.lagSrc-algo.specific,

evalauation of lagSrc

description::
·

name::
* Mcs.lagSrc'evaluation,

tool of lagSrc

description::
·

name::
* Mcs.lagSrc'tool,

generic-tree::
* tool-of-lagPrgm,

resource of lagSrc

name::
* Mcs.lagSrc'Infrsc,

generic-tree::
* resource-of-lagPrgm,

lagSrc.SPECIFIC

description::
·

name::
* Mcs.lagSrc.specific,

lagSrc.COMPILED

description::
· compiled-language[a] is a-source-language the-output[b] of which[a] must-be-translated to machine-code or bytecode for a-real-machine to understand it[b].

name::
* Mcs.Lscr.compiled,
* Mcs.compiled--programing-language,

lagSrc.INTERPRETED

description::
· interpreted-language[a] is a-source-language the-output of which[a] is-understood directly from a-real-machine with an-interpreter.

name::
* Mcs.lagSrc.interpreted,
* Mcs.interpreted--programing-language,

lagSrc.DYNAMICALLY-TYPED

description::
· dynamically-type-language[a] is a-source-language if the-type of a-variable is-known at run-time, for example Python, JavaScript.
· the main advantage is that the-programmer can-write a little quicker because s|he does-not-have to specify types every time.

name::
* Mcs.lagSrc.dynamically-typed,

lagSrc.STATICALLY-TYPED

description::
· statically-type-language[a] is a-source-language if the-type of a-variable is-known at compile-time, for example Java, C++.
· the main advantage is that all kinds of checking can-be-done by the-compiler, and therefore many trivial bugs are-caught at a very early stage.

name::
* Mcs.lagSrc.statically-type,

lagPrgm.domain-specific

name::
* Mcs.lagPrgm.domain-specific!⇒lagDsl,
* Mcs.domain-specific-lagPrgm!⇒lagDsl,
* Mcs.lagDsl,

description::
"A domain-specific language (DSL) is a computer language specialized to a particular application domain. This is in contrast to a general-purpose language (GPL), which is broadly applicable across domains. There are a wide variety of DSLs, ranging from widely used languages for common domains, such as HTML for web pages, down to languages used by only one or a few pieces of software, such as MUSH soft code. DSLs can be further subdivided by the kind of language, and include domain-specific markup languages, domain-specific modeling languages (more generally, specification languages), and domain-specific programming languages. Special-purpose computer languages have always existed in the computer age, but the term "domain-specific language" has become more popular due to the rise of domain-specific modeling. Simpler DSLs, particularly ones used by a single application, are sometimes informally called mini-languages.
The line between general-purpose languages and domain-specific languages is not always sharp, as a language may have specialized features for a particular domain but be applicable more broadly, or conversely may in principle be capable of broad application but in practice used primarily for a specific domain. For example, Perl was originally developed as a text-processing and glue language, for the same domain as AWK and shell scripts, but was mostly used as a general-purpose programming language later on. By contrast, PostScript is a Turing complete language, and in principle can be used for any task, but in practice is narrowly used as a page description language."
[{2020-05-08} https://en.wikipedia.org/wiki/Domain-specific_language]

lagPrgm.data

description::
·

name::
* Mcs.data-processing-language,
* Mcs.lagPrgm.data,

lagPrgm.concept (link)

lagPrgm.query

description::
· query-language is a-programing-language that FINDS information from computer-stored-one.

name::
* Mcs.DQR'(data-query-language)!⇒lagQry,
* Mcs.lagPrgm.query!⇒lagQry,
* Mcs.lagQry,
* Mcs.query-language!⇒lagQry,

descriptionLong::
"Query languages or data query languages (DQLs) are computer languages used to make queries in databases and information systems."
[{2021-01-03} https://en.wikipedia.org/wiki/Query_language]

meta-info

this page was-visited times since {2019-06-29}

page-wholepath: synagonism.net / Mws / dirTchInf / lagPrgm

SEARCH::
· this page uses 'locator-names', names that when you find them, you find the-LOCATION of the-concept they denote.
GLOBAL-SEARCH:
· clicking on the-green-BAR of a-page you have access to the-global--locator-names of my-site.
· use the-prefix 'lagPrgm' for structured-concepts related to current concept 'programing-language'.
LOCAL-SEARCH:
· TYPE CTRL+F "Mcs.words-of-concept's-name", to go to the-LOCATION of the-concept.
· a-preview of the-description of a-global-name makes reading fast.

footer::
• author: Kaseluris.Nikos.1959
• email:
 imgMail
• edit on github: https://github.com/synagonism/Mcsw/blob/master/dirTchInf/filMcsLprgm.last.html,
• twitter: @synagonism
• steemit: https://steemit.com/@synagonism

webpage-versions::
• version.last.dynamic: filMcsLprgm.last.html,
• version.0-1-0.2019-06-29 draft creation,

support (link)