TSE: About the extremely powerful technique of programs writing programs

[knud van eeden]

 Q. TSE: About the extremely powerful technique of programs writing programs

===

Moral of the story: If you can not beat them join them.

===

The technique of 'writing' or 'printing' programs

 E.g.

 PowerShell

 .bat batch

 .sh batch 

 Python

 GraphViz

 Java

 Rust

 SQL

 LISP

 Prolog

 MarkDown

 C++

 C

 C#

 Visual Basic

 COBOL

 Fortran

 Algol

 R

 MathLab

 Maple

 Mathematica

 Assembler  

 Delphi

 Go

 JavaScript

 Haskell

 TypeScript

 PHP

 Perl

 JSP

 ...

and then compiling or interpreting it (using their compiler or

interpreter) is already around very many years, e.g. in the order of 85 years or more.

This computer programs writing programs technique is really very and extremely powerful

and used at least since around 1940 in the past century and later.

Also in TSE SAL programs this technique is of course used.

Starting from e.g. the times of

 Alan Turing

 Claude Shannon

 Edsger Wybe Dijkstra

 Konrad Zuse

 John von Neumann

 Donald Knuth

 the early computer science developers and computer science pioneers

 ...

And this technique is used extremely often in computer programs.

Also very frequently by me in TSE SAL thus.

You can as an extra advantage then e.g. via TSE SAL language programs pass extra parameters and or replace information and or add extra TSE SAL specific

information and specific as usual TSE SAL techniques to those created programs then.

For example create a batch file from TSE and compile and run it.

Here TSE SAL creating a Microsoft Windows .bat program and letting it be executed.

PROC Main()

 EditFile( "foobar.bat" )

 AddLine( "pause" )

 SaveAs( "foobar.bat" )

 Dos( "foobar" )

END

(e.g. from TSE SAL prog)E keywords to use in this (TSE SAL) programs writing (other computer language) programs

are

AddLine()

Format()

Dos()

...

with friendly greetings

Knud van Eeden

[knud van eeden]

And to especially mention:

 HTML

What one sees on the Internet is really full of the result of (other) programs that have written (other)

 HTML 

programs.

That technique is thus an extremely common practice.

[knud van eeden]

> 'computer language programs writing other computer language programs'

ChatGPT:

The concept you are referring to — computer programs that write other programs — is a core idea in metaprogramming. Here is a structured explanation, with examples across different languages and paradigms:

---

🔁 What Is It Called?

Metaprogramming

Writing programs that generate, analyze, or transform other programs — or even themselves.

---

🧠 Common Use Cases

Use Case	Example
Code generation	Generating boilerplate code in web frameworks
Compilers / transpilers	A C program that outputs machine code
Interpreters	Python interpreter written in C
DSLs (Domain-Specific Languages)	A templating language generating SQL or HTML
AI-generated code	LLMs (like ChatGPT) generating C++ from specs

---

💬 Examples

1. Python writing C code

with open("hello.c", "w") as f:
    f.write('#include <stdio.h>\nint main() {\n  printf("Hello from C!\\n");\n  return 0;\n}')

2. C program generating Python

#include <stdio.h>
int main() {
    FILE *fp = fopen("gen.py", "w");
    fprintf(fp, "print('Hello from generated Python')\n");
    fclose(fp);
    return 0;
}

3. Lisp generating Lisp (Homoiconicity)

(defmacro make-printer (msg)
  `(lambda () (print ,msg)))

(setq f (make-printer "Hello from macro"))
(funcall f)

4. Rust procedural macros (code that writes code at compile time)

// #[derive(Debug)] is a procedural macro
#[derive(Debug)]
struct Point { x: i32, y: i32 }

5. Template engines (e.g., Jinja2 in Python)

Used to generate HTML, SQL, config files, etc., programmatically.

---

⚙️ More Advanced

• Bootstrapping: A compiler written in the language it compiles (e.g., C compiler written in C).

• Quines: Programs that output their own source code.

• AI tools: GPT-4 writing JavaScript from natural language.

---

📚 Related Concepts

Concept	Description
Reflection	A program examining its own structure
Code synthesis	Automatic generation of correct-by-construction code
Transpilation	Translating code from one language to another (e.g., TypeScript → JavaScript)

---

[knud van eeden]

Here a simple tested and running example of a TSE program creating and

generating another TSE program, (so basically generating itself (source

code)) and running it dynamically on the fly.

 PROC Main()

  EditFile( "foobar.s" )

  AddLine( "PROC Main()" )

  AddLine( "Warn( 'hello world' )" )

  AddLine( "END" )

  SaveAs( "foobar.s" )

  Dos( "sc32.exe foobar.s" )

  ExecMacro( "foobar.mac" )

 END

[nkor...@gmail.com]

 

A bottom-line question, to me, seems to be: Why use one computer coding language over another??

Knud seems to focus on TSE to achieve some amazing things.

 

Python appears to be terrific for accomplishing quite a bit.

 

I remember hearing a computer “expert” say that virtually all computer languages are capable of producing the same results.

--

---
You received this message because you are subscribed to the Google Groups "SemWare TSE Pro text editor" group.
To unsubscribe from this group and stop receiving emails from it, send an email to semware+u...@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/semware/119563405.715526.1752846261419%40mail.yahoo.com.

[knud van eeden]

> A bottom-line question, to me, seems to be: Why use one computer coding language over another??

Because some computer languages have out of the box many more in-built possibilities or better properties

than other computer languages. Or some already available commands which make it easier to achieve what one wants.

Do it with one command only instead of hundreds of commands.

As an example for example from the artificial intelligence. You write some text (=prompt), which is basically

also some kind of computer language (that is a 'natural' language 'program' (e.g. English)). 

Then automatically that artificial intelligence 'natural language program' creates another program in another computer language, 

e.g. JavaScript, C, Java, ... you name it.

Many people would prefer that method over writing the output program itself because it is (sometimes) faster and

a shorter way and even much more sophisticated to achieve one's programming goal.

Of course this is open for debate if one would use such a method.

There are always protagonists and as always antagonists also here clearly.

Regarding PowerShell, that is thus a more sophisticated 'batch' language than Microsoft .bat, accessible directly from within TSE

out of the box. It has many powerful possibilities.

It includes the quite sophisticated PowerShell batch language, 

One can use the Microsoft .NET libraries (thus a subset of the programming language C#). 

And it runs on both Microsoft Windows and also Linux WSL.

So fetching many birds with one stone.

In my personal opinion amazing things can be done if one accepts combining TSE and PowerShell, but the final decision is of course

up to the principles of the individual.

At the end of the day it is the goal that counts then accepting almost all means.

One has to or is strongly advised to encapsulate PowerShell .ps1 program e.g. inside TSE source code for security reasons, for example

one can not just simply send single .ps1 programs around with the usual means, that is simply almost impossible in general, 

one will very quickly find out.

Also embedding source code of other computer programs inside TSE programs means only one and only one .s programs to handle.

Instead of 2 or more source code files (.s, .ps1, .c, .py, .java, ...) to send around. Thus much simpler in principle.

> Knud seems to focus on TSE to achieve some amazing things.

Yes, really surprised often about what it possible, especially if one accepts basically no limits.

Of course not everybody shares the same interests in what can be done (much more) in TSE, 

so not everybody can appreciate what is achieved in fields outside of their direct interest.

But it might be very interesting for some others.

The more there is possible, the better is (my) principle. Everything in TSE at the end of the day.

There are thus of course always protagonists and as always antagonists also here, that is very clear now.

> Python appears to be terrific for accomplishing quite a bitreally

Yes, Python is the computer language used very often in machine learning.

Because it has many necessary in-built libraries ready out of the box.

https://vm.tiktok.com/ZNdmeoy9a/

Python is currently the most used computer language in the world

https://www.tiobe.com/tiobe-index/

> I remember hearing a computer “expert” say that virtually all computer languages are capable of producing the same results.

That has maybe some truth in it. One could maybe get similar results at the end (for many things), but in one it will be a few

lines, while in the other one would need hundreds if not thousands of lines and extreme amounts of effort

and taking an extreme amount of time.

And certainly not everything in general can be done in one computer language versus the other in general,

simply because of its (insufficient for those purposes) defined design.

with friendly greetings

Knud van Eeden

To view this discussion visit https://groups.google.com/d/msgid/semware/078e01dbf82d%24c6773700%245365a500%24%40gmail.com.