01_tech of lagCpgm
description::
· the-info-tech that manages the-lagCpgm.
name::
* McsEngl.lagCpgm'01_tech,
01_machine of lagCpgm
description::
· the-machine could-be a-physical-one, a-virtual-machine, or an-imaginary-machine.
name::
* McsEngl.lagCpgm'01_machine,
* McsEngl.lagCpgm'machine,
* McsEngl.machine-of-lagCpgm,
02_input|archetype of lagCpgm
description::
· lagCpgm-archetype is a-document describing information-processing as done by humans or other machines.
name::
* McsEngl.lagCpgm'02_input!⇒lagCpgm'archo,
* McsEngl.lagCpgm'archetype!⇒lagCpgm'archo,
* McsEngl.lagCpgm'input!⇒lagCpgm'archo,
* McsEngl.lagCpgm'archo,
* McsEngl.archetype-of--programing-language!⇒lagCpgm'archo,
* McsEngl.input-of-lagCpgm!⇒lagCpgm'archo,
code of archetype
description::
· archo-code is any part of an-archetype.
· in a-source-language the-archo-code is human-code.
name::
* McsEngl.lagCpgm'archo'code!⇒lagCpgm'archo-code,
* McsEngl.lagCpgm'archo'input!⇒lagCpgm'archo-code,
* McsEngl.lagCpgm'archo-code,
* McsEngl.input-code--of-lagCpgm!⇒lagCpgm'archo-code,
domain of archetype
description::
· domain of lagCpgm is the-set of all archetypes that are-mapped to algorithms.
name::
* McsEngl.lagCpgm-domain,
* McsEngl.lagCpgm'archo'domain,
* McsEngl.domain-of-lagCpgm,
03_output|algo of lagCpgm
description::
· Calgo is A-DOCUMENT describing an-archetype as done by a-machine that understands this doc.
name::
* McsEngl.lagCpgm'03_output!⇒Calgo,
* McsEngl.Calgorithm!⇒Calgo,
* McsEngl.lagCpgm'algo!⇒Calgo,
* McsEngl.lagCpgm'model!⇒Calgo,
* McsEngl.lagCpgm'output!⇒Calgo,
* McsEngl.Calgo, {2020-05-05},
* McsEngl.Calgo!=computer-algo,
* McsEngl.algorithm-of--programing-language!⇒Calgo,
* McsEngl.computer-algo!⇒Calgo, {2020-05-05},
* McsEngl.output-of--programing-language!⇒Calgo,
* McsEngl.programing-algo!⇒Calgo, {2020-05-05},
02_node of Calgo
description::
· algo-node of lagCpgm is any identifiable part of Calgo.
name::
* McsEngl.Calgo'02_node!⇒Calgonode,
* McsEngl.Calgo'node!⇒Calgonode,
* McsEngl.Calgonode,
* McsEngl.Calgonode!=node-of-computer-algo,
* McsEngl.lagCpgm-node!⇒Calgonode, {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::
* McsEngl.Calgo'03-unit-node,
* McsEngl.Calgonode.unit,
* McsEngl.Calgo'unit-node,
* McsEngl.Calgo-unit,
* McsEngl.lagCpgm'output-unit,
* McsEngl.lagCpgm'unit,
* McsEngl.lagCpgm-unit,
04_word-node of Calgo
description::
· output-word of lagCpgm is a-structure of units, that denote nothing in archetype, the-language uses to create more compound algo-structures.
name::
* McsEngl.Calgo'04_word-node,
* McsEngl.Calgo'word-node,
* McsEngl.Calgonode.word,
* McsEngl.Calgo-word,
* McsEngl.lagCpgm'output-word,
* McsEngl.lagCpgm'word,
* McsEngl.lagCpgm-word,
specific::
* identifier,
* keyword,
word.identifier
description::
· lagCpgm-indentifer is a-word, created by a-programer, that is-used to be-associated with algo-structures.
name::
* McsEngl.identifier-of-lagCpgm,
* McsEngl.lagCpgm-identifier,
* McsEngl.lagCpgm-word.identifier,
* McsEngl.lagCpgm-word.name,
word.keyword
description::
· algo-keyword of lagCpgm is a-word reserved by the-language to be-used to create more compound algo-structures.
name::
* McsEngl.keyword-of-lagCpgm,
* McsEngl.Calgo'keyword,
* McsEngl.lagCpgm-keyword,
05_semantic-unit-node of Calgo
description::
· semantic-unit of lagCpgm[a] is an-indivisible part of its[a] algo that DENOTES archo-code.
name::
* McsEngl.Calgo'05_semantic-unit-node!⇒Calgo'Sunt,
* McsEngl.Calgo'semantic-unit-node!⇒Calgo'Sunt,
* McsEngl.Calgonode.semantic-unit!⇒Calgo'Sunt,
* McsEngl.Calgo'Sunt,
* McsEngl.lagCpgm-Sunt⇒Calgo'Sunt,
* McsEngl.semantic-unit--of-lagCpgm!⇒Calgo'Sunt,
Sunt.named
description::
· named--semantic-unit is a-semantic-unit associated with a-name.
name::
* McsEngl.Calgo'Sunt.named,
* McsEngl.named--semantic-unit---of--programing-language,
* McsEngl.variable-of--programing-language,
Sunt.namedNo
description::
· namedNo--semantic-unit is a-semantic-unit NOT associated with a-name.
Sunt.function (f) of lagCpgm
description::
· algo-function of lagCpgm is a-Calgonode 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::
* McsEngl.Cpgmf,
* McsEngl.Cpgmf!=function//lagCpgm,
* McsEngl.algo-function//lagCpgm!⇒Cpgmf,
* McsEngl.function//lagCpgm!⇒Cpgmf,
* McsEngl.lagCpgm'function!⇒Cpgmf,
* McsEngl.programing-function!⇒Cpgmf,
06_phrase-node of Calgo
description::
· algo-phrase is a-structure of simpler algo-structures that denote INCOMPLETE relations or processes ( 3 + 5 ).
name::
* McsEngl.Calgo'06_phrase-node,
* McsEngl.Calgo'phrase-node,
* McsEngl.Calgonode.phrase,
* McsEngl.lagCpgm-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::
* McsEngl.Calgo'07_sentence-node,
* McsEngl.Calgo'sentence-node,
* McsEngl.Calgonode.sentence,
* McsEngl.lagCpgm-sentence,
08_section-node of Calgo
description::
· algo-section is whole constructs of sentences or comments.
name::
* McsEngl.Calgo'08_section-no!⇒Calgo'section,
* McsEngl.Calgonode.section!⇒Calgo'section,
* McsEngl.Calgo'section,
* McsEngl.lagCpgm-section!⇒Calgo'section,
specific::
* comment,
* titled-section,
* titledNo-section,
section.TITLED of lagCpgm
name::
* McsEngl.Calgo'titled-section,
* McsEngl.Calgo'section.titled,
section.TITLED.NO of lagCpgm
name::
* McsEngl.Calgo'paragraph,
* McsEngl.Calgo'section.paragraph,
* McsEngl.Calgo'section.titledNo,
09_root-node of Calgo
description::
· algo-root is the-outermost structure of the-syntax-tree.
name::
* McsEngl.Calgo'09_root-node,
* McsEngl.Calgo'root-node,
* McsEngl.lagCpgm'root-node,
10_license of Calgo
name::
* McsEngl.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
name::
* McsEngl.Calgo'12_evaluation,
* McsEngl.Calgo'evaluation,
MISC-ATTRIBUTE of Calgo
code of Calgo
description::
· code of Calgo is any PART of an algo.
name::
* McsEngl.Calgo'code!⇒lagCpgm-code,
* McsEngl.lagCpgm-code,
* McsEngl.code-of-lagCpgm!⇒lagCpgm-code,
* McsEngl.output-code--of-lagCpgm!⇒lagCpgm-code,
specific::
* machine-code,
* assembly-code,
* virtual-code,
* source-code,
codomain of Calgo
description::
· codomain of lagCpgm is the-set of all algorithms that produces.
name::
* McsEngl.Calgo'codomain,
* McsEngl.lagCpgm'codomain,
* McsEngl.lagCpgm-codomain,
file of Calgo
structure of Calgo
name::
* McsEngl.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::
* McsEngl.Calgo'syntax-tree,
* McsEngl.syntax-tree--of-Calgo,
DOING of Calgo
13_service of Calgo
description::
· service of Calgo is the-main-functing of the-algo.
name::
* McsEngl.Calgo'13_service,
* McsEngl.Calgo'service,
* McsEngl.Calgo'main-functing,
* McsEngl.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::
* McsEngl.Calgo'14_installing,
* McsEngl.Calgo'installing,
15_using of Calgo
name::
* McsEngl.Calgo'15_using,
* McsEngl.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::
* McsEngl.executing-of--Calgo,
* McsEngl.Calgo'executing,
* McsEngl.Calgo'running,
* McsEngl.running-of--Calgo,
16_developing of Calgo
evoluting of Calgo
Calgo.SPECIFIC of lagCpgm
name::
* McsEngl.Calgo.specific,
specific::
* machine-algo,
* binary-algo,
* assembly-algo,
* bytecode-algo,
* source-algo,
Calgo.FRAMEWORK of lagCpgm
description::
· "A framework and a library are both pre-written code that can be used to help developers build software applications. However, there are some key differences between the two.
A framework provides a structure for developing an application. It defines the overall architecture of the application and provides a set of classes and functions that developers can use to build their application. This can save developers a lot of time and effort, as they don't have to start from scratch. However, it also means that frameworks can be more restrictive than libraries, as developers have to conform to the framework's architecture.
A library provides a set of functions that can be used to perform specific tasks. Libraries are less restrictive than frameworks, as developers can use them in any way they want. However, this also means that libraries can require more code to be written, as developers have to integrate the library's functions into their own code.
In general, frameworks are a good choice for developing large, complex applications that need to be consistent and maintainable. Libraries are a good choice for developing smaller, more specialized applications or for adding functionality to an existing application.
Here is a table that summarizes the key differences between frameworks and libraries:
Feature Framework Library
Provides structure for application Yes No
Restrictive Yes No
Requires more code to be written No Yes
Good for Large, complex applications Small, specialized applications
Here are some examples of frameworks:
Django (Python)
Laravel (PHP)
Spring Boot (Java)
React (JavaScript)
Angular (JavaScript)
Here are some examples of libraries:
jQuery (JavaScript)
NumPy (Python)
Pandas (Python)
OpenSSL (C)
GLib (C)"
[{2023-08-14 retrieved} https://bard.google.com/]
name::
* McsEngl.framework-of-lagCpgm!⇒Cframework,
* McsEngl.Calgo.framework!⇒Cframework,
* McsEngl.Cframework,
* McsEngl.Cframework!=computer-framework,
Calgo.LIBRARY of lagCpgm
description::
· a-library of a-lagCpgm is an-algo which HAS-NO an-executing-entry-point.
name::
* McsEngl.lagCpgm'library!⇒Clibrary,
* McsEngl.lagCpgm-library!⇒Clibrary,
* McsEngl.Clibrary, {2020-05-05},
* McsEngl.Clibrary!=computer-library, {2020-05-05},
* McsEngl.Calgo.library!⇒Clibrary,
* McsEngl.library-of-lagCpgm!⇒Clibrary,
specific::
* machine-library,
* assembly-library,
* bytecode-library,
* source-library,
Calgo.PROGRAM (link) of lagCpgm
04_evaluation of lagCpgm
description::
· every lagCpgm has its cons and pros as everything.
name::
* McsEngl.lagCpgm'04_evaluation,
* McsEngl.lagCpgm'evaluation,
05_tool of lagCpgm
description::
· any program, used to work with the-language, write, execute, debug, analyze, test the-code.
name::
* McsEngl.lagCpgm'05_tool!⇒lagCpgm'tool,
* McsEngl.lagCpgm'tool!⇒lagCpgm'tool,
* McsEngl.lagCpgm'tool,
tool.SPECIFIC
name::
* McsEngl.lagCpgm'tool,
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::
* McsEngl.code-editor-of-lagCpgm!⇒editorPrgm,
* McsEngl.editor-of-lagCpgm!⇒editorPrgm,
* McsEngl.editorPrgm,
* McsEngl.lagCpgm'editor!⇒editorPrgm,
* McsEngl.lagCpgm'tool.editor!⇒editorPrgm,
info-resource 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::
* McsEngl.compiler/kompáiler/-of-lagCpgm,
* McsEngl.lagCpgm'compiler,
* McsEngl.lagCpgm'tool.compiler,
====== langoGreek:
* McsElln.μεταγλωττιστής!ο!=compiler,
compilation of compiler
description::
· compilation of lagCpgm is the-process by which a-compiler translates a-source-algo to a-machine-algo.
name::
* McsEngl.compilation-of-lagCpgm,
* McsEngl.lagCpgm'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::
* McsEngl.interpreter/intérpiter/-of-lagCpgm,
* McsEngl.lagCpgm-interpreter,
* McsEngl.lagCpgm'tool.interpreter,
====== langoGreek:
* McsElln.διερμηνέας!ο!=interpreter,
06_human of lagCpgm
description::
· any human related with a-lagCpgm.
name::
* McsEngl.lagCpgm'06_human!⇒lagCpgm'human,
* McsEngl.lagCpgm'human!⇒lagCpgm'human,
* McsEngl.human.lagCpgm!⇒lagCpgm'human,
* McsEngl.lagCpgm'human,
human.programer
description::
· programer is a-human that knows a-lagCpgm[a] and uses it[a].
name::
* McsEngl.lagCpgm'programer,
* McsEngl.lagCpgm'human.programer,
* McsEngl.programer-of-lagCpgm,
07_organization of lagCpgm
name::
* McsEngl.lagCpgm'07_organization,
* McsEngl.lagCpgm'organization,
MISC-ATTRIBUTE of lagCpgm
name::
* McsEngl.lagCpgm'attMisc,
cross-platform-support of lagCpgm
expressivity of lagCpgm
description::
· expressivity of lagCpgm is its ability to easily map its archetype.
safty of lagCpgm
speed of lagCpgm
info-resource of lagCpgm
name::
* McsEngl.lagCpgm'Infrsc,
addressWpg::
* https://tomassetti.me/resources-create-programming-languages/,
* http://beadslang.com/,
documentation of lagCpgm
specification of lagCpgm
DOING of lagCpgm
name::
* McsEngl.lagCpgm'doing!⇒lagCpgm-doing,
* McsEngl.lagCpgm-doing,
doing.SPECIFIC
name::
* McsEngl.lagCpgm-doing.specific,
specific::
* installing-lagCpgm,
* updating-lagCpgm,
* uninstalling-lagCpgm,
* creating-lagCpgm,
* evoluting-lagCpgm,
* learning-lagCpgm,
* main-functing-lagCpgm,
main-functing of lagCpgm
description::
· the-main-functing of a-programing-language is to express information-processing for machines.
creating of lagCpgm
description::
· the-process of writing an-alog using the-lagCpgm.
name::
* McsEngl.lagCpgm'creating,
creating.TDD of lagCpgm
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::
* McsEngl.lagCpgm'Tdd,
* McsEngl.lagCpgm'test-driven-development-process,
* McsEngl.test-driven-development-process--of-lagCpgm,
translating of lagCpgm
description::
· translating of lagCpgm1 to Lpgm2 is the-process of mapping the-output of lagCpgm1 to the-output of lagCpgm2.
name::
* McsEngl.lagCpgm'translating,
* McsEngl.translating--programing-language,
evoluting of lagCpgm
name::
* McsEngl.lagCpgm'evoluting,
{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 lagCpgm
generic-tree::
* computer-language,
* language,
...
* entity,
lagCpgm.SPECIFIC
name::
* McsEngl.lagCpgm.specific,
specific::
* functional-lagCpgm,
* high-level--lagCpgm,
* low-level--lagCpgm,
* object-oriented--lagCpgm,
* procedural-lagCpgm,
===
* 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]
lagCpgm.specifics-division.on-machine
description::
· a-specifics-division on the-machine that understands and runs the-algo.
* machine-lagCpgm,
* assembly-lagCpgm,
* virual-code--lagCpgm,
* source-code--lagCpgm,
===
* low-level (machine, assembly, bytcode),
* high-level (source),
lagCpgm.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::
* McsEngl.lagCpgm.specifics-division.on-time-of-creation,
lagCpgm.specifics-division.on-domain
description::
· on domain:
* domain-specific--lagCpgm,
* general-purpose--lagCpgm,
lagCpgm.machine-code
description::
· machine-language is a-programing-language with output machine-code that a-real-machine understands.
name::
* McsEngl.Lmchn!⇒lagMchn, {2019-07-02},
* McsEngl.lagMchn!=machine-language,
* McsEngl.lagCpgm.machine!⇒lagMchn,
* McsEngl.machine-lagCpgm!⇒lagMchn,
* McsEngl.machine-programing-language!⇒lagMchn,
* McsEngl.lagMchn,
* McsEngl.lagCpgm.machine!⇒lagMchn,
* McsEngl.language.machine!⇒lagMchn,
* McsEngl.machine-code--language!⇒lagMchn,
* McsEngl.machine-language!⇒lagMchn,
* McsEngl.programing-language.macnine!⇒lagMchn,
algo (output) of lagMchn
description::
· machine-algo of a-lagMchn is an-algo a-real-machine understands.
name::
* McsEngl.Calgo.machine!⇒lagMchn-algo,
* McsEngl.lagMchn-algo,
* McsEngl.machine-algo!⇒lagMchn-algo,
* McsEngl.machine-doc!⇒lagMchn-algo,
machine-code of lagMchn
description::
· machine-code is code a-real-machine understands (today binary-code).
name::
* McsEngl.lagMchn'machine-code,
* McsEngl.lagMchn-algo'machine-code,
* McsEngl.lagCpgm-code.machine,
* McsEngl.machine-code,
lagMchn.TRINARY-CODE
description::
· trinary-language is a-machine-language with output trinary-code that a-real-machine understands.
name::
* McsEngl.Ltnr!⇒lagTnr, {2019-07-02},
* McsEngl.Ltnr!=trinary-language,
* McsEngl.trinary-lagCpgm!⇒lagTnr,
* McsEngl.trinary-programing-language!⇒lagTnr,
* McsEngl.lagMchn.trinary!⇒lagTnr,
* McsEngl.lagCpgm.trinary!⇒lagTnr,
* McsEngl.lagTnr, {2019-07-16},
* McsEngl.language.trinary!⇒lagTnr,
* McsEngl.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::
* McsEngl.lagCpgm-code.trinary,
* McsEngl.lagTnr'trinary-code,
* McsEngl.lagTnr-algo'trinary-code,
* McsEngl.trinary-code,
lagCpgm.binary-code
description::
· binary-language is a-machine-language with output binary-code that a-real-machine understands.
name::
* McsEngl.binary-code-language!⇒lagCpgmBnr,
* McsEngl.binary-lagCpgm!⇒lagCpgmBnr,
* McsEngl.binary-programing-language!⇒lagCpgmBnr,
* McsEngl.lagCpgmBnr,
* McsEngl.lagCpgmBnr!=binary--programing-language,
* McsEngl.lanMchn.binary!⇒lagCpgmBnr,
* McsEngl.lanPgm.binary!⇒lagCpgmBnr,
* McsEngl.language.binary!⇒lagCpgmBnr,
* McsEngl.programing-language.binary!⇒lagCpgmBnr,
algo (output) of lagCpgmBnr
description::
· binary-algo is a-machine-algo written in binary-code.
name::
* McsEngl.bin-algo!⇒lagCpgmBnr-algo,
* McsEngl.binary-algo!⇒lagCpgmBnr-algo,
* McsEngl.binary-doc!⇒lagCpgmBnr-algo,
* McsEngl.lagCpgmBnr-algo,
* McsEngl.Calgo.binary!⇒lagCpgmBnr-algo,
binary-code of lagCpgmBnr
description::
· binary-code is code written in 0 and 1, bits.
name::
* McsEngl.lagCpgm-code.binary,
* McsEngl.binary-lagCpgm-code,
* McsEngl.object-code,
lagCpgm.assembly-code
description::
· assembly-language is a-programing-language with output assembly-code that is-translated to machine-code.
name::
* McsEngl.Lasm!⇒lagAsm,
* McsEngl.assembly-code--language!⇒lagAsm,
* McsEngl.assembly-lagCpgm!⇒lagAsm,
* McsEngl.lagAsm,
* McsEngl.lagAsm!=assembly-language,
* McsEngl.lagCpgm.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::
* McsEngl.assembly-doc!⇒lagAsm-algo,
* McsEngl.Calgo.assembly!⇒lagAsm-algo,
* McsEngl.Lasm-algo,
* McsEngl.assembly-algo!⇒lagAsm-algo,
assembly-code of lagAsm
description::
· assembly-code is code written with mnemonics very close to machine-code.
name::
* McsEngl.lagCpgm-code.assembly,
* McsEngl.assembly-code,
lagCpgm.virtual-code
description::
· virtual-language is a-programing-language with output bytecode-code that a-virtual-machine understands.
name::
* McsEngl.Lbtcd!⇒lagBtcd,
* McsEngl.bytecode-lagCpgm!⇒lagBtcd,
* McsEngl.bytecode-language!⇒lagBtcd,
* McsEngl.lagBtcd,
* McsEngl.lagBtcd!=bytecode-language,
* McsEngl.lagCpgm.bytecode!⇒lagBtcd,
* McsEngl.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::
* McsEngl.bytecode-algo!⇒lagBtcd-algo,
* McsEngl.Calgo.bytecode!⇒lagBtcd-algo,
* McsEngl.lagBtcd-algo,
virtual-code of lagVtl
description::
· virtual-code is code written in 0 and 1, that a-virtual-machine understands.
name::
* McsEngl.lagCpgm-code.bytecode,
* McsEngl.lagCpgm-code.virtual-code,
* McsEngl.bytecode-of-lagCpgm,
* McsEngl.virtual-code,
lagCpgm.source-code
description::
· source-language is a-programing-language with output source-code that a-source-machine understands.
name::
* McsEngl.Lsrc!⇒lagSrc,
* McsEngl.lagSrc,
* McsEngl.lagCpgm.source!⇒lagSrc,
* McsEngl.source-code--language!⇒lagSrc,
* McsEngl.source-lagCpgm!⇒lagSrc,
nameGreek::
* McsElln.πηγαία--γλώσσα-προγραμματισμού,
archetype (input) of lagSrc
description::
· archetype of lagSrc is a-document describing information-processing as done by humans.
name::
* McsEngl.lagSrc'archetype!⇒lagSrc-archetype,
* McsEngl.lagSrc-archetype,
generic-tree::
* archetype-of-lagCpgm,
archo-code of archetype of lagSrc
description::
· archo-code of lagSrc is any human-code part of archetype.
name::
* McsEngl.lagSrc-archetype'archo-code,
* McsEngl.lagSrc-archo-code,
generic-tree::
* archo-code-of-lagCpgm,
domain of archetype of lagSrc
description::
· domain of lagSrc[a] is the-set of all archetypes that mapped with it[a].
name::
* McsEngl.lagSrc-algo'domain,
generic-tree::
* domain-of-lagCpgm,
algorithm (output) of lagSrc
description::
· source-algorithm is an-algo a-source-machine understands.
· it[a] is-written in source-code.
name::
* McsEngl.Calgo.source!⇒lagSrc-algo,
* McsEngl.lagSrc'algo!⇒lagSrc-algo,
* McsEngl.lagSrc-algo,
* McsEngl.source-algo!⇒lagSrc-algo,
nameGreek::
* McsElln.πηγαίος-αλγόριθμος,
generic-tree::
* algorithm-of-lagCpgm,
encoding of lagSrc-algo
description::
· the-output of a-lagSrc is digital-text and therefore uses a-character-encoding.
name::
* McsEngl.encoding-of--lagSrc-output,
* McsEngl.lagSrc'output-encoding,
* McsEngl.lagSrc-algo'encoding,
source-code of lagSrc-algo
description::
· source-code[a] of lagCpgm[b] is code written in human readable format.
· it[a] is any part of its[b] algo.
name::
* McsEngl.lagCpgm-code.source,
* McsEngl.lagSrc'source-code,
* McsEngl.lagSrc-algo'source-code,
* McsEngl.source-code,
codomain of lagSrc-algo
description::
· codomain of lagSrc is the-set of all algorithms that produces.
name::
* McsEngl.lagSrc'codomain,
* McsEngl.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::
* McsEngl.lagSrc'output-syntax-tree,
* McsEngl.lagSrc-algo'syntax-tree,
file of lagSrc-algo
description::
· the-algos are-stored in files.
name::
* McsEngl.lagSrc'output-file,
* McsEngl.lagSrc-algo'file,
Calgonode of lagSrc
description::
· output-structure of lagSrc[a] is any identifiable part of its[a] algo.
name::
* McsEngl.lagSrc'output-node!⇒lagSrc-node,
* McsEngl.lagSrc'output-structure!⇒lagSrc-node,
* McsEngl.lagSrc-algo'structure!⇒lagSrc-node,
* McsEngl.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::
* McsEngl.named--lagSrc-node,
* McsEngl.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::
* McsEngl.namedNo--agSrc-node,
* McsEngl.lagSrc-node.namedNo,
Calgo'unit of lagSrc
description::
· output-unit of lagSrc[a] is any indivisible part of its[a] algo.
name::
* McsEngl.lagSrc'output-unit,
* McsEngl.lagSrc'unit,
* McsEngl.lagSrc-algo'unit,
* McsEngl.lagSrc-node.unit,
* McsEngl.lagSrc-unit,
generic-tree::
* unit-of-lagCpgm,
Calgo'word of lagSrc
description::
· output-word of lagSrc is a-structure of units the-language uses to create more compound algo-structures.
name::
* McsEngl.lagSrc'output-word!⇒lagSrc-word,
* McsEngl.lagSrc'word!⇒lagSrc-word,
* McsEngl.lagSrc-algo'word!⇒lagSrc-word,
* McsEngl.lagSrc-node.word!⇒lagSrc-word,
* McsEngl.lagSrc-word,
generic-tree::
* word-of-lagCpgm,
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::
* McsEngl.identifier-of-lagSrc!⇒lagSrc-identifier,
* McsEngl.lagSrc'identifier!⇒lagSrc-identifier,
* McsEngl.lagSrc-identifier,
* McsEngl.lagSrc-word.identifier!⇒lagSrc-identifier,
naming-convention of identifier
description::
· source-code-languages use misc naming conventsions to form identifiers.
name::
* McsEngl.lagSrc'naming-convention!⇒lagSrc-naming-convention,
* McsEngl.lagSrc-identifier'naming-convention!⇒lagSrc-naming-convention,
* McsEngl.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::
* McsEngl.Hungarian--lagSrc-naming-convention,
* McsEngl.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::
* McsEngl.camel-case--lagSrc-naming-convention,
* McsEngl.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::
* McsEngl.lagSrc-naming-convention.snake-case,
* McsEngl.snake-case--lagSrc-naming-convention,
word.keyword of lagSrc
description::
· source-keyword is a-word reserved by the-language to construct algo-nodes.
name::
* McsEngl.keyword-of-lagSrc,
* McsEngl.lagSrc-keyword,
* McsEngl.lagSrc-word.keyword,
* McsEngl.lagSrc-word.reserved,
* McsEngl.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::
* McsEngl.lagSrc'semantic-unit!⇒lagSrc-Sunt,
* McsEngl.lagSrc-algo'semantic-unit!⇒lagSrc-Sunt,
* McsEngl.lagSrc-node.semantic-unit!⇒lagSrc-Sunt,
* McsEngl.lagSrc-semantic-unit!⇒lagSrc-Sunt,
* McsEngl.lagSrc-Sunt,
generic-tree::
* sem-unit-of-lagCpgm,
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::
* McsEngl.lagSrc'character!⇒lagSrc-ch,
* McsEngl.lagSrc-Sunt.character!⇒lagSrc-ch,
* McsEngl.lagSrc-ch,
specific::
* Rust-character,
Sunt.string (s) of lagSrc
description::
· strings are containers of human-written-code-(text).
name::
* McsEngl.lagSrc'string!⇒lagSrc-s,
* McsEngl.lagSrc-Sunt.string!⇒lagSrc-s,
* McsEngl.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::
* McsEngl.lagSrc'boolean!⇒lagSrc-b,
* McsEngl.lagSrc-Sunt.boolean!⇒lagSrc-b,
* McsEngl.lagSrc-b,
Sunt.number (n) of lagSrc
description::
· source-number of lagSrc is a-Sunt that denotes human-numbers.
name::
* McsEngl.lagSrc'number!⇒lagSrc-n,
* McsEngl.lagSrc-Sunt.number!⇒lagSrc-n,
* McsEngl.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::
* McsEngl.lagSrc'function!⇒lagSrc-f,
* McsEngl.lagSrc-Sunt.function!⇒lagSrc-f,
* McsEngl.lagSrc-f,
lagSrc-f.SPECIFIC
lagSrc-f.operator
description::
· source-operator of lagSrc is a-special-function with syntax like math-operators.
name::
* McsEngl.lagSrc'operator!⇒lagSrc-opr,
* McsEngl.lagSrc-f.operator!⇒lagSrc-opr,
* McsEngl.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::
* McsEngl.lagSrc'literal,
* McsEngl.lagSrc-Sunt.instance,
* McsEngl.lagSrc-Sunt.literal,
Sunt.instanceNo of lagSrc
description::
· type--semantic-unit of lagSrc is a-generic Sunt.
name::
* McsEngl.lagSrc'type,
* McsEngl.lagSrc-Sunt.instanceNo,
* McsEngl.lagSrc-Sunt.type,
Sunt.named of lagSrc
description::
· named-Sunt of lagSrc is a-semantic-unit associated with an-identifier.
name::
* McsEngl.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::
* McsEngl.lagSrc'output-phrase,
* McsEngl.lagSrc'phrase,
* McsEngl.lagSrc-algo'phrase,
* McsEngl.lagSrc-node.phrase,
* McsEngl.lagSrc-phrase,
generic-tree::
* phrase-of-lagCpgm,
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::
* McsEngl.lagSrc'output-sentence,
* McsEngl.lagSrc'sentence,
* McsEngl.lagSrc-algo'sentence,
* McsEngl.lagSrc-node.sentence,
* McsEngl.lagSrc-sentence,
generic-tree::
* sentence-of-lagCpgm,
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::
* McsEngl.lagSrc'output-section,
* McsEngl.lagSrc'section,
* McsEngl.lagSrc-algo'section,
* McsEngl.lagSrc-node.section,
* McsEngl.lagSrc-section,
generic-tree::
* section-of-lagCpgm,
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::
* McsEngl.lagSrc-algo'root,
* McsEngl.lagSrc-node.root,
* McsEngl.lagSrc-root,
Calgo.SPECIFIC of lagSrc
evalauation of lagSrc
tool of lagSrc
generic-tree::
* tool-of-lagCpgm,
info-resource of lagSrc
name::
* McsEngl.lagSrc'Infrsc,
generic-tree::
* resource-of-lagCpgm,
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::
* McsEngl.Lscr.compiled,
* McsEngl.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::
* McsEngl.lagSrc.interpreted,
* McsEngl.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.
lagCpgm.domain-specific
name::
* McsEngl.lagCpgm.domain-specific!⇒lagDsl,
* McsEngl.domain-specific-lagCpgm!⇒lagDsl,
* McsEngl.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]
lagCpgm.data
name::
* McsEngl.data-processing-language!⇒lagDtpr,
* McsEngl.lagCpgm.data!⇒lagDtpr,
* McsEngl.lagDtpr,
* McsEngl.lagDtpr!=data-processing--computer-language,
lagCpgm.concept (link)
lagCpgm.query
description::
· query-language is a-programing-language that FINDS information from computer-stored-one.
name::
* McsEngl.DQR!=data-query-language,
* McsEngl.lagCpgm.query!⇒lagQury,
* McsEngl.lagQury,
* McsEngl.query-language!⇒lagQury,
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]
lagCpgm.Lean
description::
· "Lean is a functional programming language that makes it easy to write correct and maintainable code. You can also use Lean as an interactive theorem prover. Lean programming primarily involves defining types and functions. This allows your focus to remain on the problem domain and manipulating its data, rather than the details of programming. Lean has numerous features, including:
* Type inference
* First-class functions
* Powerful data types
* Pattern matching
* Type classes
* Extensible syntax
* Hygienic macros
* Dependent types
* Metaprogramming framework
* Multithreading
* Verification: you can prove properties of your functions using Lean itself
The Lean project was launched by Leonardo de Moura when he was at Microsoft Research in 2013. It is an open source project, hosted on GitHub. Lean 4 is the latest version. The first milestone has been released on January 4, 2021, and nightly stable builds are available here. Information about the community of Lean users and the mathematical components library Mathlib can be found at the Lean Community website."
[{2023-08-19 retrieved} https://leanprover.github.io/about/]
name::
* McsEngl.lagLean,
* McsEngl.lagLean!=Lean-functional-programing-language,
* McsEngl.lagCpgm.Lean!⇒lagLean,
* McsEngl.Lean-functional-programing-language!⇒lagLean,
meta-info
this webpage was-visited times since {2019-06-29}
page-wholepath: synagonism.net / worldviewSngo / dirTchInf / lagCpgm
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 'lagCpgm' for structured-concepts related to current concept 'programing-language'.
⊛ LOCAL-SEARCH:
· TYPE CTRL+F "McsLang.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/McsWorld/blob/master/dirTchInf/McsTchInf000006.last.html,
• twitter: @synagonism
webpage-versions::
• version.last.dynamic: McsTchInf000006.last.html,
• version.1-0-0.2021-04-09: (0-31) ../../dirMiwMcs/dirTchInf/filMcsLagPrgm.1-0-0.2021-04-09.html,
• version.0-1-0.2019-06-29 draft creation,