programing-language structured-concept-Mcs
(lagPgm)

McsHitp-creation: {2019-06-29}

overview of lagPgm

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.filMcsLpgm.last.html!⇒lagPgm,
* Mcs.dirTchInf/filMcsLpgm.last.html!⇒lagPgm,
* Mcs.Lpgm!⇒lagPgm,
* Mcs.lagCmr.programing!⇒lagPgm,
* Mcs.lagPgm'(programing-language)!⇒lagPgm,
* Mcs.lagPgm, {2019-07-04}
* Mcs.language.programing!⇒lagPgm,
* Mcs.programing--computer-language!⇒lagPgm,
* Mcs.programing-language!⇒lagPgm,

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

input (archetype) of lagPgm

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

name::
* Mcs.lagPgm'archetype!⇒lagPgm-archo,
* Mcs.lagPgm'input!⇒lagPgm-archo,
* Mcs.lagPgm-archo,
* Mcs.archetype-of--programing-language!⇒lagPgm-archo,
* Mcs.input-of-lagPgm!⇒lagPgm-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.lagPgm-archo'code!⇒lagPgm-archo-code,
* Mcs.lagPgm-archo'input!⇒lagPgm-archo-code,
* Mcs.lagPgm-archo-code,
* Mcs.input-code--of-lagPgm!⇒lagPgm-archo-code,

domain of archetype

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

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

output (algo) of lagPgm

description::
· lagPgm-algo is document describing an-archetype as done by a-machine that understands this doc.

name::
* Mcs.lagPgm'algorithm!⇒lagPgm-algo,
* Mcs.lagPgm'model!⇒lagPgm-algo,
* Mcs.lagPgm'output!⇒lagPgm-algo,
* Mcs.lagPgm-algo,
* Mcs.algorithm-of--programing-language!⇒lagPgm-algo,
* Mcs.output-of--programing-language!⇒lagPgm-algo,

machine of algo

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

name::
* Mcs.lagPgm-algo'machine,
* Mcs.lagPgm-machine,

specific::

code of algo

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

name::
* Mcs.lagPgm-algo'code!⇒lagPgm-code,
* Mcs.lagPgm-code,
* Mcs.code-of-lagPgm!⇒lagPgm-code,
* Mcs.output-code--of-lagPgm!⇒lagPgm-code,

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

codomain of algo

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

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

syntax-tree of algo

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.lagPgm-algo'syntax-tree,
* Mcs.syntax-tree--of--lagPgm-algo,

file of algo

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

name::
* Mcs.lagPgm-algo'file,

algo'node of lagPgm

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

name::
* Mcs.lagPgm-algo'node!⇒lagPgm-node,
* Mcs.lagPgm-algo'structure!⇒lagPgm-node,
* Mcs.lagPgm-algo-structure!⇒lagPgm-node,
* Mcs.lagPgm-node, {2019-07-05}
* Mcs.lagPgm'output-structure!⇒lagPgm-node,

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

algo'unit of lagPgm

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

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

algo'word of lagPgm

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

name::
* Mcs.lagPgm'algo-word,
* Mcs.lagPgm'output-word,
* Mcs.lagPgm'word,
* Mcs.lagPgm-algo'word,
* Mcs.lagPgm-node.word,
* Mcs.lagPgm-word,

specific::
* identifier,
* keyword,

word.identifier

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

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

word.keyword

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

name::
* Mcs.keyword-of-lagPgm,
* Mcs.lagPgm-algo'keyword,
* Mcs.lagPgm-keyword,

algo'semantic-unit of lagPgm

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

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

Sunt.named

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

name::
* Mcs.lagPgm-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.lagPgm-Sunt.namedNo,

Sunt.function (f) of lagPgm

description::
· algo-function of lagPgm 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.lagPgm'function!⇒lagPgm-f,
* Mcs.lagPgm-f,

algo'phrase of lagPgm

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

name::
* Mcs.lagPgm-algo'phrase,
* Mcs.lagPgm-node.phrase,
* Mcs.lagPgm-phrase,

algo'sentence of lagPgm

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.lagPgm-algo'sentence,
* Mcs.lagPgm-node.sentence,
* Mcs.lagPgm-sentence,

algo'section of lagPgm

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

name::
* Mcs.lagPgm-algo'section!⇒lagPgm-section,
* Mcs.lagPgm-node.section!⇒lagPgm-section,
* Mcs.lagPgm-section,

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

section.TITLED of lagPgm

description::
·

name::
* Mcs.lagPgm-algo'titled-section,
* Mcs.lagPgm-section.titled,

section.TITLED.NO of lagPgm

description::
·

name::
* Mcs.lagPgm-algo'paragraph,
* Mcs.lagPgm-section.paragraph,
* Mcs.lagPgm-section.titledNo,

algo'root of lagPgm

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

name::
* Mcs.lagPgm-algo'root,
* Mcs.lagPgm-root,

algo'DOING of lagPgm

name::
* Mcs.lagPgm-algo'doing,

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

service of lagPgm-algo

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

name::
* Mcs.lagPgm-algo'main-functing,
* Mcs.lagPgm-algo'service,
* Mcs.service-lagPgm-algo,

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,

executing of lagPgm-algo

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--lagPgm-algo,
* Mcs.lagPgm-algo'executing,
* Mcs.lagPgm-algo'running,
* Mcs.running-of--lagPgm-algo,

algo.SPECIFIC of lagPgm

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

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

algo.LIBRARY of lagPgm

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

name::
* Mcs.lagPgm'library!⇒lagPgm-library,
* Mcs.lagPgm-library,
* Mcs.lagPgm-algo.library!⇒lagPgm-library,
* Mcs.library-of-lagPgm!⇒lagPgm-library,

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

algo.PROGRAM of lagPgm

description::
· a-program of a-lagPgm is an-algo which HAS an-executing-entry-point.

name::
* Mcs.cmr'program!⇒cmr-program,
* Mcs.cmr-program, {2019-07-17}
* Mcs.computer-program!⇒cmr-program,
* Mcs.lagPgm'program!⇒cmr-program,
* Mcs.lagPgm-program!⇒cmr-program,
* Mcs.lagPgm-algo.program!⇒cmr-program,
* Mcs.program-of-lagPgm!⇒cmr-program,
* Mcs.software-program!⇒cmr-program,

program.SPECIFIC of lagPgm

description::
· alphabetically:
* assembly-program,
* bytecode-program,
* machine-program,
* source-program,

name::
* Mcs.cmr-program.specific,

program.specific-division.user of lagPgm

description::
· division on usage from a-user or not:
* application-program,
* system-program,

name::
* Mcs.cmr-program.specific-division.user,

program.application of lagPgm

description::
· application-program is a-program a-user uses.

name::
* Mcs.application-program!⇒cmr-app,
* Mcs.application-of-computer!⇒cmr-app,
* Mcs.cmr-app,
* Mcs.cmr-program.application!⇒cmr-app,
* Mcs.computer-application!⇒cmr-app,
* Mcs.software-application!⇒cmr-app,

program.system of lagPgm

description::
· system-program is a-program a-computer[a] not a-user uses for its[a] operations.

name::
* Mcs.cmr-program.system!⇒system-program,
* Mcs.system-program,
* Mcs.system-software!⇒system-program,

specific::
* device-driver,
* operating-system,

program.operating-system of lagPgm

description::
· operating-system is a-system-program, the-most important a-computer[a] needs to work that manages its[a] resources and provides common services for its[a] apps.

name::
* Mcs.OS!⇒cmr-Os,
* Mcs.cmr-Os,
* Mcs.operating-system!⇒cmr-Os,

resource of Os of lagPgm

name::
* Mcs.cmr-Os'resource,

addressWpg::
* https://en.wikipedia.org/wiki/Timeline_of_operating_systems,

evaluation of lagPgm

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

name::
* Mcs.lagPgm'evaluation,

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

tool of lagPgm

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

name::
* Mcs.lagPgm'tool!⇒lagPgm-tool,
* Mcs.lagPgm-tool,

tool.SPECIFIC

name::
* Mcs.lagPgm-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-lagPgm,
* Mcs.lagPgm'compiler,
* Mcs.lagPgm-tool.compiler,

compilation of compiler

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

name::
* Mcs.compilation-of-lagPgm,
* Mcs.lagPgm'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-lagPgm,
* Mcs.lagPgm-interpreter,
* Mcs.lagPgm-tool.interpreter,

human of lagPgm

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

name::
* Mcs.lagPgm'human!⇒lagPgm-human,
* Mcs.lagPgm-human,

human.programer

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

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

organization of lagPgm

description::
·

name::
* Mcs.lagPgm'organization,

resource of lagPgm

name::
* Mcs.lagPgm'resource,

addressWpg::
*

ATTRIBUTE of lagPgm

cross-platform-support of lagPgm

description::
·

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

expressivity of lagPgm

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

name::
* Mcs.lagPgm'expressivity,

safty of lagPgm

description::
·

name::
* Mcs.lagPgm'safty,

speed of lagPgm

description::
·

name::
* Mcs.lagPgm'speed,

DOING of lagPgm

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

doing.SPECIFIC

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

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

main-functing of lagPgm

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

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

creating of lagPgm

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

name::
* Mcs.lagPgm'creating,

creating.TDD of lagPgm

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.lagPgm'Tdd,
* Mcs.lagPgm'test-driven-development-process,
* Mcs.test-driven-development-process--of-lagPgm,

translating of lagPgm

description::
· translating of lagPgm1 to Lpgm2 is the-process of mapping the-output of lagPgm1 to the-output of lagPgm2.

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

EVOLUTING of lagPgm

name::
* Mcs.lagPgm'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 lagPgm

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

lagPgm.SPECIFIC

name::
* Mcs.lagPgm.specific,

specific::
* functional-lagPgm,
* high-level--lagPgm,
* low-level--lagPgm,
* object-oriented--lagPgm,
* procedural-lagPgm,

lagPgm.specific-division.on-machine

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

name::
* Mcs.lagPgm.specific-division-on-machine,

lagPgm.specific-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.lagPgm.specific-division.on-time-of-creation,

lagPgm.specific-division.on-domain

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

name::
* Mcs.lagPgm.specific-division.on-domain,

lagPgm.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.lagPgm.machine!⇒lagMchn,
* Mcs.machine-lagPgm!⇒lagMchn,
* Mcs.machine-programing-language!⇒lagMchn,
* Mcs.lagMchn,
* Mcs.lagPgm.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.lagPgm-algo.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.lagPgm-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-lagPgm!⇒lagTnr,
* Mcs.trinary-programing-language!⇒lagTnr,
* Mcs.lagMchn.trinary!⇒lagTnr,
* Mcs.lagPgm.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.lagPgm-code.trinary,
* Mcs.lagTnr'trinary-code,
* Mcs.lagTnr-algo'trinary-code,
* Mcs.trinary-code,

lagPgm.binary-code

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

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

algo (output) of lagPgmBnr

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

name::
* Mcs.bin-algo!⇒lagPgmBnr-algo,
* Mcs.binary-algo!⇒lagPgmBnr-algo,
* Mcs.binary-doc!⇒lagPgmBnr-algo,
* Mcs.lagPgmBnr-algo,
* Mcs.lagPgm-algo.binary!⇒lagPgmBnr-algo,

binary-code of lagPgmBnr

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

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

lagPgm.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-lagPgm!⇒lagAsm,
* Mcs.lagAsm,
* Mcs.lagAsm'(assembly-language)!⇒lagAsm,
* Mcs.lagPgm.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.lagPgm-algo.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.lagPgm-code.assembly,
* Mcs.assembly-code,

lagPgm.virtual-code

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

name::
* Mcs.Lbtcd!⇒lagBtcd,
* Mcs.bytecode-lagPgm!⇒lagBtcd,
* Mcs.bytecode-language!⇒lagBtcd,
* Mcs.lagBtcd,
* Mcs.lagBtcd'(bytecode-language)!⇒lagBtcd,
* Mcs.lagPgm.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.lagPgm-algo.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.lagPgm-code.bytecode,
* Mcs.lagPgm-code.virtual-code,
* Mcs.bytecode-of-lagPgm,
* Mcs.virtual-code,

lagPgm.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.lagPgm.source!⇒lagSrc,
* Mcs.source-code--language!⇒lagSrc,
* Mcs.source-lagPgm!⇒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-chain::
* archetype-of-lagPgm,

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-chain::
* archo-code-of-lagPgm,

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-chain::
* domain-of-lagPgm,

algorithm (output) of lagSrc

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

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

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

generic-chain::
* algorithm-of-lagPgm,

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 lagPgm[b] is code written in human readable format.
· it[a] is any part of its[b] algo.

name::
* Mcs.lagPgm-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,

algo'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,

algo'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-chain::
* unit-of-lagPgm,

specific::
* white-space,

algo'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-chain::
* word-of-lagPgm,

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,

algo'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-chain::
* sem-unit-of-lagPgm,

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,

algo'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-chain::
* phrase-of-lagPgm,

algo'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-chain::
* sentence-of-lagPgm,

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,

algo'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-chain::
* section-of-lagPgm,

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.,

algo'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,

algo.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-chain::
* tool-of-lagPgm,

resource of lagSrc

name::
* Mcs.lagSrc'resource,

generic-chain::
* resource-of-lagPgm,

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,

meta-info

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

page-path: synagonism.net / Mcs-worldview / dirTchInf / lagPgm

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 'lagPgm' 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/filMcsLpgm.last.html,
• twitter: @synagonism
• steemit: https://steemit.com/@synagonism

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

support (link)