01_tech of lagPrgm
description::
· the-info-tech that manages the-lagPrgm.
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.
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]
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
name::
* Mcs.Calgo'titled-section,
* Mcs.Calgo'section.titled,
section.TITLED.NO of lagPrgm
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
12_evaluation of Calgo
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
structure of Calgo
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
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
15_using of Calgo
name::
* Mcs.Calgo'15_using,
* Mcs.Calgo'using,
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
evoluting of Calgo
Calgo.SPECIFIC of lagPrgm
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,
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
specific::
* compiler,
* interpreter,
* transpiler,
* runtime-system,
* code-analyzer,
* editor,
* package-manager,
* task-runner-tool,
* testing-tool,
tool.editor
description::
· the-program we use to-write a-program.
name::
* Mcs.code-editor-of-lagPrgm!⇒editorPrgm,
* Mcs.editor-of-lagPrgm!⇒editorPrgm,
* Mcs.editorPrgm,
* Mcs.lagPrgm'editor!⇒editorPrgm,
* Mcs.lagPrgm'tool.editor!⇒editorPrgm,
Infrsc of editorPrgm
description::
* https://tomassetti.me/go-to-definition-in-the-language-server-protocol/,
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
name::
* Mcs.lagPrgm'07_organization,
* Mcs.lagPrgm'organization,
MISC-ATTRIBUTE of lagPrgm
cross-platform-support of lagPrgm
expressivity of lagPrgm
description::
· expressivity of lagPrgm is its ability to easily map its archetype.
safty of lagPrgm
speed of lagPrgm
Infrsc of lagPrgm
addressWpg::
* https://tomassetti.me/resources-create-programming-languages/,
* http://beadslang.com/,
documentation of lagPrgm
specification of lagPrgm
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.
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),
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,
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,
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.
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.
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.
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
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].
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,
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,
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,
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
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,
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.
Sunt.namedNo of lagSrc
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
sentence.definition of lagSrc
description::
· definition is a-sentence that uniquely creates instances of semantic-units.
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-{}.
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
evalauation of lagSrc
tool of lagSrc
generic-tree::
* tool-of-lagPrgm,
resource of lagSrc
generic-tree::
* resource-of-lagPrgm,
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.
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.
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
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:
• edit on github: https://github.com/synagonism/Mcsw/blob/master/dirTchInf/filMcsLagPrgm.last.html,
• twitter: @synagonism
• steemit: https://steemit.com/@synagonism
webpage-versions::
• version.last.dynamic: filMcsLagPrgm.last.html,
• version.0-1-0.2019-06-29 draft creation,