senso-concept-Mcs (lagCpgm)

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

overview of lagCpgm

· programing-language is a-computer-language that maps information-processing by humans or machines (archetype) to information-processing by machines (algorithm).

* McsEngl.McsTchInf000006.last.html//dirTchInf//dirMcs!⇒lagCpgm,
* McsEngl.dirMcs/dirTchInf/McsTchInf000006.last.html!⇒lagCpgm,
* McsEngl.Lpgm!⇒lagCpgm,
* McsEngl.lagCmr.001-programing!⇒lagCpgm,
* McsEngl.lagCmr.programing!⇒lagCpgm,
* McsEngl.lagPgm!⇒lagCpgm,
* McsEngl.lagCpgm!=McsTchInf000006,
* McsEngl.lagCpgm!=programing--computer-language, {2023-08-19},
* McsEngl.lagPrgm!⇒lagCpgm, {2019-07-04},
* McsEngl.lagPrograming!⇒lagCpgm,
* McsEngl.language.programing!⇒lagCpgm,
* McsEngl.programing--computer-language!⇒lagCpgm,
* McsEngl.programing-language!⇒lagCpgm,
* McsEngl.programming-language!⇒lagCpgm,
====== langoGreek:
* McsElln.γλώσσα-προγραμματισμού!η!=lagCpgm,

01_tech of lagCpgm

· the-info-tech that manages the-lagCpgm.

* McsEngl.lagCpgm'01_tech,

01_machine of lagCpgm

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

* McsEngl.lagCpgm'01_machine,
* McsEngl.lagCpgm'machine,
* McsEngl.machine-of-lagCpgm,

02_input|archetype of lagCpgm

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

* 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

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

* 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

· domain of lagCpgm is the-set of all archetypes that are-mapped to algorithms.

* McsEngl.lagCpgm-domain,
* McsEngl.lagCpgm'archo'domain,
* McsEngl.domain-of-lagCpgm,

03_output|algo of lagCpgm

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

* 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,
*!⇒Calgo, {2020-05-05},
* McsEngl.output-of--programing-language!⇒Calgo,
* McsEngl.programing-algo!⇒Calgo, {2020-05-05},

02_node of Calgo

· algo-node of lagCpgm is any identifiable part of Calgo.

* McsEngl.Calgo'02_node!⇒Calgonode,
* McsEngl.Calgo'node!⇒Calgonode,
* McsEngl.Calgonode,
* McsEngl.Calgonode!=node-of-computer-algo,
* McsEngl.lagCpgm-node!⇒Calgonode, {2019-07-05},

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

03_unit-node of Calgo

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

* 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

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

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

* identifier,
* keyword,


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

* McsEngl.identifier-of-lagCpgm,
* McsEngl.lagCpgm-identifier,
* McsEngl.lagCpgm-word.identifier,


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

* McsEngl.keyword-of-lagCpgm,
* McsEngl.Calgo'keyword,
* McsEngl.lagCpgm-keyword,

05_semantic-unit-node of Calgo

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

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

· data-structure is a-semantic-unit that denotes types of data used in the-process.

"overview of data-structures:
Data structures are fundamental building blocks in computer science and play a crucial role in organizing and manipulating data efficiently. They provide a means to store, manage, and access data in various ways. Here's an overview of some common data structures:

1. **Arrays**:
- Arrays are collections of elements, each identified by an index.
- Elements are stored in contiguous memory locations.
- Quick access to elements using their index.

2. **Linked Lists**:
- Linked lists consist of nodes where each node holds data and a reference to the next node.
- Can be singly linked (each node points to the next) or doubly linked (each node points to the next and previous).
- Dynamic size and efficient insertion and deletion.

3. **Stacks**:
- A stack is a linear data structure that follows the Last-In-First-Out (LIFO) principle.
- Used for managing function calls, undo operations, and more.

4. **Queues**:
- A queue is a linear data structure that follows the First-In-First-Out (FIFO) principle.
- Used for managing tasks such as scheduling in operating systems.

5. **Trees**:
- Trees are hierarchical data structures with a root node and child nodes.
- Common types include binary trees, AVL trees, and B-trees.
- Used for organizing and searching data efficiently.

6. **Graphs**:
- Graphs are collections of nodes (vertices) and edges connecting these nodes.
- Used for modeling complex relationships, such as in social networks and network routing.

7. **Hash Tables**:
- Hash tables use a hash function to map keys to indices in an array, allowing for efficient data retrieval.
- Provides constant-time average-case complexity for search, insertion, and deletion.

8. **Heaps**:
- Heaps are specialized tree-based data structures used for maintaining a specific order, like a priority queue.
- Common types include min-heaps and max-heaps.

9. **Trie**:
- A trie is a tree-like data structure used for efficiently storing a dynamic set of strings.
- Well-suited for tasks like autocomplete and dictionary implementations.

10. **Sets and Maps**:
- Sets store a collection of unique elements.
- Maps associate keys with values, allowing for efficient data retrieval based on keys.

11. **Arrays and Matrices**:
- Multidimensional arrays and matrices are used to represent data with more than one dimension, like tables or images.

12. **Sparse Data Structures**:
- These are specialized data structures for efficiently storing and manipulating sparse data, where most elements are zero.

13. **Bloom Filters**:
- A probabilistic data structure used to test whether an element is a member of a set.
- Often used for quickly checking if data is present in a large dataset.

Each data structure has its own advantages and use cases, and the choice of which one to use depends on the specific requirements of your application. Understanding data structures is crucial for writing efficient algorithms and optimizing software performance."
[{2023-10-20 retrieved}]

====== langoGreek:
* McsElln.δομή-δεδομένων!=data-structure,

"overview of data-structures:
A **data structure** is a way of organizing data in a computer so that it can be used efficiently. It is a collection of data values and the relationships between them. Data structures are used to store, manage, and retrieve data in a way that is efficient and easy to understand.

There are many different types of data structures, each with its own advantages and disadvantages. Some common data structures include:
* **Arrays:** Arrays are a simple and efficient way to store a collection of data items of the same type.
* **Linked lists:** Linked lists are a flexible data structure that can be used to store a collection of data items of any type.
* **Stacks:** Stacks are a last-in-first-out (LIFO) data structure that is often used to implement function calls and undo/redo functionality.
* **Queues:** Queues are a first-in-first-out (FIFO) data structure that is often used to implement job queues and buffers.
* **Trees:** Trees are a hierarchical data structure that is often used to implement databases and file systems.
* **Graphs:** Graphs are a network data structure that is often used to represent social networks, transportation networks, and other complex relationships.

The choice of data structure depends on the specific needs of the application. For example, if you need to store a large collection of data items that need to be accessed quickly and randomly, then an array would be a good choice. If you need to store a collection of data items that need to be added and removed frequently, then a linked list would be a good choice.

Data structures are a fundamental concept in computer science, and they are used in almost every type of software. By understanding how data structures work, you can write more efficient and effective code.

Here are some of the benefits of using data structures:
* **Efficiency:** Data structures can help to improve the efficiency of your code by making it easier to access and manipulate data.
* **Accuracy:** Data structures can help to improve the accuracy of your code by reducing the risk of errors.
* **Reusability:** Data structures can be reused in different parts of your code, which can save you time and effort.
* **Maintainability:** Data structures can make your code more maintainable by making it easier to understand and modify.

If you are interested in learning more about data structures, there are many resources available online and in libraries. There are also many courses and tutorials that can teach you the basics of data structures and how to use them in your code."
[{2023-10-20 retrieved}]


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

* McsEngl.Calgo'Sunt.named,
* McsEngl.named--semantic-unit---of--programing-language,
* McsEngl.variable-of--programing-language,


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

* McsEngl.Calgo'Sunt.namedNo,

Sunt.function (f) of lagCpgm

· 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]."

* 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

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

* McsEngl.Calgo'06_phrase-node,
* McsEngl.Calgo'phrase-node,
* McsEngl.Calgonode.phrase,
* McsEngl.lagCpgm-phrase,

07_sentence-node of Calgo

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

* McsEngl.Calgo'07_sentence-node,
* McsEngl.Calgo'sentence-node,
* McsEngl.Calgonode.sentence,
* McsEngl.lagCpgm-sentence,

08_section-node of Calgo

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

* McsEngl.Calgo'08_section-no!⇒Calgo'section,
* McsEngl.Calgonode.section!⇒Calgo'section,
* McsEngl.Calgo'section,
* McsEngl.lagCpgm-section!⇒Calgo'section,

* comment,
* titled-section,
* titledNo-section,

section.TITLED of lagCpgm


* McsEngl.Calgo'titled-section,
* McsEngl.Calgo'section.titled,

section.TITLED.NO of lagCpgm


* McsEngl.Calgo'paragraph,
* McsEngl.Calgo'section.paragraph,
* McsEngl.Calgo'section.titledNo,

09_root-node of Calgo

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

* McsEngl.Calgo'09_root-node,
* McsEngl.Calgo'root-node,
* McsEngl.lagCpgm'root-node,

10_license of Calgo

* McsEngl.Calgo'10_license,

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

11_human of Calgo

* McsEngl.Calgo'11_human,
* McsEngl.Calgo'human,


12_evaluation of Calgo

* McsEngl.Calgo'12_evaluation,
* McsEngl.Calgo'evaluation,



code of Calgo

· code of Calgo is any PART of an algo.

* McsEngl.Calgo'code!⇒lagCpgm-code,
* McsEngl.lagCpgm-code,
* McsEngl.code-of-lagCpgm!⇒lagCpgm-code,
* McsEngl.output-code--of-lagCpgm!⇒lagCpgm-code,

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

codomain of Calgo

· codomain of lagCpgm is the-set of all algorithms that produces.

* McsEngl.Calgo'codomain,
* McsEngl.lagCpgm'codomain,
* McsEngl.lagCpgm-codomain,

file of Calgo

· the-algos are-stored in files.

* McsEngl.Calgo'file,

structure of Calgo

* McsEngl.Calgo'structure,

syntax-tree of Calgo

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

* McsEngl.Calgo'syntax-tree,
* McsEngl.syntax-tree--of-Calgo,

DOING of Calgo

* McsEngl.Calgo'doing,

* writting,
* translating,
* executing,

13_service of Calgo

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

* McsEngl.Calgo'13_service,
* McsEngl.Calgo'service,
* McsEngl.Calgo'main-functing,
* McsEngl.service-Calgo,

* {2019-08-22} Sean-Fleming,,

14_installing of Calgo

* McsEngl.Calgo'14_installing,
* McsEngl.Calgo'installing,


15_using of Calgo

* McsEngl.Calgo'15_using,
* McsEngl.Calgo'using,


executing of Calgo

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

* McsEngl.executing-of--Calgo,
* McsEngl.Calgo'executing,
* McsEngl.Calgo'running,
* McsEngl.running-of--Calgo,

16_developing of Calgo

* McsEngl.Calgo'16_devoloping,


evoluting of Calgo

* McsEngl.evoluting-of-Calgo,
* McsEngl.Calgo'evoluting,


Calgo.SPECIFIC of lagCpgm

* McsEngl.Calgo.specific,

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

Calgo.FRAMEWORK of lagCpgm

· "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}]

* McsEngl.framework-of-lagCpgm!⇒Cframework,
* McsEngl.Calgo.framework!⇒Cframework,
* McsEngl.Cframework,
* McsEngl.Cframework!=computer-framework,

Calgo.LIBRARY of lagCpgm

· a-library of a-lagCpgm is an-algo which HAS-NO an-executing-entry-point.

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

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

Calgo.PROGRAM (link) of lagCpgm

04_evaluation of lagCpgm

· every lagCpgm has its cons and pros as everything.

* McsEngl.lagCpgm'04_evaluation,
* McsEngl.lagCpgm'evaluation,

* benefit-of-lagCpgm,
* benefitNo-of-lagCpgm,

05_tool of lagCpgm

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

* McsEngl.lagCpgm'05_tool!⇒lagCpgm'tool,
* McsEngl.lagCpgm'tool!⇒lagCpgm'tool,
* McsEngl.lagCpgm'tool,


* McsEngl.lagCpgm'tool,

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


· the-program we use to-write a-program.

* 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


* McsEngl.editorPrgm'Infrsc,


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

* McsEngl.compiler/kompáiler/-of-lagCpgm,
* McsEngl.lagCpgm'compiler,
* McsEngl.lagCpgm'tool.compiler,
====== langoGreek:
* McsElln.μεταγλωττιστής!ο!=compiler,

compilation of compiler

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

* McsEngl.compilation-of-lagCpgm,
* McsEngl.lagCpgm'compilation,


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

* McsEngl.interpreter/intérpiter/-of-lagCpgm,
* McsEngl.lagCpgm-interpreter,
* McsEngl.lagCpgm'tool.interpreter,
====== langoGreek:
* McsElln.διερμηνέας!ο!=interpreter,

06_human of lagCpgm

· any human related with a-lagCpgm.

* McsEngl.lagCpgm'06_human!⇒lagCpgm'human,
* McsEngl.lagCpgm'human!⇒lagCpgm'human,
* McsEngl.human.lagCpgm!⇒lagCpgm'human,
* McsEngl.lagCpgm'human,


· programer is a-human that knows a-lagCpgm[a] and uses it[a].

* McsEngl.lagCpgm'programer,
* McsEngl.lagCpgm'human.programer,
* McsEngl.programer-of-lagCpgm,

07_organization of lagCpgm


* McsEngl.lagCpgm'07_organization,
* McsEngl.lagCpgm'organization,


* McsEngl.lagCpgm'attMisc,

cross-platform-support of lagCpgm


* McsEngl.lagCpgm'cross-platform-support,

expressivity of lagCpgm

· expressivity of lagCpgm is its ability to easily map its archetype.

* McsEngl.lagCpgm'expressivity,

safty of lagCpgm


* McsEngl.lagCpgm'safty,

speed of lagCpgm


* McsEngl.lagCpgm'speed,

info-resource of lagCpgm

* McsEngl.lagCpgm'Infrsc,


documentation of lagCpgm

* McsEngl.lagCpgm'documentation,


specification of lagCpgm

* McsEngl.lagCpgm'specification,


DOING of lagCpgm

* McsEngl.lagCpgm'doing!⇒lagCpgm-doing,
* McsEngl.lagCpgm-doing,


* McsEngl.lagCpgm-doing.specific,

* installing-lagCpgm,
* updating-lagCpgm,
* uninstalling-lagCpgm,
* creating-lagCpgm,
* evoluting-lagCpgm,
* learning-lagCpgm,
* main-functing-lagCpgm,

main-functing of lagCpgm

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

* McsEngl.lagCpgm'main-functing,

programing of lagCpgm

· the-process of writing an-algo using the-lagCpgm.

"overview of programing:
Programming is the process of creating instructions for a computer to follow. These instructions, called code, are written in a programming language, which is a set of rules that define how the computer should interpret the code.

Once the code is written, it needs to be compiled or interpreted into a form that the computer can understand. This process is called translation. Once the code has been translated, it can be executed, or run, by the computer.

Programming languages can be divided into two main categories: high-level languages and low-level languages. High-level languages are easier for humans to read and write, while low-level languages are closer to the machine code that the computer actually understands.

Some popular high-level programming languages include Python, Java, C++, JavaScript, and Ruby. Some popular low-level programming languages include C and Assembly.

Programming can be used to create a wide variety of software applications, including websites, mobile apps, desktop applications, video games, and operating systems.

Here is an overview of the basic steps involved in programming:
1. **Define the problem.** What do you want the computer to do?
2. **Design a solution.** How can you break down the problem into smaller, more manageable tasks?
3. **Choose a programming language.** Which language is best suited for your task?
4. **Write the code.** Implement your solution in the chosen programming language.
5. **Compile or interpret the code.** Translate the code into a form that the computer can understand.
6. **Test the code.** Run the code and make sure it works as expected.
7. **Deploy the code.** Make the code available to users.

Programming is a complex skill, but it is also a rewarding one. It allows you to create things that would not be possible otherwise. If you are interested in learning to program, there are many resources available online and in libraries.

Here are some tips for getting started with programming:
* Start with a simple language like Python or Ruby. These languages are relatively easy to learn and have large communities of users and developers.
* Find a good tutorial or book on programming. There are many resources available online and in libraries.
* Practice regularly. The more you code, the better you will become at it.
* Don't be afraid to ask for help. There are many online forums and communities where you can ask questions and get help from other programmers.

Programming is a skill that is in high demand in the job market. If you learn to program, you will have many opportunities for employment."
[{2023-10-20 retrieved}]

* McsEngl.lagCpgm'programing,
* McsEngl.programing//lagCpgm,
* McsEngl.programming//lagCpgm,

programing.TDD of lagCpgm

"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!"

* McsEngl.lagCpgm'Tdd,
* McsEngl.lagCpgm'test-driven-development-process,
* McsEngl.test-driven-development-process--of-lagCpgm,

translating of lagCpgm

· translating of lagCpgm1 to Lpgm2 is the-process of mapping the-output of lagCpgm1 to the-output of lagCpgm2.

* McsEngl.lagCpgm'translating,
* McsEngl.translating--programing-language,

evoluting of lagCpgm

"evolution of programming-languages:
The evolution of programming languages is a fascinating journey that has spanned several decades. Programming languages have evolved to become more powerful, expressive, and user-friendly, reflecting changes in hardware, software development practices, and the needs of developers. Here's a brief overview of the key stages in the evolution of programming languages:

1. Machine Language (1940s): The earliest programming languages were essentially machine code, which directly interacted with the computer's hardware. Programmers had to write instructions using binary or hexadecimal code specific to the computer they were working on.

2. Assembly Language (1950s): Assembly languages provided symbolic representations of machine code instructions, making it easier for programmers to work with hardware. Assembly languages were still closely tied to the underlying architecture of the computer.

3. High-Level Programming Languages (1950s-1960s): The development of high-level languages, like Fortran, COBOL, and LISP, marked a significant shift. These languages introduced abstractions that were more natural and user-friendly, making it easier to write code for specific tasks and algorithms. Fortran, for instance, was designed for scientific and engineering calculations, while COBOL was developed for business applications.

4. Structured Programming (1960s-1970s): The 1960s saw the emergence of structured programming languages, such as ALGOL and Pascal, which promoted structured code with clear control flow constructs, like loops and conditionals. This led to more readable and maintainable code.

5. C and C++ (1970s-1980s): The creation of the C programming language by Dennis Ritchie in the early 1970s had a profound impact. C became a widely used and influential language due to its portability and low-level capabilities. C++ extended C with object-oriented features, further shaping the way software was developed.

6. Object-Oriented Programming (1980s-1990s): Languages like Smalltalk, C++, and later Java and C# popularized the concept of object-oriented programming (OOP). OOP introduced the idea of encapsulating data and behavior within objects, improving code organization and reusability.

7. Scripting Languages (1990s): Scripting languages like Perl, Python, and Ruby gained popularity for their ease of use and versatility in tasks like web development, automation, and text processing.

8. The Rise of the Web (1990s-2000s): The growth of the internet and the World Wide Web gave rise to languages like HTML, JavaScript, and CSS, which are used for web development. These languages enabled the creation of dynamic and interactive web applications.

9. Functional Programming (2000s-present): Languages like Haskell, Scala, and Erlang brought functional programming concepts to the forefront. Functional programming emphasizes immutability and the use of pure functions.

10. Mobile Development (2000s-present): The mobile revolution led to the development of languages and platforms such as Swift for iOS and Kotlin for Android, which made mobile app development more accessible and efficient.

11. Modern Languages and Paradigms (2000s-present): Modern languages like Rust, Go, and TypeScript have emerged, each designed to address specific challenges in systems programming, concurrent programming, and web development.

12. Artificial Intelligence and Data Science (2010s-present): Languages like Python have become the go-to choice for AI and data science applications, thanks to libraries like TensorFlow and scikit-learn.

13. Low-Code and No-Code (2010s-present): The rise of low-code and no-code platforms has allowed non-developers to create software applications using visual interfaces, reducing the need for traditional programming.

The evolution of programming languages continues, driven by advancements in technology and the evolving needs of the software development community. New languages and paradigms will continue to emerge to address the challenges of the future."
[{2023-10-20 retrieved}]

* McsEngl.evoluting-of-lagCpgm,
* McsEngl.lagCpgm'evoluting,

=== 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."

GENERIC of lagCpgm

* computer-language,
* language,
* entity,


* McsEngl.lagCpgm.specific,

* high-level--lagCpgm,
* low-level--lagCpgm,
* declarative-lagCpgm,
* imperative-lagCpgm,
* functional-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,


· 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),

* McsEngl.lagCpgm.specifics-division-on-machine,


* {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,

"programming languages along with their respective release years:
* Fortran - 1957
* LISP - 1958
* COBOL - 1959
* ALGOL - 1960
* CPL (Combined Programming Language) - 1963
* BASIC (Beginner's All-purpose Symbolic Instruction Code) - 1964
* PL/I (Programming Language One) - 1964
* APL (A Programming Language) - 1964
* Simula - 1967
* SNOBOL - 1967
* Pascal - 1970
* C - 1972
* Smalltalk - 1972
* Prolog - 1972
* ML (Meta Language) - 1973
* Scheme - 1975
* SQL (Structured Query Language) - 1976
* Forth - 1970s
* AWK - 1977
* Modula-2 - 1978
* Ada - 1980
* C++ - 1983
* Perl - 1987
* Python - 1991
* Ruby - 1995
* Java - 1995
* JavaScript - 1995
* Delphi (Object Pascal) - 1995
* PHP - 1995
* Visual Basic - 1991 (original version)
* Visual Basic. NET - 2001
* C# - 2000
* Swift - 2014
* Kotlin - 2011
* Rust - 2010
* TypeScript - 2012
* Go - 2009
* Dart - 2011
These are just a few of the many programming languages that have been developed over the years, each with its own specific purposes and applications."
[{2024-01-08 retrieved}]

* McsEngl.lagCpgm.specifics-division.on-time-of-creation,


· on domain:
* domain-specific--lagCpgm,
* general-purpose--lagCpgm,

* McsEngl.lagCpgm.specifics-division.on-domain,


"Global Index @TheGlobal_Index
Top 35 most used programming languages worldwide, 2023 💻:
* Javascript - 63%
* HTML/CSS - 53%
* Python - 49%
* SQL - 48%
* TypeScript - 39%
* Bash/Sell - 32%
* Java - 30%
* C# - 27%
* C++ - 22%
* C - 19%
* PHP - 18%
* PowerShell - 13%
* Go - 13%
* Rust - 13%
* Kotlin - 6%
* Ruby - 6%
* Lua - 6%
* Dart - 6%
* Assembly - 5%
* Swift - 4%
* R - 4%
* Visual Basic - 4%
* MATLAB - 3%
* VBA - 3%
* Groovy - 3%
* Delphi - 3%
* Scala - 2%
* Perl - 2%
* Elixir - 2%
* Objective-C - 2%
* Haskell - 2%
* GDScript - 1%
* Lisp - 1%
* Solidity - 1%
* Clojure - 1%"
[{2023-11-20 retrieved}]

* McsEngl.lagCpgm.used,


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

* 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

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

* McsEngl.Calgo.machine!⇒lagMchn-algo,
* McsEngl.lagMchn-algo,
* McsEngl.machine-algo!⇒lagMchn-algo,
* McsEngl.machine-doc!⇒lagMchn-algo,

machine-code of lagMchn

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

* McsEngl.lagMchn'machine-code,
* McsEngl.lagMchn-algo'machine-code,
* McsEngl.lagCpgm-code.machine,
* McsEngl.machine-code,

* binary-code,
* trinary-code,


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

* 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

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

* McsEngl.lagCpgm-code.trinary,
* McsEngl.lagTnr'trinary-code,
* McsEngl.lagTnr-algo'trinary-code,
* McsEngl.trinary-code,


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

* 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

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

* 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

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

* McsEngl.lagCpgm-code.binary,
* McsEngl.binary-lagCpgm-code,
* McsEngl.object-code,


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

* 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

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

* McsEngl.lagAsm'archetype,

algo (output) of lagAsm

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

* McsEngl.assembly-doc!⇒lagAsm-algo,
* McsEngl.Calgo.assembly!⇒lagAsm-algo,
* McsEngl.Lasm-algo,
* McsEngl.assembly-algo!⇒lagAsm-algo,

assembly-code of lagAsm

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

* McsEngl.lagCpgm-code.assembly,
* McsEngl.assembly-code,


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

* 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

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

* McsEngl.bytecode-algo!⇒lagBtcd-algo,
* McsEngl.Calgo.bytecode!⇒lagBtcd-algo,
* McsEngl.lagBtcd-algo,

virtual-code of lagVtl

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

* McsEngl.lagCpgm-code.bytecode,
* McsEngl.lagCpgm-code.virtual-code,
* McsEngl.bytecode-of-lagCpgm,
* McsEngl.virtual-code,


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

* McsEngl.Lsrc!⇒lagSrc,
* McsEngl.lagSrc,
* McsEngl.lagCpgm.source!⇒lagSrc,
* McsEngl.source-code--language!⇒lagSrc,
* McsEngl.source-lagCpgm!⇒lagSrc,

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

archetype (input) of lagSrc

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

* McsEngl.lagSrc'archetype!⇒lagSrc-archetype,
* McsEngl.lagSrc-archetype,

* archetype-of-lagCpgm,

archo-code of archetype of lagSrc

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

* McsEngl.lagSrc-archetype'archo-code,
* McsEngl.lagSrc-archo-code,

* archo-code-of-lagCpgm,

domain of archetype of lagSrc

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

* McsEngl.lagSrc-algo'domain,

* domain-of-lagCpgm,

algorithm (output) of lagSrc

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

* McsEngl.Calgo.source!⇒lagSrc-algo,
* McsEngl.lagSrc'algo!⇒lagSrc-algo,
* McsEngl.lagSrc-algo,
* McsEngl.source-algo!⇒lagSrc-algo,

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

* algorithm-of-lagCpgm,

encoding of lagSrc-algo

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

* McsEngl.encoding-of--lagSrc-output,
* McsEngl.lagSrc'output-encoding,
* McsEngl.lagSrc-algo'encoding,

source-code of lagSrc-algo

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

* McsEngl.lagCpgm-code.source,
* McsEngl.lagSrc'source-code,
* McsEngl.lagSrc-algo'source-code,
* McsEngl.source-code,

codomain of lagSrc-algo

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

* McsEngl.lagSrc'codomain,
* McsEngl.lagSrc-algo'codomain,

syntax-tree of lagSrc-algo

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

* McsEngl.lagSrc'output-syntax-tree,
* McsEngl.lagSrc-algo'syntax-tree,

file of lagSrc-algo

· the-algos are-stored in files.

* McsEngl.lagSrc'output-file,
* McsEngl.lagSrc-algo'file,

Calgonode of lagSrc

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

* McsEngl.lagSrc'output-node!⇒lagSrc-node,
* McsEngl.lagSrc'output-structure!⇒lagSrc-node,
* McsEngl.lagSrc-algo'structure!⇒lagSrc-node,
* McsEngl.lagSrc-node,

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

node.named of lagSrc-algo

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

* McsEngl.named--lagSrc-node,
* McsEngl.lagSrc-node.named,

node.namedNo of lagSrc-algo

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

* McsEngl.namedNo--agSrc-node,
* McsEngl.lagSrc-node.namedNo,

Calgo'unit of lagSrc

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

* McsEngl.lagSrc'output-unit,
* McsEngl.lagSrc'unit,
* McsEngl.lagSrc-algo'unit,
* McsEngl.lagSrc-node.unit,
* McsEngl.lagSrc-unit,

* unit-of-lagCpgm,

* white-space,

Calgo'word of lagSrc

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

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

* word-of-lagCpgm,

* identifier,
* keyword,

word.identifier of lagSrc

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

* McsEngl.identifier-of-lagSrc!⇒lagSrc-identifier,
* McsEngl.lagSrc'identifier!⇒lagSrc-identifier,
* McsEngl.lagSrc-identifier,
* McsEngl.lagSrc-word.identifier!⇒lagSrc-identifier,

naming-convention of identifier

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

* McsEngl.lagSrc'naming-convention!⇒lagSrc-naming-convention,
* McsEngl.lagSrc-identifier'naming-convention!⇒lagSrc-naming-convention,
* McsEngl.lagSrc-naming-convention,

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

naming-convention.Hungarian of lagSrc

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

* McsEngl.Hungarian--lagSrc-naming-convention,
* McsEngl.lagSrc-naming-convention.Hungarian,

naming-convention.camel-case of lagSrc

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

* McsEngl.camel-case--lagSrc-naming-convention,
* McsEngl.lagSrc-naming-convention.camel-case,

naming-convention.snake-case of lagSrc

· snake-case--naming-convention of lagSrc is the-convention of writing multi-word identifiers separated with the-underscore-(_ LOW-LINE)-char.

* McsEngl.lagSrc-naming-convention.snake-case,
* McsEngl.snake-case--lagSrc-naming-convention,

word.keyword of lagSrc

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

* 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

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

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

* sem-unit-of-lagCpgm,

Sunt.SPECIFIC of lagSrc

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

* McsEngl.lagSrc-Sunt.specific,

Sunt.character (ch) of lagSrc

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

* McsEngl.lagSrc'character!⇒lagSrc-ch,
* McsEngl.lagSrc-Sunt.character!⇒lagSrc-ch,
* McsEngl.lagSrc-ch,

* Rust-character,

Sunt.string (s) of lagSrc

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

* McsEngl.lagSrc'string!⇒lagSrc-s,
* McsEngl.lagSrc-Sunt.string!⇒lagSrc-s,
* McsEngl.lagSrc-s,

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

Sunt.boolean (b) of lagSrc

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

* McsEngl.lagSrc'boolean!⇒lagSrc-b,
* McsEngl.lagSrc-Sunt.boolean!⇒lagSrc-b,
* McsEngl.lagSrc-b,

Sunt.number (n) of lagSrc

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

* McsEngl.lagSrc'number!⇒lagSrc-n,
* McsEngl.lagSrc-Sunt.number!⇒lagSrc-n,
* McsEngl.lagSrc-n,

number.SPECIFIC of lagSrc

* integer-number,
* integerNo-number,
* signed-number,
* signedNo-number,
* C++-number,
* Rust-number,

* McsEngl.lagSrc-n.specific,

Sunt.function (f) of lagSrc

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

* McsEngl.lagSrc'function!⇒lagSrc-f,
* McsEngl.lagSrc-Sunt.function!⇒lagSrc-f,
* McsEngl.lagSrc-f,


* operator,

* McsEngl.lagSrc-f.specific,


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

* McsEngl.lagSrc'operator!⇒lagSrc-opr,
* McsEngl.lagSrc-f.operator!⇒lagSrc-opr,
* McsEngl.lagSrc-opr,


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

* McsEngl.lagSrc-opr.specific,

Sunt.instance (literal) of lagSrc

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

* McsEngl.lagSrc'literal,
* McsEngl.lagSrc-Sunt.instance,
* McsEngl.lagSrc-Sunt.literal,

Sunt.instanceNo of lagSrc

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

* McsEngl.lagSrc'type,
* McsEngl.lagSrc-Sunt.instanceNo,
* McsEngl.lagSrc-Sunt.type,

Sunt.named of lagSrc

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

* McsEngl.lagSrc-Sunt.named,

identifier of named-Sunt (link)

value of named-Sunt

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

* McsEngl.lagSrc-named-Sunt'value,

Sunt.namedNo of lagSrc


* McsEngl.lagSrc-Sunt.namedNo,

Calgo'phrase of lagSrc

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

* McsEngl.lagSrc'output-phrase,
* McsEngl.lagSrc'phrase,
* McsEngl.lagSrc-algo'phrase,
* McsEngl.lagSrc-node.phrase,
* McsEngl.lagSrc-phrase,

* phrase-of-lagCpgm,

Calgo'sentence of lagSrc

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

* McsEngl.lagSrc'output-sentence,
* McsEngl.lagSrc'sentence,
* McsEngl.lagSrc-algo'sentence,
* McsEngl.lagSrc-node.sentence,
* McsEngl.lagSrc-sentence,

* sentence-of-lagCpgm,

sentence.SPECIFIC of lagSrc

* definition-sentence,

* McsEngl.lagSrc.specific,

sentence.definition of lagSrc

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

* McsEngl.lagSrc-sentence.definition,

* assignment-definition,
* function-definition,

Calgo'section of lagSrc

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

* McsEngl.lagSrc'output-section,
* McsEngl.lagSrc'section,
* McsEngl.lagSrc-algo'section,
* McsEngl.lagSrc-node.section,
* McsEngl.lagSrc-section,

* section-of-lagCpgm,

* comment,
* titled-section,
* titledNo-section,

section.block of lagSrc

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

* McsEngl.lagSrc-block,

Calgo'root of lagSrc

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

* McsEngl.lagSrc-algo'root,
* McsEngl.lagSrc-node.root,
* McsEngl.lagSrc-root,

Calgo.SPECIFIC of lagSrc

* library--Lsrc-algo,
* program--Lsrc-algo,

* McsEngl.lagSrc-algo.specific,

evalauation of lagSrc


* McsEngl.lagSrc'evaluation,

tool of lagSrc


* McsEngl.lagSrc'tool,

* tool-of-lagCpgm,

info-resource of lagSrc

* McsEngl.lagSrc'Infrsc,

* resource-of-lagCpgm,



* McsEngl.lagSrc.specific,


· 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].

* McsEngl.Lscr.compiled,
* McsEngl.compiled--programing-language,


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

* McsEngl.lagSrc.interpreted,
* McsEngl.interpreted--programing-language,


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

* McsEngl.lagSrc.dynamically-typed,


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

* McsEngl.lagSrc.statically-type,


* McsEngl.lagCpgm.domain-specific!⇒lagDsl,
* McsEngl.domain-specific-lagCpgm!⇒lagDsl,
* McsEngl.lagDsl,

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


* McsEngl.lagDtpr,
* McsEngl.lagDtpr!=data-processing--computer-language,

lagCpgm.concept (link)


"overview of functional-language:
Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data. Functional languages are programming languages that emphasize and support functional programming principles. Here's an overview of functional languages and the key concepts associated with them:

1. **Immutability**: Functional languages promote the use of immutable data structures, which means once a data object is created, it cannot be modified. Instead, new objects are created as a result of transformations.

2. **First-Class and Higher-Order Functions**: In functional languages, functions are treated as first-class citizens, which means they can be assigned to variables, passed as arguments to other functions, and returned as values from other functions. Higher-order functions are functions that take other functions as arguments or return them as results.

3. **Pure Functions**: Pure functions are a fundamental concept in functional programming. They have no side effects, meaning they don't modify any external state or variables, and their output solely depends on their input parameters. This makes them predictable and easier to reason about.

4. **Recursion**: Recursion is often preferred over loops for repetitive tasks in functional programming. It's a natural way to express algorithms, and many functional languages optimize tail recursion.

5. **Lazy Evaluation**: Some functional languages support lazy evaluation, which means expressions are not evaluated until their results are actually needed. This can improve efficiency by avoiding unnecessary calculations.

6. **Pattern Matching**: Pattern matching is a way to destructure data and perform different actions based on its structure. It's common in functional languages like Haskell and Erlang.

7. **List Comprehensions**: Many functional languages provide list comprehensions, which are concise ways to generate and transform lists or collections.

8. **Higher-Order Abstractions**: Functional languages often provide higher-order abstractions like map, filter, and reduce (fold) to operate on collections in a declarative way.

9. **Type Systems**: Functional languages often have strong and expressive type systems that help catch errors at compile-time. Some use static typing (e.g., Haskell), while others use type inference (e.g., ML).

10. **Concurrency and Parallelism**: Functional languages are well-suited for concurrent and parallel programming because they emphasize immutability and lack of shared state, making it easier to reason about and avoid race conditions.

Notable functional languages include:
1. **Haskell**: Known for its strong type system, lazy evaluation, and emphasis on purity. Haskell is a purely functional language.

2. **Erlang**: Designed for building highly concurrent and fault-tolerant systems, Erlang is known for its actor model and pattern matching.

3. **Lisp**: One of the oldest functional languages, Lisp is known for its powerful macro system and is used in artificial intelligence and symbolic computing.

4. **ML (e.g., Standard ML and OCaml)**: ML family of languages have strong type systems and are used in both academia and industry.

5. **Scala**: A hybrid language that combines functional and object-oriented programming, running on the Java Virtual Machine.

6. **Clojure**: A modern Lisp dialect that runs on the Java Virtual Machine and emphasizes immutability and simplicity.

Functional programming can be a powerful paradigm for solving certain types of problems, and functional languages have seen increased interest in recent years due to their suitability for parallel and distributed computing."
[{2023-10-20 retrieved}]

* McsEngl.functional-language,
* McsEngl.lagCpgm.002-functional,
* McsEngl.lagCpgm.functional,


"overview of object-oriented-languages:
Object-oriented programming (OOP) is a programming paradigm that is based on the concept of "objects." Object-oriented languages are programming languages that support and encourage the principles and features of OOP. Here's an overview of key concepts and features commonly associated with object-oriented languages:

1. **Objects**: Objects are the fundamental building blocks in OOP. They represent real-world entities or concepts and encapsulate data (attributes) and behavior (methods or functions) related to those entities. For example, in a program representing a banking system, an "Account" object might have attributes like balance and account number and methods like deposit and withdraw.

2. **Classes**: Classes serve as blueprints or templates for creating objects. They define the structure and behavior of objects. A class can be thought of as a user-defined data type. Instances of a class are objects.

3. **Encapsulation**: Encapsulation is the concept of bundling data (attributes) and methods (functions) that operate on the data into a single unit called an object. This provides data hiding and restricts direct access to an object's internal state, allowing controlled interaction with the object through defined methods.

4. **Inheritance**: Inheritance is a mechanism that allows a class (called the subclass or derived class) to inherit properties and behaviors from another class (called the superclass or base class). This promotes code reuse and the creation of hierarchies of related classes.

5. **Polymorphism**: Polymorphism enables objects of different classes to be treated as objects of a common superclass. It allows for flexibility in method invocation and behavior depending on the actual type of the object at runtime. This is often achieved through method overriding and interfaces.

6. **Abstraction**: Abstraction involves simplifying complex systems by breaking them into smaller, more manageable parts. In OOP, this is often achieved by defining abstract classes and methods that provide a high-level view of an object's functionality without getting into the implementation details.

7. **Method Overloading and Overriding**: Method overloading allows a class to have multiple methods with the same name but different parameter lists. Method overriding allows a subclass to provide a specific implementation for a method defined in its superclass.

8. **Dynamic Binding**: Object-oriented languages typically support dynamic binding, which means the decision of which method to invoke is made at runtime based on the actual type of the object, not the reference type.

Some popular object-oriented programming languages include:
1. **Java**: Known for its "write once, run anywhere" capability, Java is a widely used, statically-typed object-oriented language. It enforces strict encapsulation and supports inheritance, polymorphism, and dynamic binding.

2. **C++**: An extension of the C programming language, C++ supports both procedural and object-oriented programming. It features classes, inheritance, polymorphism, and operator overloading.

3. **C#**: Developed by Microsoft, C# is designed for building Windows applications and web services. It combines OOP principles with features for event-driven and component-based programming.

4. **Python**: Python is dynamically typed and highly versatile. It supports OOP features such as classes, inheritance, and encapsulation, but it also allows for other programming paradigms.

5. **Ruby**: Ruby is known for its elegant and highly flexible object-oriented features. It follows the principle of "everything is an object," and it emphasizes simplicity and productivity.

6. **Smalltalk**: Smalltalk is one of the earliest object-oriented programming languages, and it heavily influenced the development of OOP concepts. It's known for its pure OOP approach.

7. **Objective-C**: Objective-C is the primary language used for macOS and iOS app development. It's an object-oriented superset of C and has dynamic typing.

These languages and their object-oriented features have been instrumental in the development of a wide range of software applications, from desktop applications to web and mobile applications."
[{2023-10-20 retrieved}]

* McsEngl.OOL!=object-oriented-language!⇒lagCool,
* McsEngl.lagCool!=object-oriented--programing-language,
* McsEngl.lagCpgm.003-object-oriented!⇒lagCool,
* McsEngl.lagCpgm.object-oriented!⇒lagCool,
* McsEngl.object-oriented-language!⇒lagCool,

evoluting of lagCool

"evolution of object-oriented-languages:
The evolution of object-oriented programming languages has been a significant and ongoing process since the inception of the concept of object-oriented programming (OOP). Below is a brief overview of the key milestones and developments in the history of object-oriented languages:

1. **Simula (1967)**:
- Simula, created by Ole-Johan Dahl and Kristen Nygaard, is often considered the first object-oriented programming language. It introduced the concept of classes and objects.
- Simula influenced many subsequent OOP languages, and its primary focus was on simulation and modeling.

2. **Smalltalk (1972)**:
- Smalltalk, developed by Alan Kay and his team at Xerox PARC, was a groundbreaking language. It introduced the idea of message passing, encapsulation, and a graphical user interface.
- Smalltalk's purity as an object-oriented language served as a model for many other OOP languages.

3. **C++ (1983)**:
- C++, created by Bjarne Stroustrup, extended the C programming language by adding support for object-oriented programming. It introduced features like classes, inheritance, and polymorphism.
- C++ became popular for systems programming and application development, and it laid the foundation for many OOP languages that followed.

4. **Objective-C (1983)**:
- Objective-C, developed by Brad Cox, added object-oriented features to the C programming language. It gained prominence as the primary language for macOS and iOS application development.

5. **Eiffel (1986)**:
- Eiffel, designed by Bertrand Meyer, emphasized the importance of software engineering practices and formal methods. It introduced design by contract and other innovative concepts.
- Eiffel was used for building reliable and high-quality software systems.

6. **Java (1995)**:
- Java, developed by James Gosling at Sun Microsystems (now Oracle), gained popularity for its "Write Once, Run Anywhere" capability. It introduced features like platform independence and garbage collection.
- Java is widely used for web and enterprise applications, and its OOP features are a core part of its design.

7. **Python (1991)**:
- Python, created by Guido van Rossum, is a dynamically-typed, high-level language that incorporates object-oriented principles. It is known for its simplicity and readability.
- Python has become a versatile language, used in web development, data analysis, and artificial intelligence.

8. **C# (2000)**:
- Microsoft's C# was developed as part of the .NET framework. It combines object-oriented features with event-driven and component-based programming for building Windows applications and web services.

9. **Ruby (1995)**:
- Ruby, created by Yukihiro Matsumoto, is an expressive and dynamically-typed language known for its elegant object-oriented features. It introduced the idea that "everything is an object."
- Ruby's simplicity and productivity have led to its use in web development and scripting.

10. **Scala (2003)**:
- Scala, designed by Martin Odersky, combines functional programming and object-oriented programming. It runs on the Java Virtual Machine (JVM) and is known for its expressiveness.

11. **Kotlin (2011)**:
- Kotlin, created by JetBrains, is another language that runs on the JVM. It was designed to be more concise and safe than Java while maintaining compatibility with Java libraries.

12. **Swift (2014)**:
- Swift, developed by Apple, is used for macOS, iOS, watchOS, and tvOS app development. It introduced modern OOP features and a focus on performance and safety.

The evolution of object-oriented languages has seen a shift towards more modern features, such as functional programming capabilities and improved memory management. While the principles of OOP have remained consistent, these languages have adapted to the changing needs of software development, making them more versatile and powerful. Additionally, they continue to influence and inspire the development of new programming languages and paradigms."
[{2023-10-20 retrieved}]

* McsEngl.evoluting-of-lagCool,
* McsEngl.lagCool'evoluting,


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

* McsEngl.DQR!=data-query-language,
* McsEngl.lagCpgm.query!⇒lagQury,
* McsEngl.lagQury,
* McsEngl.query-language!⇒lagQury,

"Query languages or data query languages (DQLs) are computer languages used to make queries in databases and information systems."


"overview of scripting-languages:
Scripting languages, also known as script languages, are a type of programming language that are typically used for automating tasks, writing small to medium-sized programs, and controlling software applications. Unlike low-level languages like C or assembly, scripting languages are higher-level and offer a more abstract and simplified way to interact with a computer system. Here's an overview of scripting languages:

1. **Interpreted Languages**: Most scripting languages are interpreted, meaning the code is executed line by line by an interpreter, without the need for compilation. This makes them more accessible and flexible for tasks that require rapid development.

2. **Dynamic Typing**: Scripting languages often use dynamic typing, which means you don't need to declare variable types explicitly. The interpreter determines the type at runtime.

3. **High-Level Abstractions**: Scripting languages typically provide high-level abstractions for common tasks, making it easier to write code. This can include string manipulation, file handling, and data structures.

4. **Script Files**: Scripting languages are often used to create script files, which contain a series of commands or instructions to be executed. These scripts can automate processes or configure software.

5. **Common Uses**:
- **Automation**: Scripting languages are commonly used for automating repetitive tasks, such as file manipulation, data processing, and system administration.
- **Web Development**: Many web technologies use scripting languages, such as JavaScript for client-side web development and languages like Python, Ruby, or PHP for server-side scripting.
- **System Administration**: Scripting languages like Bash, PowerShell, and Python are widely used for managing and configuring computer systems.
- **Data Analysis**: Languages like Python and R are popular for data analysis and visualization tasks.
- **Game Development**: Some game engines and frameworks use scripting languages to create game logic and behaviors.

6. **Examples of Scripting Languages**:
- **Python**: Known for its simplicity and readability, Python is widely used in various domains, including web development, data science, and automation.
- **JavaScript**: Primarily used for web development to add interactivity and dynamic behavior to websites.
- **Bash**: A Unix shell script language used for system administration and automation on Unix-like operating systems.
- **Ruby**: Known for its elegant syntax and is often used in web development (Ruby on Rails).
- **Perl**: Historically used for text processing and system administration tasks.
- **PHP**: A server-side scripting language designed for web development.

7. **Advantages**:
- Quick development: Easier and faster to write code.
- Platform independence: Often portable across different operating systems.
- High-level abstractions: Simplify complex tasks.
- Versatility: Suitable for a wide range of applications.

8. **Disadvantages**:
- Slower execution: Interpreted languages are generally slower than compiled languages.
- Limited performance: Not ideal for CPU-intensive tasks.
- Security concerns: Vulnerabilities may arise due to dynamic typing and weak typing.
- Learning curve: Some scripting languages may have unique syntax and features.

Scripting languages are essential tools for automating tasks and building applications where development speed and ease of use are more critical than raw performance. The choice of a scripting language often depends on the specific task at hand and the developer's preferences."
[{2023-10-20 retrieved}]

* McsEngl.lagCpgm.001-scripting!⇒lagCscr,
* McsEngl.lagCpgm.scripting!⇒lagCscr,
* McsEngl.lagCscr!=scripting--programing-language,
* McsEngl.scripting-language!⇒lagCscr,

evoluting of lagCscr

"evolution of scripting-languages:
The evolution of scripting languages has been a fascinating journey that has seen these languages evolve from simple tools for automating tasks to powerful and versatile programming languages used in various domains. Here is a brief overview of the evolution of scripting languages:

1. **Early Scripting Languages (1950s - 1960s)**:
- The concept of scripting languages can be traced back to the early days of computing when simple command scripts were used to automate tasks.
- Languages like **FORTRAN** and **COBOL** had scripting capabilities that allowed users to create custom batch jobs.

2. **Shell Scripting (1970s - 1980s)**:
- Shell scripting languages like **Bourne Shell (sh)** and later **Bash (Bourne-Again Shell)** became popular for automating tasks on Unix-based systems.
- These languages were primarily used for system administration and file manipulation.

3. **Perl (1987)**:
- Perl, created by Larry Wall, was one of the first scripting languages designed specifically for text processing and report generation.
- Perl's expressive syntax and regular expression support made it popular for web programming and data manipulation.

4. **Python (1989)**:
- Guido van Rossum created Python, a general-purpose scripting language that emphasized readability and simplicity.
- Python's clean syntax, extensive standard library, and community support contributed to its widespread adoption in various domains.

5. **JavaScript (1995)**:
- JavaScript was originally developed by Netscape for web scripting, enabling dynamic, client-side interactions in web browsers.
- It has since evolved to become a versatile language, used not only for web development but also for server-side development (Node.js).

6. **Ruby (1995)**:
- Yukihiro Matsumoto created Ruby as a flexible, dynamic, and object-oriented scripting language.
- Ruby gained popularity, particularly in web development with the Ruby on Rails framework.

7. **PHP (1995)**:
- Rasmus Lerdorf initially developed PHP as a server-side scripting language for web development.
- PHP became one of the most popular choices for building dynamic web applications.

8. **Perl 6 (Raku) (2015)**:
- Perl 6, which later renamed itself to Raku, was developed as a complete redesign of Perl, incorporating modern language features and better support for concurrency.

9. **Swift (2014)**:
- While primarily designed for application development on Apple's platforms, Swift is a powerful scripting language known for its performance, safety features, and ease of use.

10. **Modern Scripting Languages (ongoing)**:
- Scripting languages continue to evolve and adapt to the changing needs of developers. They have become essential in various domains, including web development, data analysis, automation, and more.

The evolution of scripting languages has been driven by the need for increased productivity, ease of use, and the demands of various application domains. These languages continue to adapt and evolve to meet the challenges of the ever-changing technological landscape."
[{2023-10-20 retrieved}]

* McsEngl.evoluting-of-lagCscr,
* McsEngl.lagCscr'evoluting,


"overview of declarative-languages:
Declarative languages are a type of programming language that focuses on describing what should be done, rather than explicitly specifying how to do it. In declarative languages, you define the desired outcome or result, and the language's runtime system or interpreter figures out the steps to achieve that outcome. This is in contrast to imperative languages, where you specify each step of the program's execution.

Here is an overview of declarative languages:
1. **Declarative vs. Imperative:** Declarative languages are often contrasted with imperative languages. In imperative programming, you provide explicit instructions on how to achieve a task, using statements like loops, conditionals, and assignments. In declarative programming, you declare the desired outcome and let the system determine how to achieve it.

2. **Types of Declarative Languages:**
a. **Functional Languages:** Functional programming languages, such as Haskell, Lisp, and Erlang, are declarative in nature. They focus on the evaluation of mathematical functions and expressions.
b. **Logic Programming Languages:** Logic programming languages, like Prolog, are based on formal logic. You specify facts and rules, and the system infers conclusions from these declarations.
c. **Database Query Languages:** SQL (Structured Query Language) is a common example of a declarative language used for querying and manipulating relational databases.
d. **Markup Languages:** Markup languages like HTML and XML are declarative languages used for structuring and presenting data on the web.

3. **Advantages of Declarative Languages:**
a. **Simplicity:** Declarative languages often result in more concise and readable code because they abstract away low-level details.
b. **Ease of Parallelism:** Declarative code can be easier to parallelize since the system can optimize execution based on the desired outcome.
c. **Abstraction:** Declarative languages allow developers to focus on the "what" rather than the "how," promoting a higher level of abstraction.

4. **Limitations of Declarative Languages:**
a. **Limited Control:** Declarative languages may not be suitable for tasks that require fine-grained control over the execution process.
b. **Performance:** In some cases, declarative languages can be less efficient than imperative languages because they leave optimization decisions to the system.
c. **Learning Curve:** Learning to think and program in a declarative manner can be challenging for developers accustomed to imperative paradigms.

5. **Examples of Declarative Usage:**
- SQL for querying databases.
- HTML for defining the structure of web pages.
- Regular expressions for pattern matching in strings.
- CSS for styling web pages.
- Prolog for expert systems and artificial intelligence.

6. **Hybrid Languages:** Some languages, like Python and Ruby, incorporate both imperative and declarative elements. Developers can choose to write code in a more declarative or imperative style, depending on the situation.

In summary, declarative languages are designed to make programming more about specifying the desired results and less about the step-by-step instructions to achieve those results. They are often used in specific domains where abstraction and high-level descriptions of tasks are beneficial."
[{2023-10-24 retrieved}]

* McsEngl.declarative-lagCpgm,
* McsEngl.lagCpgm.declarative,


"imperative-languages vs procedural-languages:
Imperative languages and procedural languages are both programming paradigms that describe how a program is structured and how tasks are performed, but they are not the same thing. Let's distinguish between the two:

1. **Imperative Languages:**
- **Definition:** Imperative programming is a paradigm that focuses on describing a sequence of steps or actions that the computer must take to accomplish a task. It's characterized by statements that change a program's state through assignment, loops, and control flow structures.
- **Features:**
- It is based on the concept of "how to do" something.
- Programs are written as a sequence of statements that modify the program's state.
- It uses variables, loops, and conditionals to control the flow of execution.
- Common examples include languages like C, C++, and Pascal.

2. **Procedural Languages:**
- **Definition:** Procedural programming is a subset of imperative programming that focuses on organizing code into reusable procedures or functions. A procedure is a self-contained block of code that performs a specific task.
- **Features:**
- It emphasizes breaking down a program into smaller, manageable procedures or functions.
- Functions are used to encapsulate and structure code, promoting modularity and reusability.
- It still relies on variables, loops, and conditionals.
- Common examples include C, Pascal, and Fortran (though it can be applied in other languages as well).

In summary, procedural programming is a subset of imperative programming. While both paradigms involve modifying a program's state through statements and actions, procedural programming places a stronger emphasis on organizing code into procedures or functions to promote modularity and maintainability. The choice between imperative and procedural programming depends on the specific requirements of a project and the preferences of the programmer."
[{2023-10-24 retrieved}]

* McsEngl.imperative-lagCpgm,
* McsEngl.lagCpgm.imperative,


· "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}]

* McsEngl.lagLean,
* McsEngl.lagLean!=Lean-functional-programing-language,
* McsEngl.lagCpgm.Lean!⇒lagLean,
* McsEngl.Lean-functional-programing-language!⇒lagLean,


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

page-wholepath: / worldviewSngo / dirTchInf / lagCpgm

· this page uses 'locator-names', names that when you find them, you find the-LOCATION of the-concept they denote.
· 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'.
· TYPE CTRL+F "McsLag4.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.

• author: Kaseluris.Nikos.1959
• email:
• edit on github:,
• twitter: @synagonism

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

support (link)