03_output of CmprLago

description::
· output of CmprLago is a-document a-computer understands.

name::
* McsEngl.CmprCode!=output-of-CmprLago,
* McsEngl.Cmprloutput!⇒CmprCode,
* McsEngl.code-of-computer-language!⇒CmprCode,
* McsEngl.infoComputer!⇒CmprCode,
* McsEngl.CmprLago'03_output!⇒CmprCode,
* McsEngl.CmprLago'output!⇒CmprCode,
* McsEngl.output-of-CmprLago!⇒CmprCode,

node of CmprCode

description::
· output-node of CmprLago is any identifiable part of its[a] output.

name::
* McsEngl.CmprCode'node!⇒Cmprlnode,
* McsEngl.CmprLago'node!⇒Cmprlnode,
* McsEngl.CmprLago'output-node!⇒Cmprlnode,
* McsEngl.Cmprlnode,
* McsEngl.Cmprlnode!=node-of-CmprLago'output,
* McsEngl.CmprLago'output'node!⇒Cmprlnode,

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

code of CmprCode

description::
· output-code of CmprLago[a] is any part of its[a] output.

name::
* McsEngl.code//CmprLago,
* McsEngl.CmprLago'output-code,
* McsEngl.CmprLago'output'code,

syntax-tree of CmprCode

description::
· output-syntax-tree of CmprLago[a] is the-whole-part-tree of nodes of its[a] output.

name::
* McsEngl.CmprLago'output-syntax-tree,
* McsEngl.CmprLago'output'syntax-tree,

unit of CmprCode

description::
· to create the-output, we need building-blocks.
· the-units-(symbols) of these building-blocks are the-unit-of-the-output.

name::
* McsEngl.CmprCode'unit,

semantic-unit of CmprCode

description::
· a-structure of units that DENOTE a-node in input.

name::
* McsEngl.CmprCode'semantic-unit,

data-structure of CmprCode

description::
· data-structure is a-semantic-unit that denotes data.

name::
* McsEngl.CmprCode'data-structure,
* McsEngl.data-structure//CmprLago,

static-analysis of CmprCode

description::
× Mcsh-creation: {2025-12-02},
">static analysis of code:
Static analysis is the process of examining source code *without executing it* to find bugs, security vulnerabilities, style issues, or maintainability problems early in development.
Below is a concise but complete overview.
---
## ✅ **What Static Analysis Is**
Static analysis inspects your code **statically**—i.e., based only on its text—to detect:
* Possible null pointer dereferences
* Type inconsistencies
* Unused variables or dead code
* Security vulnerabilities (SQL injection, unsafe deserialization, etc.)
* Concurrency issues (data races, inconsistent synchronization)
* Code smells and architectural violations
It helps developers catch issues **before runtime**, reducing debugging time and improving software quality.
---
## 🔍 **How Static Analysis Works**
Different tools use different techniques:
### **1. Lexical Analysis**
Parses the raw text to identify tokens like identifiers, keywords, literals.
### **2. Syntax Analysis (Parsing)**
Builds an AST (Abstract Syntax Tree).
Example:
```java
int x = a + b;
```
is represented as a tree where `+` is the root and `a`, `b` are children.
### **3. Semantic Analysis**
Checks:
* Type correctness
* Variable and method resolution
* Scope rules
* Data flow (e.g., uninitialized variables)
### **4. Control + Data Flow Analysis**
Finds:
* Unreachable code
* Always-false conditions
* Nullability issues
* Resources that may not be closed
### **5. Pattern-based rule matching**
Tools use rules like:
⭢ “If you open a stream but don’t close it, warn.”
---
## 🧰 Popular Static Analysis Tools (Java-focused since you’re a Java dev)
### **Code Quality & Bug Detection**
* **SpotBugs** (successor of FindBugs)
* **Checkstyle**
* **PMD**
* **SonarQube** (industry standard; CI/CD integration)
### **Security Analysis**
* **SonarCloud / SonarQube Security Rules**
* **OWASP Dependency Check**
* **Snyk**
* **Checkmarx**
* **Fortify SCA**
### **IDE Built-in**
* IntelliJ inspections
* Eclipse static analysis
* VSCode plugins
---
## ⚙️ Example in Java
Given this code:
```java
public String getName(User user) {
return user.getName().toLowerCase(); // possible NPE
}
```
Static analysis tools may report:
* **Possible NullPointerException** (`user` or `user.getName()` might be null)
* Missing null-check
* Missing @NotNull annotation
---
## 🧪 Static Analysis vs Dynamic Analysis
| Static | Dynamic |
| No execution required | Runs the code |
| Faster | Slower |
| Finds potential bugs early | Catches runtime errors |
| Checks entire codebase | Limited to executed paths |
| Cannot detect logical/runtime bugs | Can detect real failures |
You usually want **both**.
---
## 🚀 If you want, I can also:
* Perform static analysis on a **piece of code you provide**
* Recommend the best tools for your project
* Generate a **static analysis checklist**
* Explain how to integrate static analysis into **Maven/Gradle pipelines**
Just paste your code or tell me what you need!

⭢ the static analysis of LLMs is better than special tools?
Short answer: **No — LLMs are *useful*, but traditional static analysis tools are still much better for real, reliable static analysis.**
LLMs and static analyzers are *complementary*, not replacements for each other.
Below is the clear comparison.
---
# ✅ **LLMs vs Traditional Static Analysis Tools**
## **1. Accuracy & Reliability**
### **Static analysis tools:**
* Use deterministic algorithms
* Perform real **type checking, data-flow, control-flow** analysis
* Guarantee detection of certain classes of bugs
* No hallucinations
### **LLMs:**
* Work statistically, predicting text
* Can miss issues or invent non-existent problems
* Cannot reliably trace execution paths
* No guarantee of correctness
➡️ **Static analysis tools win** for guaranteed correctness.
---
## **2. Depth of Code Understanding**
### **Static tools**
* Understand code **formally**
* Know language grammar, bytecode, control/data flow graphs
* Track variables through functions and branching
### **LLMs**
* Understand code **semantically and linguistically**
* Can summarize logic, propose improvements
* Can identify *design-level* issues or smells tools can’t detect (e.g., “This module violates single responsibility.”)
➡️ **LLMs win** for design critique or architectural insights.
---
## **3. Detecting Low-level Bugs**
### Static analyzers:
* Null pointer dereference
* Deadlocks
* Resource leaks
* Type errors
* Injection vulnerabilities
* Race conditions (to some extent)
### LLMs:
* Might spot them if obvious
* But cannot reliably trace execution for all branches
* Miss subtle concurrency bugs
➡️ **Static analyzers win massively** here.
---
## **4. Security**
### Static analysis tools (Checkmarx, Fortify, SonarQube, Semgrep):
* Rule-based
* Updated with new CVE patterns
* Scan dependency vulnerabilities
* No hallucination risk
### LLMs:
* Can suggest security improvements
* But cannot guarantee finding all vulnerabilities
* Could hallucinate nonexistent exploits
➡️ **Static analyzers win** — trusted for compliance and audits.
---
## **5. Maintainability & Code Quality Suggestions**
### LLMs:
* Excellent at refactoring suggestions
* Can rewrite code to be cleaner
* Can detect high-level smells (overengineering, poor naming)
### Static analysis tools:
* Limited to predefined rule sets
➡️ **LLMs win** for *refactoring* and *readability* advice.
---
# 🏁 **Conclusion**
### ❌ LLMs do *not* replace static analysis tools
* They cannot track formal execution paths
* They hallucinate
* They cannot enforce strict coding rules reliably
* They are not accepted for compliance/security audits
### ✅ LLMs are excellent *complements*
Use them for:
* Understanding code
* Refactoring
* Improving design
* Explaining static analysis warnings
* Suggesting fixes
### 🔥 Best approach:
⭢ **Use a static analysis tool to detect objective issues, and an LLM to explain and improve the code.**
---
If you want, I can compare specific tools (SonarQube vs GPT-4/5), or analyze a code snippet with both "LLM-style analysis" and "static-tool-style analysis" so you can see the difference."
[{2025-12-02 retrieved} https://chatgpt.com/c/692ef5c4-a80c-8333-95f9-07be8b19e03e]

name::
* McsEngl.CmprCode'static-analysis,
* McsEngl.static-analysis-CmprCode,

relation-to-AI of static-analysis

description::
× Mcsh-creation: {2025-12-02},
"Static Analysis and AI
If you’re like me, the way you write code has changed significantly in the past year. December 2024 was the first time I decided to use AI to write code, and today it generates most of the code I work on. It also writes the tests and documentation. My job is now focused on reviewing code, and that can get tiring. How can I be confident that the code meets my standards, remains secure, and scales well? The answer is static analysis.

Static analysis tools inspect code without executing it, which removes the risk of side effects or security issues that can appear when running tests. This is why static analysis often runs before code execution in continuous integration systems. You may be thinking, “Wait a minute! Don't LLMs perform static analysis on my files to work on them?” The answer is not really.

LLMs read text and look for patterns. Because they have been trained on a large amount of code, they can identify patterns that appear desirable or undesirable. Their analysis is non-deterministic, which means you will not always get the same results even when asking the same question of the same code. LLMs also have no semantic understanding of the code they read. Without semantics, any evaluation becomes a guess.

Traditional static analysis tools are deterministic and understand semantics. For example, ESLint knows the difference between an identifier named foo and the string "foo". To an LLM, these are similar-looking tokens and the interpretation can shift based on context. This makes static analysis even more important for AI-generated code than for human-written code.

Here are some static analysis tools worth integrating, especially if you are deploying AI-generated code:

Linters. As the creator of ESLint, I am a strong supporter of using linters. They are especially important for languages that are not compiled before deployment, such as JSON, YAML, and CSS, because they catch syntax errors before production. As capable as LLMs are, I still encounter incorrect syntax in AI-generated code at least once a week. Many linters also flag problematic patterns even when syntax is valid, which makes them essential for AI-generated code.

Type checkers. Compiled languages include type checking, but others do not. If you are using a language with a type checker, such as TypeScript for JavaScript, make sure to use it to avoid runtime errors.

Accessibility checkers. When working with generated HTML, it is important to verify that the code meets accessibility standards. Accessibility checkers are available both as command line tools and as features built into browser developer tools.

Security scanners. Because LLMs are trained on large amounts of code that may not be verified as safe, AI-generated code often contains security vulnerabilities. Use a security scanner that supports your programming language so you do not deploy code that is open to attack.

Dependency checkers. You should never let AI select a dependency that has not been vetted. Since LLMs are trained on historical data, they often choose outdated dependencies with known security or licensing issues. Make sure your dependencies are automatically checked before deployment.

As AI becomes a larger part of how we write code, static analysis provides a reliable foundation that keeps our work consistent, secure, and maintainable. These tools do not replace the value of human judgment, but they give us confidence that the code we review is structurally sound before we ship it. By pairing AI-assisted development with a strong static analysis pipeline, you set yourself up for faster reviews and higher quality results.

Key Takeaways
AI can generate large amounts of code, but static analysis is essential to ensure that the code is secure, consistent, and reliable.
LLMs identify patterns but do not understand code semantics, so their output cannot replace deterministic static analysis tools.
Integrating linters, type checkers, accessibility tools, security scanners, and dependency checkers provides a safer path to deploying AI-generated code."
[{2025-12-02 retrieved} nicholas@humanwhocodes.com]

name::
* McsEngl.static-analysis'relation-to-AI,

CmprLago.data-representation-006

description::
· data-representation-language is an-info-representation-language that represents data.

name::
* McsEngl.data-representation-language!⇒lagDtrp,
* McsEngl.CmprLago.006-data-representation!⇒lagDtrp,
* McsEngl.CmprLago.data-representation!⇒lagDtrp,
* McsEngl.lagDtrp,
* McsEngl.lagDtrp!=data-representation--computer-language,

CmprLago.data-serialization-008

description::
"In computing, serialization (US spelling) or serialisation (UK spelling) is the process of translating a data structure or object state into a format that can be stored (for example, in a file or memory data buffer) or transmitted (for example, across a computer network) and reconstructed later (possibly in a different computer environment).[1] When the resulting series of bits is reread according to the serialization format, it can be used to create a semantically identical clone of the original object. For many complex objects, such as those that make extensive use of references, this process is not straightforward. Serialization of object-oriented objects does not include any of their associated methods with which they were previously linked.
This process of serializing an object is also called marshalling an object in some situations.[1][2] The opposite operation, extracting a data structure from a series of bytes, is deserialization, (also called unserialization or unmarshalling)."
[{2021-01-01} https://en.wikipedia.org/wiki/Serialization]

name::
* McsEngl.data-serialization-format,
* McsEngl.CmprLago.008-data-serialization,

CmprLago.delimiter-separated-values-009

description::
"Formats that use delimiter-separated values (also DSV)[1]:113 store two-dimensional arrays of data by separating the values in each row with specific delimiter characters. Most database and spreadsheet programs are able to read or save data in a delimited format. Due to their wide support, DSV files can be used in data exchange among many applications.
A delimited text file is a text file used to store data, in which each line represents a single book, company, or other thing, and each line has fields separated by the delimiter.[2] Compared to the kind of flat file that uses spaces to force every field to the same width, a delimited file has the advantage of allowing field values of any length.[3]"
[{2021-01-01} https://en.wikipedia.org/wiki/Delimiter-separated_values]

name::
* McsEngl.DSV!=delimiter-separated-values,
* McsEngl.delimiter-separated-values!⇒lagDsv,
* McsEngl.CmprLago.009-delimiter-separated-values!⇒lagDsv,
* McsEngl.CmprLago.delimiter-separated-values!⇒lagDsv,
* McsEngl.lagDsv,

CmprLago.text-document-representation-007

description::
· text-document-representation-language is a-info-representation-language that represents TEXT documents.

name::
* McsEngl.TdocLago!=text-document--language,
* McsEngl.document-file-format!⇒TdocLago,
* McsEngl.document-representation-language!⇒TdocLago,
* McsEngl.CmprLago.007-document-representation!⇒TdocLago,
* McsEngl.CmprLago.document-representation!⇒TdocLago,
* McsEngl.lagDoc!⇒TdocLago,
* McsEngl.lagTdoc!⇒TdocLago, {2021-01-04},
* McsEngl.lagoTdoc!⇒TdocLago,
* McsEngl.TdocLago!=text-document-representation-language,
* McsEngl.text-document-representation-language!⇒TdocLago,

descriptionLong::
"A document file format is a text or binary file format for storing documents on a storage media, especially for use by computers. There currently exist a multitude of incompatible document file formats.
Examples of XML-based open standards are DocBook, XHTML, and, more recently, the ISO/IEC standards OpenDocument (ISO 26300:2006) and Office Open XML (ISO 29500:2008).
In 1993, the ITU-T tried to establish a standard for document file formats, known as the Open Document Architecture (ODA) which was supposed to replace all competing document file formats. It is described in ITU-T documents T.411 through T.421, which are equivalent to ISO 8613. It did not succeed.
Page description languages such as PostScript and PDF have become the de facto standard for documents that a typical user should only be able to create and read, not edit. In 2001, a series of ISO/IEC standards for PDF began to be published, including the specification for PDF itself, ISO-32000.
HTML is the most used and open international standard and it is also used as document file format. It has also become ISO/IEC standard (ISO 15445:2000).
The default binary file format used by Microsoft Word (.doc) has become widespread de facto standard for office documents, but it is a proprietary format and is not always fully supported by other word processors."
[{2021-01-01} https://en.wikipedia.org/wiki/Document_file_format]

machine of TdocLago

description::
· the-machine that understads|displays the-output-doc.

name::
* McsEngl.TdocLago'machine,

input-doc of TdocLago

description::
· a-text-document written in a-human-natural-language.

name::
* McsEngl.docNtxt,
* McsEngl.docNtxt!=natural-language--text-document,
* McsEngl.docText.natural!⇒docNtxt,
* McsEngl.document.text!⇒docNtxt,
* McsEngl.TdocLago'human-doc!⇒docNtxt,
* McsEngl.TdocLago'input-doc!⇒docNtxt,
* McsEngl.TdocLago'text-doc!⇒docNtxt,
* McsEngl.text-document!⇒docNtxt,
====== lagoGreek:
* McsElln.έγγραφο-κειμένου!το!=docNtxt,

unit of docNtxt

description::
* letter,
* number,
* symbol,
* image,

name::
* McsEngl.docNtxt'unit,
* McsEngl.unit-of-docNtxt,

title of docNtxt

description::
· a-phrase.

name::
* McsEngl.docNtxt'title,
* McsEngl.title-of-docNtxt,

paragraph of docNtxt

description::
· sequence of sentences.

name::
* McsEngl.docNtxt'paragraph,
* McsEngl.paragraph-of-docNtxt,

list of docNtxt

description::
· a-sequence of info, ordered or not.

name::
* McsEngl.docNtxt'list,
* McsEngl.list-of-docNtxt,

table of docNtxt

description::
· a-rectagular structure of info.

name::
* McsEngl.docNtxt'table,
* McsEngl.table-of-docNtxt,

tree of docNtxt

description::
· a-hierarchical structure of terms.

name::
* McsEngl.docNtxt'tree,
* McsEngl.tree-of-docNtxt,

section of docNtxt

description::
· a-title, some paragraphs, sections.

name::
* McsEngl.docNtxt'section,
* McsEngl.section-of-docNtxt,

GENERIC-SPECIFIC-TREE of docNtxt

generic-tree-of-docNtxt::
* document,
* ... entity,
* McsEngl.docNtxt'generic-tree,

specific-tree-of-docNtxt::
* article,
* book,
* encyclopedia,
* periodical,
* title-content-tree--document,

* McsEngl.docNtxt.specific-tree,

output of TdocLago

description::
· the-mapping doc that the-machine displays.

name::
* McsEngl.digital--text-document!⇒docDtxt,
* McsEngl.docDtxt,
* McsEngl.docDtxt!=document-of--digital-text,
* McsEngl.docText.digital!⇒docDtxt,
* McsEngl.TdocLago'output-doc!⇒docDtxt,
* McsEngl.TdocLago'machine-doc!⇒docDtxt,

GENERIC-SPECIFIC-TREE of docDtxt

generic-tree-of-docDtxt::
* digital-document,
* ... entity,
* McsEngl.docDtxt'generic-tree,

specific-tree-of-docDtxt::
* plain-docDtxt,
* formatted-docDtxt,

* McsEngl.docDtxt.specific-tree,

tool of TdocLago

description::
· any program we use to write and display the-machine-doc.

name::
* McsEngl.TdocLago'tool,

TdocLago.SPECIFIC

description::
* 0 – Plain Text Document, normally used for licensing,
* 1ST – Plain Text Document, normally preceded by the words "README" (README.1ST),
* 600 – Plain Text Document, used in UNZIP history log,
* 602 – Text602 document,
* ABW – AbiWord document,
* ACL – MS Word AutoCorrect List,
* AFP – Advanced Function Presentation – IBc,
* AMI – Lotus Ami Pro,
* Amigaguide,
* ANS – American National Standards Institute (ANSI) text,
* ASC – ASCII text,
* AWW – Ability Write,
* CCF – Color Chat 1.0,
* CSV – ASCII text as comma-separated values, used in spreadsheets and database management systems,
* CWK – ClarisWorks-AppleWorks document,
* DBK – DocBook XML sub-format,
* DITA – Darwin Information Typing Architecture document,
* DOC – Microsoft Word document,
* DOCM – Microsoft Word macro-enabled document,
* DOCX – Office Open XML document,
* DOT – Microsoft Word document template,
* DOTX – Office Open XML text document template,
* DWD – DavkaWriter Heb/Eng word processor file,
* EGT – EGT Universal Document,
* EPUB – EPUB open standard for e-books,
* EZW – Reagency Systems easyOFFER document[6],
* FDX – Final Draft,
* FTM – Fielded Text Meta,
* FTX – Fielded Text (Declared),
* GDOC – Google Drive Document,
* HTML – HyperText Markup Language (.html, .htm),
* HWP – Haansoft (Hancom) Hangul Word Processor document,
* HWPML – Haansoft (Hancom) Hangul Word Processor Markup Language document,
* LOG – Text log file,
* LWP – Lotus Word Pro,
* MBP – metadata for Mobipocket documents,
* MD – Markdown text document,
* ME – Plain text document normally preceded by the word "READ" (READ.ME),
* MCW – Microsoft Word for Macintosh (versions 4.0–5.1),
* Mobi – Mobipocket documents,
* NB – Mathematica Notebook,
* nb – Nota Bene Document (Academic Writing Software),
* NBP – Mathematica Player Notebook,
* NEIS – 학교생활기록부 작성 프로그램 (Student Record Writing Program) Document,
* NT – N-Triples RDF container (.nt),
* NQ – N-Quads RDF container (.nq),
* ODM – OpenDocument master document,
* ODOC – Synology Drive Office Document,
* ODT – OpenDocument text document,
* OSHEET – Synology Drive Office Spreadsheet,
* OTT – OpenDocument text document template,
* OMM – OmmWriter text document,
* PAGES – Apple Pages document,
* PAP – Papyrus word processor document,
* PDAX – Portable Document Archive (PDA) document index file,
* PDF – Portable Document Format,
* QUOX – Question Object File Format for Quobject Designer or Quobject Explorer,
* Radix-64,
* RTF – Rich Text document,
* RPT – Crystal Reports,
* SDW – StarWriter text document, used in earlier versions of StarOffice,
* SE – Shuttle Document,
* STW – OpenOffice.org XML (obsolete) text document template,
* Sxw – OpenOffice.org XML (obsolete) text document,
* TeX – TeX,
* INFO – Texinfo,
* Troff,
* TXT – ASCII or Unicode plain text file,
* UOF – Uniform Office Format,
* UOML – Unique Object Markup Language,
* VIA – Revoware VIA Document Project File,
* WPD – WordPerfect document,
* WPS – Microsoft Works document,
* WPT – Microsoft Works document template,
* WRD – WordIt! document,
* WRF – ThinkFree Write,
* WRI – Microsoft Write document,
* XHTML (xhtml, xht) – eXtensible HyperText Markup Language,
* XML – eXtensible Markup Language,
* XPS – Open XML Paper Specification,
[{2021-01-04} https://en.wikipedia.org/wiki/List_of_file_formats#Document]

name::
* McsEngl.TdocLago.specific,

TdocLago.Hitp (link)

TdocLago.PDF

description::
"Portable Document Format (PDF) is a file format developed by Adobe in 1993 to present documents, including text formatting and images, in a manner independent of application software, hardware, and operating systems.[2][3] Based on the PostScript language, each PDF file encapsulates a complete description of a fixed-layout flat document, including the text, fonts, vector graphics, raster images and other information needed to display it.
PDF was standardized as ISO 32000 in 2008, and no longer requires any royalties for its implementation.[4]
PDF files may contain a variety of content besides flat text and graphics including logical structuring elements, interactive elements such as annotations and form-fields, layers, rich media (including video content), and three-dimensional objects using U3D or PRC, and various other data formats. The PDF specification also provides for encryption and digital signatures, file attachments, and metadata to enable workflows requiring these features."
[{2021-01-04} https://en.wikipedia.org/wiki/PDF]

name::
* McsEngl.PDF!=portable-document-format,
* McsEngl.TdocLago.PDF!⇒lagDpdf,
* McsEngl.lagDpdf,
* McsEngl.portable-document-format!⇒lagDpdf,

TdocLago.markup

description::
· a-markup-language to map text-documents.

name::
* McsEngl.TdocLago.markup!⇒TdocLagoMrkp,
* McsEngl.TdocLagoMrkp,

TdocLagoMrkp.SPECIFIC

description::
* lagHitp,
* lagHtml,
* lagXmlg,

name::
* McsEngl.TdocLagoMrkp.specific,

TdocLago.Html (link)

CmprLago.markup-language

description::
· a-markup-language places codes in the-input-doc and the-machine processes the-doc the-way have-instructed.

name::
* McsEngl.lagMrkp,
* McsEngl.CmprLago.011-markup-language!⇒lagMrkp,
* McsEngl.CmprLago.markup-language!⇒lagMrkp,
* McsEngl.markup-language!⇒lagMrkp,

descriptionLong::
"In computer text processing, a markup language is a system for annotating a document in a way that is syntactically distinguishable from the text,[1] meaning when the document is processed for display, the markup language is not shown, and is only used to format the text.[2] The idea and terminology evolved from the "marking up" of paper manuscripts (i.e., the revision instructions by editors), which is traditionally written with a red pen or blue pencil on authors' manuscripts.[3] Such "markup" typically includes both content corrections (such as spelling, punctuation, or movement of content), and also typographic instructions, such as to make a heading larger or boldface.
In digital media, this "blue pencil instruction text" was replaced by tags which ideally indicate what the parts of the document are, rather than details of how they might be shown on some display. This lets authors avoid formatting every instance of the same kind of thing redundantly (and possibly inconsistently). It also avoids the specification of fonts and dimensions which may not apply to many users (such as those with different-size displays, impaired vision and screen-reading software).
Early markup systems typically included typesetting instructions, as troff, TeX and LaTeX do, while Scribe and most modern markup systems name components, and later process those names to apply formatting or other processing, as in the case of XML.
Some markup languages, such as the widely used HTML, have pre-defined presentation semantics—meaning that their specification prescribes some aspects of how to present the structured data on particular media. HTML, like DocBook, Open eBook, JATS and countless others, is a specific application of the markup meta-languages SGML and XML. That is, SGML and XML enable users to specify particular schemas, which determine just what elements, attributes, and other features are permitted, and where.
One extremely important characteristic of most markup languages is that they allow mixing markup directly into text streams. This happens all the time in documents: A few words in a sentence must be emphasized, or identified as a proper name, defined term, or other special item. This is quite different structurally from traditional databases, where it is by definition impossible to have data that is (for example) within a record, but not within any field. Likewise, markup for natural language texts must maintain ordering: it would not suffice to make each paragraph of a book into a "paragraph" record, where those records do not maintain order."
[{2021-01-04} https://en.wikipedia.org/wiki/Markup_language]

info-resource of lagMrkp

description::
* https://en.wikipedia.org/wiki/List_of_document_markup_languages,
* https://en.wikipedia.org/wiki/Comparison_of_document-markup_languages,

name::
* McsEngl.lagMrkp'Infrsc,

lagMrkp.SPECIFIC

description::
* text-document-lagMrkp,
* concept-lagMrkp,

name::
* McsEngl.lagMrkp.specific,

CmprLago.file-format-010

description::
· file-format is a-computer-language that is-used to store info in computers.

name::
* McsEngl.file-format!⇒lagFile,
* McsEngl.CmprLago.file-format!⇒lagFile,
* McsEngl.CmprLago.010-file-format!⇒lagFile,
* McsEngl.lagFile,

descriptionLong::
"A file format is a standard way that information is encoded for storage in a computer file. It specifies how bits are used to encode information in a digital storage medium. File formats may be either proprietary or free and may be either unpublished or open.
Some file formats are designed for very particular types of data: PNG files, for example, store bitmapped images using lossless data compression. Other file formats, however, are designed for storage of several different types of data: the Ogg format can act as a container for different types of multimedia including any combination of audio and video, with or without text (such as subtitles), and metadata. A text file can contain any stream of characters, including possible control characters, and is encoded in one of various character encoding schemes. Some file formats, such as HTML, scalable vector graphics, and the source code of computer software are text files with defined syntaxes that allow them to be used for specific purposes."
[{2021-01-04} https://en.wikipedia.org/wiki/File_format]

input-info of lagFile

description::
· text, audio, image input information.

name::
* McsEngl.lagFile'input-info,

output-info of lagFile

description::
· the-encoded info used by the-machine.

name::
* McsEngl.Cmprdoc!⇒docCmpr,
* McsEngl.docCmpr,
* McsEngl.docCmpr!=computer-document,
* McsEngl.computer-document!⇒docCmpr,
* McsEngl.computer-file!⇒docCmpr,
* McsEngl.docComputer!⇒docCmpr,
* McsEngl.lagFile'output!⇒docCmpr,

docCmpr.file

description::
· computer-file is a-computer-document stored in storage with a-name.
· not all computer-documents are-stored, eg a-dynamic Htmldoc.

name::
* McsEngl.Cmprfile,
* McsEngl.Cmprfile!=computer-file,
* McsEngl.computer-file!⇒Cmprfile,
* McsEngl.docCmpr.file!⇒Cmprfile,
* McsEngl.file-of-computer!⇒Cmprfile,

extention of Cmprfile

description::
· the-extention of its name that shows the-format.

name::
* McsEngl.Cmprfile'extention,

renaming of Cmprfile

description::
* batch file renaming Windows10:
· open terminal.
· go to directory.
· > ren IMG_2022*.jpg 2022*.jpg
· this method has limits (eg sets '2022' two times in new name).

* second method:
· download "https://www.advancedrenamer.com/"
· add method "replace" old new text.
· add directory.
· run "start batch".

name::
* McsEngl.Cmprfile'renaming,

docCmpr.character

description::
"character vs binary computer-file:
"Character" and "binary" computer files are two distinct types of computer data representations, and they serve different purposes:

1. **Character Files**:
- **Character files**, also known as text files, store data in a human-readable format. Each character in the file is typically represented using a character encoding, such as ASCII or UTF-8, which assigns numerical values to characters. These files contain textual information and often include line breaks and special characters (e.g., letters, numbers, punctuation, and control characters).

- **Use Case**: Character files are commonly used for storing documents, source code, configuration files, and other text-based data. They are easily human-readable and editable with text editors.

- **Examples**: .txt, .html, .xml, .csv, .json files.

2. **Binary Files**:
- **Binary files** contain data in a format that is not intended for direct human interpretation. Instead of representing characters, they store raw binary data, which can include numbers, images, audio, video, executables, and more. These files do not use character encoding and may contain non-textual information.

- **Use Case**: Binary files are used for a wide range of applications, including multimedia, software, databases, and any situation where data is not naturally expressed in plain text.

- **Examples**: .jpg, .mp3, .exe, .dat files.

**Key Differences**:
- **Content Representation**: Character files represent data as characters and text, while binary files store data in a raw binary format.

- **Human Readability**: Character files are human-readable, making them suitable for viewing and editing with text editors. Binary files are not designed for direct human consumption.

- **Character Encoding**: Character files rely on character encoding to represent characters, while binary files do not use character encoding.

- **Use Cases**: Character files are commonly used for documents, source code, and configuration, while binary files are used for multimedia, software, and non-textual data.

- **Editing**: Character files are easily edited using text editors, while binary files require specialized tools and knowledge to manipulate.

In summary, the choice between character and binary files depends on the type of data being stored. Character files are ideal for textual data, and binary files are used when data needs to be represented in its raw, non-textual form, as in multimedia, executables, and various data structures."
[{2023-10-21 retrieved} https://chat.openai.com/c/1ab09bbc-0afb-443c-addc-45a932bc3825]

name::
* McsEngl.docCmpr.character,
* McsEngl.character-computer-file,

docCmpr.binary

description::
·

name::
* McsEngl.docCmpr.binary,
* McsEngl.binary-computer-file,

lagFile.ODF

description::
"The Open Document Format for Office Applications (ODF), also known as OpenDocument, is a ZIP-compressed[6] XML-based file format for spreadsheets, charts, presentations and word processing documents. It was developed with the aim of providing an open, XML-based file format specification for office applications.[7] It is also the default format for documents in typical Linux distributions.
The standard was developed by a technical committee in the Organization for the Advancement of Structured Information Standards (OASIS) consortium.[8] It was based on the Sun Microsystems specification for OpenOffice.org XML, the default format for OpenOffice.org and LibreOffice. It was originally developed for StarOffice "to provide an open standard for office documents."[9]
In addition to being an OASIS standard, it was published as an ISO/IEC international standard ISO/IEC 26300 – Open Document Format for Office Applications (OpenDocument).[2][3][4][5][10][11] The current version is 1.3.[12]"
[{2021-01-04} https://en.wikipedia.org/wiki/OpenDocument]

name::
* McsEngl.ODF!=open-document-format-for-office-applications,
* McsEngl.OpenDocument!⇒lagOdfo,
* McsEngl.lagFile.ODF!⇒lagOdfo,
* McsEngl.open-document-format-for-office-applications!⇒lagOdfo,

lagFile.OOXML

description::
"Office Open XML (also informally known as OOXML)[3] is a zipped, XML-based file format developed by Microsoft for representing spreadsheets, charts, presentations and word processing documents. The format was initially standardized by Ecma (as ECMA-376), and by the ISO and IEC (as ISO/IEC 29500) in later versions.
Microsoft Office 2010 provides read support for ECMA-376, read/write support for ISO/IEC 29500 Transitional, and read support for ISO/IEC 29500 Strict.[4] Microsoft Office 2013 and Microsoft Office 2016 additionally support both reading and writing of ISO/IEC 29500 Strict.[5] While Office 2013 and onward have full read/write support for ISO/IEC 29500 Strict, Microsoft has not yet implemented the strict non-transitional, or original standard, as the default file format yet due to remaining interoperability concerns.[6]"

name::
* McsEngl.OOXML!=office-open-Xml,
* McsEngl.lagFile.OOXML!⇒lagOoxml,
* McsEngl.office-open-Xml!⇒lagOoxml,

overview of CmprLago

01_computer of CmprLago

tool of CmprLago

02_input of CmprLago

03_output of CmprLago

node of CmprCode

code of CmprCode

syntax-tree of CmprCode

unit of CmprCode

semantic-unit of CmprCode

data-structure of CmprCode

static-analysis of CmprCode

relation-to-AI of static-analysis

04_method of CmprLago

06_human of CmprLago

07_organization of CmprLago

info-resource of CmprLago

documentation of CmprLago

specification of CmprLago

DOING of CmprLago

coding of CmprLago

evoluting of CmprLago

GENERIC of CmprLago

CmprLago.SPECIFIC

CmprLago.spec-div.output-function

CmprLago.programing (link)

CmprLago.programingNo (lagCpgmNo)

lagCpgmNo.SPECIFIC

CmprLago.programingBoth (lagCpgmBo)

CmprLago.data (representation and processing)

lagCdat.SPECIFIC

CmprLago.logo--knowledge-language (link)

CmprLago.concept--knowledge-language (link)

CmprLago.binary-info (lagBnr)

input of lagBnr

output of lagBnr

binary-info of lagBnr

output'unit of lagBnr

output'word of lagBnr

word.byte of lagBnr

output'Sunt of lagBnr

CmprLago.binaryNo (lagChar)