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,

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,

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,

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,

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

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

description::
·

12_evaluation of Calgo

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

description::
·

MISC-ATTRIBUTE of Calgo

structure of Calgo

name::
* McsEngl.Calgo'structure,

DOING of Calgo

name::
* McsEngl.Calgo'doing,

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

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,

description::
·

15_using of Calgo

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

description::
·

16_developing of Calgo

name::
* McsEngl.Calgo'16_devoloping,

description::
·

evoluting of Calgo

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

description::
·

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

tool.SPECIFIC

name::
* McsEngl.lagCpgm'tool,

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

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,

cross-platform-support of lagCpgm

description::
·

name::
* McsEngl.lagCpgm'cross-platform-support,

expressivity of lagCpgm

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

name::
* McsEngl.lagCpgm'expressivity,

safty of lagCpgm

description::
·

name::
* McsEngl.lagCpgm'safty,

speed of lagCpgm

description::
·

name::
* McsEngl.lagCpgm'speed,

documentation of lagCpgm

name::
* McsEngl.lagCpgm'documentation,

description::
·

specification of lagCpgm

name::
* McsEngl.lagCpgm'specification,

description::
·

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.

name::
* McsEngl.lagCpgm'main-functing,

programing of lagCpgm

description::
· 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} https://bard.google.com/chat/4e52bb74e0d91bde]

name::
* McsEngl.lagCpgm'programing,
* McsEngl.programing//lagCpgm,
* McsEngl.programming//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,

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,

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,

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,

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,

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,

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.πηγαία--γλώσσα-προγραμματισμού,

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

description::
·

name::
* McsEngl.data-processing-language!⇒lagDtpr,
* McsEngl.lagCpgm.data!⇒lagDtpr,
* McsEngl.lagDtpr,
* McsEngl.lagDtpr!=data-processing--computer-language,

lagCpgm.concept (link)

lagCpgm.functional

description::
"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} https://chat.openai.com/c/2b7f6bc9-5fa0-414c-bae7-e6c26f610b8a]

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

lagCpgm.object-oriented

description::
"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} https://chat.openai.com/c/bef855e9-5c16-4aa3-a120-5baa3479045e]

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

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

description::
"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} https://chat.openai.com/c/30b13c96-f431-4d72-92b8-58eff1d3da76]

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

lagCpgm.declarative

description::
"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} https://chat.openai.com/c/5cd8acf9-8bc6-4af2-b683-5280ac522c0d]

name::
* McsEngl.declarative-lagCpgm,
* McsEngl.lagCpgm.declarative,

lagCpgm.imperative

description::
"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} https://chat.openai.com/c/ecbea33d-bb69-4041-b0fb-efbd6e4a7c36]

name::
* McsEngl.imperative-lagCpgm,
* McsEngl.lagCpgm.imperative,

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

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,

support (link)