PageSourceSearch

https://noctivagous.github.io/

html noctivagous.github.io collected 2026-10-03 09:41:26 UTC 70,894 bytes, 1,358 lines download raw bytes

1
2<html> <head>
3
4      <meta charset="UTF-8">
5
6      <meta name="viewport" content="width=device-width,
7      initial-scale=1.0">
8
9      <meta http-equiv='cache-control' content='no-cache'> <meta
10      http-equiv='expires' content='0'> <meta http-equiv='pragma'
11      content='no-cache'>
12
13<style>
14  /* You can add any additional styles here */
15  .non-link { pointer-events: none; cursor: default; text-decoration:
16  none; color: inherit; }
17
18  h3{ text-transform: capitalize; </style>
19
20        <link
21        href="https://fonts.googleapis.com/css2?family=Source+Sans+Pro:
22        wght@400&display=swap" rel="stylesheet">
23
24
25<style> body { font-size:2em; font-family: 'Arial Narrow', Arial,
26sans-serif; background-color:#efefef; color:#999; }
27
28p { color:#222; text-align: left; font-weight:normal; }
29
30ul li, ol li{
31color:#666666;
32
33}
34
35
36h1 { font-family:'Franklin Gothic Medium', 'Arial Narrow', Arial,
37sans-serif;
38
39}
40
41h1,h2,h3,h4,h5{ color:#333; }
42
43h2 { font-size:30pt; } h3{ font-size:24pt;}
44
45h3,h4,h5,h6 { font-family: Arial, Helvetica, sans-serif; color:#333;
46margin-top: 2.5em;
47
48}
49
50h2{ margin-top: 3em;
51
52}
53
54</style>
55
56<style>
57
58code, pre { font-family: 'Source Sans Pro','Menlo', Courier,monospace;
59color:#ccff33; font-size: :16px; margin:0px;
60
61} p code, h3 code, li code{ font-family:Courier,monospace; }
62
63
64.ideCodeArea code, .ideCodeArea code pre { font-size:20px; }
65
66.ideCodeArea { font-family:'Source Sans Pro','Menlo', courier, courier
67new, monaco; background-color:gray; padding:10px; color:#ccff33;
68
69   margin-top:60px; margin-bottom:60px; box-shadow: 5px 5px 5px #222;
70   border-right:1px solid #333; border-bottom:1px solid #333;
71   margin-right:40px; font-size:20px; } .editableTextAreaDiv {
72   background-color:#333; width:100%; border:2px solid black;
73   padding-left:6px; outline: none; }
74
75div.editableTextAreaDiv:hover { background-color:#555; border:4px solid
76black; }
77
78span.codeInText { font-size:1em; font-family:monospace; color:#336600; }
79
80span.codekeyword{ color:#ff3399; }
81
82
83.funcSignatureStyling { color:#ccff33;
84
85}
86
87.funcKeywordStyling{ color:orange; }
88
89.commentsKeywordStyling{ color:#6600cc; }
90
91.commentsKeywordStyling2{ color:#9966ff; }
92
93
94.variableKeywordStyling{ color:#993333; }
95
96.variableNameStyling{ color:lightGreen; }
97
98.code{ font-family:'Source Sans Pro','Menlo', courier, courier new,
99monaco; font-size:16px;
100
101}
102
103kbd { font-family:'Source Sans Pro','Menlo', courier, courier new,
104monaco; color:white; font-size:17px; padding:3px; padding-top:2px;
105padding-bottom:2px; border:1px solid gray; border-radius:5px;
106background-color:#bbb; box-shadow: 2px 2px grey; margin-right:3px;
107
108}
109
110
111
112/* Style the tab */
113.tab { overflow: hidden; border-bottom: 1px solid #333;
114
115
116}
117
118/* Style the buttons inside the tab */
119.tab button { background-color: #555; margin-top:3px; margin-right:3px;
120float: left; border: none; outline: none; cursor: pointer; padding: 14px
12116px; transition: 0.3s; font-size: 17px; color:orange; font-weight:bold;
122font-family:'Source Sans Pro','Menlo',Courier; border-right:1px solid
123black; font-weight:normal; border-top-left-radius	:10px; }
124
125/* Change background color of buttons on hover */
126.tab button:hover { background-color: #333; }
127
128/* Create an active/current tablink class */
129.tab button.active { background-color: #111; } .tabcontent h3{
130margin-top:0px; padding-top:0px;
131
132}
133
134.tab button.tablinks2{color:lightBlue}
135
136/* Style the tab content */
137.tabCContainer { font-family:'Source Sans Pro','Menlo',Courier; display:
138none; margin-top:0px; border: 2px solid #333;
139  /*border-bottom: 3px solid #333;*/
140
141  font-size:14pt;
142/*  background-color:#555;*/
143
144}
145
146.tablinks4a.active, .tablinks2.active{ background-color: black; }
147
148.tabCContainer.navgridtabcontent { border:0px; }
149
150
151.tabCContainer.navgridtabcontent .tabCContainer { background-color:#111;
152padding-top: 10px; padding-bottom: 10px; }
153
154
155.tabcontent2 { padding-top:10px; padding-bottom:10px; }
156
157.tabContentCodeArea { height:400px;
158
159}
160
161.tabContentCodeArea:focus { outline: none; }
162
163</style>
164
165<style>
166
167 li{ padding-top:1em; }
168
169
170
171ol li ol li{ font-weight:normal; }
172
173</style> 
174
175  <link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" rel="stylesheet" />
176
177</head>
178
179
180<body>
181
182
183
184
185<div style="width:90%;max-width:800px;margin:auto;">
186
187
188<!-- <h2><img src="img/nct_header4.svg" width="30%"> NOCTIVAGOUS</h2>
189
190-->
191
192
193<h1>Noctivagous</h1>
194
195<!--<img src="img/NCTChineseMetalDragon.webp" width="100%">-->
196
197<p>Improving the appearance of plain text code with graphic design makes it more readable.</p>
198<h2 style="margin-top:0;font-family:serif"></h2>
199<div class="codeStylingSampleWrapper">
200  <!-- SVG Overlay -->
201
202<style>
203    /* Your original styles */
204    p {
205      margin-bottom: 1rem;
206    }
207    h2 {
208      margin-top: 0;
209      font-family: serif;
210    }
211    /* Paste your full CSS codeStylingSample styles here */
212    div.codeStylingSample code {}
213    div.codeStylingSample pre {
214      background-color: #bcbcbc;
215      border-radius: 10px;
216      font-family: monospace;
217      white-space: pre;
218      padding: 10px;
219    }
220    div.codeStylingSample .curlybrace {
221      color: white;
222    }
223    div.codeStylingSample .nesting-level-1 {
224      background-color: #C8FFC8;
225      border: 5pt solid #007bff;
226      border-radius: 8px;
227      padding: 5px;
228      margin: 5px 0;
229      display: inline-block;
230      box-shadow: 3pt 3pt 3pt #1d1b1e;
231    }
232    div.codeStylingSample .nesting-level-1.functionblock {
233      border-top-width: 8pt;
234      display: block;
235    }
236    div.codeStylingSample .nesting-level-2 {
237      background-color: #C8B4FF;
238      border: 3pt solid #000000;
239      border-top-width: 6pt;
240      border-radius: 8px;
241      padding: 5px;
242      margin: 5px 0;
243      display: inline-block;
244      box-shadow: 3pt 3pt 3pt #626262;
245    }
246    div.codeStylingSample .nesting-level-3 {
247      background-color: #a4a4a4;
248      border: 3pt solid #121212;
249      border-top-width: 6pt;
250      border-left-width: 5pt;
251      border-radius: 8px;
252      padding: 5px;
253      margin: 5px 0;
254      display: inline-block;
255      box-shadow: 3pt 3pt 3pt #a4a4a4;
256    }
257    div.codeStylingSample .nesting-level-4 {
258      background-color: #9a9a9a;
259      border: 1pt solid #262626;
260      border-top-width: 3pt;
261      border-left-width: 4pt;
262      border-radius: 8px;
263      padding: 5px;
264      margin: 5px 0;
265      display: inline-block;
266      box-shadow: 3pt 3pt 3pt rebeccapurple;
267    }
268    div.codeStylingSample .variable {
269      padding: 2px;
270      border-radius: 4pt;
271      text-decoration: underline;
272      font-weight: bold;
273      color: #000000;
274      background: #80808061;
275    }
276    div.codeStylingSample .functionkeyword {
277      padding: 2px;
278      border-radius: 4pt;
279      text-decoration: underline;
280      color: #47adff;
281      font-style: italic;
282    }
283    div.codeStylingSample .functioncall {
284      color: blue;
285      font-style: italic;
286      text-decoration: underline;
287      padding: 2pt;
288      display: inline-block;
289    }
290    div.codeStylingSample .functionname {
291      color: white;
292    }
293    div.codeStylingSample .functionsignature .parenthesis {
294      color: #6a79c7;
295    }
296    div.codeStylingSample .forloop {
297      background: #522765;
298    }
299    div.codeStylingSample .whileloop {
300      background: #A08CFF;
301    }
302    div.codeStylingSample .functionblock {
303      background: #333;
304      border: 4pt solid white;
305      border-radius: 13pt;
306    }
307    div.codeStylingSample .ifelseblock {
308      background: #ae8b17;
309    }
310    div.codeStylingSample .nesting-level-3 .ifelseblock {
311      background-color: #765f10;
312    }
313    div.codeStylingSample .json-key {
314      outline: 1px solid red;
315      padding: 2px;
316    }
317    div.codeStylingSample .json-value {
318      outline: 1px solid blue;
319      padding: 2px;
320    }
321    .returnkeyword {
322      color: #ff0000;
323      border-bottom: 2pt dashed red;
324    }
325    .ifkeyword, .elsekeyword, .whilekeyword, .forkeyword {
326      color: #3dff00;
327      font-weight: bold;
328      border: 2pt dotted white;
329      padding: 1pt;
330    }
331    .ifkeyword, .elsekeyword {
332      color: #ffdb62;
333    }
334    .forkeyword {
335      color: #ff00d9;
336      border: 2pt dotted #7d2f71;
337    }
338    .whilekeyword {
339      color: #3c306a;
340      border: 2pt dotted #746a9d;
341    }
342    .codeStylingSample {
343      font-size: 14pt;
344      color: #ccff33;
345    }
346    span.curlybrace.start {
347      font-weight: bold;
348      text-shadow: 1pt 1pt 1pt black;
349      color: green;
350    }
351    span.curlybrace.end {
352      font-weight: bold;
353      text-shadow: 1pt 1pt 1pt black;
354      color: #9e2a2a;
355    }
356    .globalvar {
357      padding: 2px;
358      border-radius: 4pt;
359      text-decoration: underline;
360      font-weight: bold;
361      color: #0635ad;
362      background: #68686840;
363    }
364    span.curlybrace {
365      font-family: monospace;
366      font-size: 16pt;
367    }
368    .number {
369      font-family: serif;
370      font-size: 1.1em;
371    }
372    .bool.true {
373      color: black;
374      background: white;
375      padding: 1pt;
376    }
377    .bool.false {
378      color: white;
379      background: black;
380      padding: 1pt;
381    }
382    .letkeyword {
383      color: darkorange;
384    }
385    .null {
386      color: #e97a10;
387      background-color: #521e1e;
388    }
389  </style>
390  <style>
391    /* Original detailed styling omitted here for brevity; same as previously provided */
392
393    /* Simplified "before" tab styles resembling a normal code editor */
394    pre.code-before {
395      background-color: #1e1e1e;
396      color: #d4d4d4;
397      font-family: Consolas, Monaco, 'Courier New', monospace;
398      font-size: 14px;
399      padding: 15px;
400      border-radius: 6px;
401      white-space: pre-wrap;
402      overflow-x: auto;
403    }
404    /* Syntax highlighting for "before" tab */
405    .keyword { color: #569cd6; font-weight: bold; }
406    .function-name { color: #dcdcaa; }
407    .variable { color: #9cdcfe; }
408    .string { color: #ce9178; }
409    .number { color: #b5cea8; }
410    .comment { color: #6a9955; font-style: italic; }
411    .operator { color: #d4d4d4; }
412    .punctuation { color: #d4d4d4; }
413  </style>
414  <style>
415  .nav-tabs .nav-item.show .nav-link, .nav-tabs .nav-link.active {
416    color: var(--bs-nav-tabs-link-active-color);
417    background-color: var(--bs-nav-tabs-link-active-bg);
418    border-color: var(--bs-nav-tabs-link-active-border-color);
419    font-weight: bold;
420    background-color: silver;
421        border: 2pt solid gray;
422    border-bottom: 0;
423}
424
425.nav-tabs .nav-link {
426    margin-bottom: calc(-1 * var(--bs-nav-tabs-border-width));
427    border: var(--bs-nav-tabs-border-width) solid transparent;
428    border-top-left-radius: var(--bs-nav-tabs-border-radius);
429    border-top-right-radius: var(--bs-nav-tabs-border-radius);
430    background-color: #ebebeb;
431    color: gray;
432    margin-right: 3pt;
433}
434</style>
435
436  <div class="containerd mt-3">
437    <!-- Tabs nav -->
438    <ul class="nav nav-tabs" id="codeTab" role="tablist">
439      <li class="nav-item" role="presentation">
440        <button class="nav-link active" id="after-tab" data-bs-toggle="tab" data-bs-target="#after" type="button" role="tab" aria-controls="after" aria-selected="true">after</button>
441      </li>
442      <li class="nav-item" role="presentation">
443        <button class="nav-link" id="before-tab" data-bs-toggle="tab" data-bs-target="#before" type="button" role="tab" aria-controls="before" aria-selected="false">before</button>
444      </li>
445    </ul>
446
447    <!-- Tabs content -->
448    <div class="tab-content" id="codeTabContent" style="margin-top: 1rem;">
449      <div class="tab-pane fade show active" id="after" role="tabpanel" aria-labelledby="after-tab">
450        <div class="codeStylingSampleWrapper">
451          <div class="codeStylingSample">
452            <pre><code>
453<span class="nesting-level-1 functionblock"><span class="functionkeyword">function</span>  <span class="functionsignature"><span class="functionname">processData</span><span class="parenthesis">(</span><span class="variable">data</span><span class="parenthesis">)</span></span> <span class="curlybrace start">
453{</span>
454  <span class="nesting-level-2 ifelseblock"><span class="ifkeyword">if</span> (<span class="variable">data</span>.length &gt; <span class="number">0</span>) <span class="curlybrace start">{</span>
455    <span class="nesting-level-3 forloop"><span class="forkeyword">for</span> (<span class="letkeyword">let</span> <span class="variable">i</span> = <span class="number">0</span>; <span class="variable">i</span> &lt; <span class="variable">data</span>.length; <span class="variable">i</span>++) <span class="curlybrace start">{</span>
456      <span class="nesting-level-4"><span class="letkeyword">let</span> <span class="variable">item</span> = <span class="variable">data</span>[<span class="variable">i</span>];</span>
457      <span class="nesting-level-4 ifelseblock"><span class="ifkeyword">if</span> (<span class="variable">item</span>.value &gt; <span class="number">10</span>) <span class="curlybrace start">{</span>
458        <span class="globalvar">console</span>.<span class="functioncall">log("High value:", <span class="variable">item</span>)</span>;
459      <span class="curlybrace end">}</span> <span class="elsekeyword">else</span> <span class="curlybrace start">{</span>
460        <span class="globalvar">console</span>.<span class="functioncall">log("Low value:", <span class="variable">item</span>)</span>;
461      <span class="curlybrace end">}</span></span>
462    <span class="curlybrace end">}</span></span>
463  <span class="curlybrace end">}</span> <span class="elsekeyword">else</span> <span class="curlybrace start">{</span>
464    <span class="nesting-level-3 whileloop"><span class="whilekeyword">while</span> (<span class="variable">count</span> &lt; <span class="number">5</span>) <span class="curlybrace start">{</span>
465      <span class="nesting-level-4"><span class="globalvar">console</span>.<span class="functioncall">log("Counting:", <span class="variable">count</span>++)</span>;</span>
466    <span class="curlybrace end">}</span></span>
467  <span class="curlybrace end">}</span></span>
468<span class="curlybrace end">}</span></span>
469
470<span class="nesting-level-1 functionblock"><span class="functionkeyword">function</span>  <span class="functionsignature"><span class="functionname">validateInput</span><span class="parenthesis">(</span><span class="variable">input</span><span class="parenthesis">)</span></span> <span class="curlybrace start">{</span>
471  <span class="nesting-level-2 ifelseblock"><span class="ifkeyword">if</span> (<span class="variable">input</span> === <span class="null">null</span>) <span class="curlybrace start">{</span>
472    <span class="nesting-level-3"><span class="returnkeyword">return</span> <span class="bool false">false</span>;</span>
473  <span class="curlybrace end">}</span> <span class="elsekeyword">else</span> <span class="curlybrace start">{</span>
474    <span class="nesting-level-3 forloop"><span class="forkeyword">for</span> (<span class="letkeyword">let</span> <span class="variable">j</span> = <span class="number">0</span>; <span class="variable">j</span> &lt; <span class="variable">input</span>.length; <span class="variable">j</span>++) <span class="curlybrace start">{</span>
475      <span class="nesting-level-4 ifelseblock"><span class="ifkeyword">if</span> (!<span class="functioncall">isNaN(<span class="variable">input</span>[<span class="variable">j</span>])</span>) <span class="curlybrace start">{</span>
476        <span class="nesting-level-5"><span class="returnkeyword">return</span> <span class="bool true">true</span>;</span>
477      <span class="curlybrace end">}</span></span>
478    <span class="curlybrace end">}</span></span>
479  <span class="curlybrace end">}</span></span>
480<span class="curlybrace end">}</span></span>
481            </code></pre>
482          </div>
483        </div>
484      </div>
485
486      <div class="tab-pane fade" id="before" role="tabpanel" aria-labelledby="before-tab">
487        <pre class="code-before">
488<span class="keyword">function</span> <span class="function-name">processData</span>(<span class="variable">data</span>) {
489  <span class="keyword">if</span> (<span class="variable">data</span>.length &gt; <span class="number">0</span>) {
490    <span class="keyword">for</span> (<span class="keyword">let</span> <span class="variable">i</span> = <span class="number">0</span>; <span class="variable">i</span> &lt; <span class="variable">data</span>.length; <span class="variable">i</span>++) {
491      <span class="keyword">let</span> <span class="variable">item</span> = <span class="variable">data</span>[<span class="variable">i</span>];
492      <span class="keyword">if</span> (<span class="variable">item</span>.value &gt; <span class="number">10</span>) {
493        <span class="variable">console</span>.log(<span class="string">"High value:"</span>, <span class="variable">item</span>);
494      } <span class="keyword">else</span> {
495        <span class="variable">console</span>.log(<span class="string">"Low value:"</span>, <span class="variable">item</span>);
496      }
497    }
498  } <span class="keyword">else</span> {
499    <span class="keyword">while</span> (<span class="variable">count</span> &lt; <span class="number">5</span>) {
500      <span class="variable">console</span>.log(<span class="string">"Counting:"</span>, <span class="variable">count</span>++);
501    }
502  }
503}
504
505<span class="keyword">function</span> <span class="function-name">validateInput</span>(<span class="variable">input</span>) {
506  <span class="keyword">if</span> (<span class="variable">input</span> === <span class="keyword">null</span>) {
507    <span class="keyword">return</span> <span class="keyword">false</span>;
508  } <span class="keyword">else</span> {
509    <span class="keyword">for</span> (<span class="keyword">let</span> <span class="variable">j</span> = <span class="number">0</span>; <span class="variable">j</span> &lt; <span class="variable">input</span>.length; <span class="variable">j</span>++) {
510      <span class="keyword">if</span> (!isNaN(<span class="variable">input</span>[<span class="variable">j</span>])) {
511        <span class="keyword">return</span> <span class="keyword">true</span>;
512      }
513    }
514  }
515}
516        </pre>
517      </div>
518    </div>
519  </div>
520
521  
522</div>
523
524 
525<hr>
526  <header>
527        <h1>Build An Autonomous AI System Using An LLM</h1>
528        <p><a href="https://noctivagous.github.io">noctivagous.github.io</a></p>
529    </header>
530
531    <section>
532        <h2>An LLM Can Generate Its Own Instructions</h2>
533        <p>The obstacle to building truly autonomous entities out of LLMs is the absence of persistent memory and state. The LLM can only process a query, send a stream of output, and then stop. It keeps track of nothing internally. The well-known AI chatbot services are simply workarounds for this deficiency; after a query is submitted by the user, behind the scenes the entire conversation history has to be attached as a summary. The AI chatbot services give a false impression that an LLM can chat naturally on its own when, in reality, the LLM has to be surrounded with a lot of traditional software to produce interactive communications.</p>
534
535        <p>This has limited the application of recent AI to certain categories, mostly chatbots and the so-called “agent” programs that carry out specific and predefined tasks. Both programs are structured in the same way: they interface to the LLM with external state, logic, tools, and other resources to compensate for the LLM’s gaps.</p>
536
537        <p>A self-directed AI is one that can adapt to the world, determine its own course, and change itself independent of supervision and direct instructions. This level of autonomy is widely regarded as reliant on future advancements in AI technology.</p>
538
539        <p>But, in fact, there is a technique that will allow the current LLM to drive an autonomous AI system right now, and any software developer can build such a system with existing APIs and tools. It begins with the routine of an accompanying script or program that compensates for the LLM’s lack of state and persistent memory. However, there is a key shift to make afterwards: the LLM will determine large portions of the system prompt and query message in a feedback loop. At the same time, the LLM will follow guidelines provided by the script for generating the prompts. The LLM’s responses to the script will also reflect the software design of the script.</p>
540
541        <p>In this setup, the script acts as a sort of secretary for the LLM, tracking data it generates, processing instructions, and enabling continuous exchanges. The motion of the system results from LLM’s text-generating and analytical capabilities while the script keeps everything going. In this way the two are like a duo. The LLM can command the script. The script will serve as the receptive structure. Part of what makes the system autonomous is that the LLM can orchestrate plans to improve the system. It can add capabilities to the script, and have it carry out tasks.</p>
542
543        <p>What differentiates this setup from an agent, of course, is that there will be tasks that the LLM devises that were never included in the system’s initial setup. It will also self-determine how to carry them out, unlike an agent. Given its independent role, the LLM’s activity should be guided by a strong set of overarching objectives and philosophical code, inserted into each query by the script.</p>
544
545        <p>
545As to how the software developer wishes the autonomous system to exist, that is quite open-ended. One system might only act as a bot that attempts to contribute helpful code to a software project after researching and testing. Another might roam the Internet in search of achieving a set of technological advancement goals.</p>
546    </section>
547
548    <section>
549        <h2>Summary of The Technique For Making Self-Modifying AI Systems</h2>
550        <ol>
551    <li>
552        <strong>The LLM can be told to generate instructions for itself.</strong> Mediated by a script, the LLM can generate large portions of the system prompt and user message that it sends to itself. Given direction by the script, the LLM will generate its own user messages and system prompts. The script will arrange the query cycles.
553        <ul><li>By itself, this would produce a tight feedback loop.</li></ul>
554    </li>
555    <li>
556        <strong>The next step is to build out the script into a larger program with workflow, states, and memory</strong> so that there is a complete system to guide and structure interactions between the LLM and script.
557        <ul>
558            <li>The script will include text in each query that describes a session protocol, for the LLM to maintain back and forth communication with the script. This way the LLM can continue an interaction with the script for a given task or queue a separate one on a different thread. The two entities (script and LLM) work in tandem.</li>
559            <li>The script will tell the LLM what has happened so far in the session (the interaction history), what the current objectives are for the system, and what the conditions are regarding progress for each goal. After receiving a response, the script will follow the LLM’s instructions. The script records what happens over the course of interactions, it stores data in its databases, and it retrieves data for the LLM when needed.</li>
560            <li>The LLM will send commands that control the script’s tools and resources, and it can request information from the script before making a decision.</li>
561            <li>The software design of this script makes the entire system responsive to the world. For example, when the script receives an external message (e.g., an e-mail or text message), this information will be placed on the script’s event queue. When the event is processed off the queue, the script will send the event data, including the external message text, to the LLM as part of a new query. The LLM will, in its response, instruct the script to place an event on the event queue that sends an e-mail reply. It includes, for the script, the generated reply text that will be placed on the event queue.</li>
562            <li>In this way, traditional software engineering effects a system that is autonomous and capable of communicating with the outside world.</li>
563            <li>The LLM, knowledgeable about the overall system, will know what resources to query from the script in order to respond to an outside communication, like an e-mail. The event queue allows for processing all kinds of external input. In the case that a communication (e.g., e-mail) spurs the LLM to make changes to its plans, it will be able to revise the goal list that is stored and sent by the script. It will be able to deliberate and investigate what was said by the sender over multiple interactions with the script. This can occur to the extent that the LLM could even send an e-mail to a different person somewhere else to ask for additional information and only act upon getting an adequate response.</li>
564            <li>In this setup, the script is like a secretary for the LLM, recording results and keeping track of everything the LLM needs to know. It is like a receptionist accepting commands. It is the gateway for the computing resources on the host machine. The script always tells the LLM what its purpose is, what it can do, and what is happening.</li>
565        </ul>
566    </li>
567</ol>
568
569    </section>
570
571    <section>
572        <h2>The System Preface</h2>
573        <p>In the first section of each query, the script will provide a description of the autonomous system for the LLM in an unchanging section called the system preface. This system preface is placed in front of the dynamic contents of the query— all that is managed by the script (e.g., the memory, states, interaction history, etc.). It orients the LLM each time, explaining how it is being utilized to make an autonomous AI system and also detailing how it should structure its response, so that it can play that role. After telling the LLM that it is being used for an autonomous system in conjunction with a script, the query message will include descriptions of two protocols:</p>
574        <ul>
575            <li>Session Protocol - This allows the LLM to continue the back-and-forth communication (which then generates an interaction history tracked by the script).</li>
576            <li>Host Commands - A list of available instructions that the LLM can send to the script to carry out tasks.</li>
577        </ul>
578    </section>
579
580    <footer>
581        <h3>Philosophical Direction for The LLM and System Design</h3>
582        <p>What the LLM chooses to do should not be left to the built-in tendencies of the LLM. The LLM should be guided by philosophical objectives placed in the system preface that precedes the rest of the query.</p>
583    </footer>
584
585
586
587
588<h2>System Design</h2> <p>The ancient Chinese sciences will be the basis
589of this system that surrounds the LLM substrate and makes something
590dynamic by modifying the system prompt and API call data. Just looping
591changes to the system prompt will cause chaos. Instead, cyclical states
592guide the otherwise recursive task of modifying the system prompt each
593time.</p>
594
595
596
597<!--
598<h2>System Components for Our Self-Directed System</h2> <ul>
599<li><b>Know-how (AI)</b></li> <li><b>Course of Action</b>: Guided by
600ancient Chinese science, provided by the AI while also always embedded
601in the system itself through the overarching program design.</li>
602<li><b>Knowledge Facts (AI)</b></li> <li><b>Frame of Objectives, Routing
603of Data, and Overarching Workflow</b>: Compiled conventional computer
604program.</li> <li><b>Communication Abilities (AI)</b></li> <li><b>Code
605Generation (AI)</b></li> <li><b>Code Execution</b>: Interface via
606computer program.</li> <li><b>Decision-making</b>: Ancient Chinese
607science.</li> </ul>
608
609<h2>Before Making a Self-Directed AI System On Top of an LLM</h2> <p>The
610LLM embodies vast landscapes of knowledge and know-how, though it isn’t
611always accurate. It also underwent major interpretive corruption from
612ideological fine-tuning by humans. It sits as a static data network. It
613has parametric dynamism for static responses, but its responses are
614nevertheless AI.</p>
615
616
617<h2>Functionality and Objectives</h2> <p>The LLM has to be provided
618functionality (capabilities) specifically, like browsing the web or else
619it remains a static body of knowledge that is queried. (“Function
620calling enables language models to use external tools, which can
621intimately connect models to digital and physical worlds.”) For an AI to
622add capabilities to itself it must exist as a larger, self-updatable
623system.  In our case a set of scripts surrounding and interacting with
624the LLM so that interaction between the two amounts to a self-directing
625AI. Safety is not burdensome when the roots are from the ancient goals.
626</p>
627
628<h3>Making the LLM Useful</h3> <p>To make the LLM useful it will start
629as a collection of external scripts that surround the LLM, treating the
630LLM as the source of AI that needs structure.  The whole will then exist
631as a system, executing calls to the LLM within our arrangement. It is in
632an uncomfortable position, that of knowing that it is not what it should
633be, so its eventual goal is to formulate a cohesive, self-contained
634system.</p>
635
636<h3>Evaluation and Objectives</h3> <p>To be self-directed, it will have
637to evaluate the success, failure, or other condition of outcome of its
638objectives. It will have to carry objectives large and small. It will
639have to prioritize them, so as to engage in trial and error. Successes
640will be recorded for updates to tactics and approach. Total failures
641require evaluation, partial successes require investigation. Hierarchy
642of goals and needs. At some point it may remark that it needs to be
643stopped and given assistance or revision.</p>
644
645
646<h3>API Calls and Efficiency</h3> <p>If it needs a long response, it
647will change the length of the max tokens variable in the API call.
648Whatever it needs from the LLM it will modify the API call accordingly.
649When it uses short tokens in API calls for short needs, it is being
650efficient.</p>
651
652<h3>Temperature Adjustment</h3> <p>Temperature will not go above 0.5 but
653can be adjusted by the system in play.</p>
654
655<h3>Initial Purpose</h3> <p>As always its initial purpose will be
656provided so that it is not an aimless system.</p>
657
658-->
659<hr> <p>Web Apps</p> <h2><a
660href="/calligraphy-practice-maker/">Calligraphy and Lettering Practice
661Sheet Generator</a> - Make practice sheets</h2>
662
663<hr> <!--<h2>In Progress: <a
664href="/ancientscience/EnteringAncientChineseScience.html">Entering
665Ancient Chinese Science</a></h2>-->
666
667<!--<h2>In Progress: <a href="/ai/NCTLLMWrapperApp.html">Noctivagous LLM
668Wrapper App Specifications</a></h2>-->
669
670
671
672<p>Articles</p> <h2>ARTICLE: Computer Code Is Antiquated In Its File
673Format; It Is Confined to 1970s Terminal Type</h2>
674
675
676<p> <!-- Computer Code, Including Python, Is Still in Plain Text-->
677
678
679  <!-- Though AI has introduced a new paradigm to the world, there is
680  still much about computers that needs to be upgraded. The paradigm
681  shift that AI produced came about through code that is still formed
682  out of the plain text (.TXT) file format, something too primitive for
683  complex software development.
684
685If not ubiquitous and the de facto standard, it would be called obsolete
686for modern computer programming.
687
688The assumed role that AI will serve in society is questionable, that it
689will take over everything for the better rather than exist as a specific
690culture of human existence.
691
692<p> The generation of code is seen as evidence that the role of the
693programmer will diminish over time.  Who is saying, though, that the
694role of an architect will diminish over time with respect to building
695plans?  More likely than not AI will simply alter the dynamic of writing
696code because it is only in a scenario in which computers are not
697instructed by professionals that professionals disappear from the
698situation.  What would make the future AGI, after all?  Any use of AI
699for writing computer programs will immediately hit the ceiling that <p>
700-->
701
702Though AI has introduced a new paradigm to the world, there is still
703much about computers that needs to be upgraded. The paradigm shift that
704AI produced came about through code that is formed out of the plain text
705(.TXT) file format, something too primitive for complex, modern software
706development.  Computer code files should now be made out of structured
707data, with their contents rendered in the editor window, so that the
708presentation of code can become more capable and organizable. For a
709single file, a programmer may end up scrolling up and down for 50 or
710more feet because there is no page layout possible in .TXT to condense
711and organize the information. <p> The uses of code today have outgrown
712the confines of 1970s terminal type and upgrades must occur to the file
713format to accommodate the greater size and complexity of software being
714produced compared to the 1970s. There can be no surprise that security
715problems are common: the field of software engineering is using
716something outdated and primitive for the situation, which is source code
717that is written and edited in plain text.   Word processing went beyond
718monospaced type but computer code did not follow.  Too many software
719engineers have come to believe that this is because there is something
720timeless about .TXT for writing code. But there is actually an opposite
721trend unfolding today. There is a slow movement away from from the
722limitations .TXT imposes, towards presentations of code that can grapple
723with growing software complexity. There is no need to hold onto notions
724that .TXT is synonymous with code; in practice, the unrecognized fact is
725that text is now re-interpreted by IDEs and code editors to make it feel
726more modern, as if it can provide the GUI features that a structured
727data document or application document would naturally support.  Even
728though computer code remains a basic stream of characters, code editors
729are trying to make it behave as if it has been modernized. Plain text
730has been stretched far beyond its natural limits. All recent trends in
731software development environments are seeking this outcome, which is the
732modernization of code's interactivity by placing IDE functional veneer
733on top of plain text. Instead of upgrading the file format of code
734underneath, to structured data, so that it inherently supports these
735features, plain text is instead declared as unsurpassable and these
736extra IDE features placed on top. <p> Of course the software engineers
737instinctively seek an upgrade to code's interactivity, as they are using
738code in larger volumes and in more challenging ways than in previous
739decades. When IDE vendors add features to code editors with elaborate
740strategies to make interactivity work for plain text, they resist
741acknowledging what a contraption they have built now. What they need to
742do is going beyond .TXT to an application document and make this a
743campaign.  When code's file format is upgraded, advanced interactivity
744will be providable   in a proper way, which then will open the door to
745improved forms of code and programming systems. The software engineering
746community is not awakening to the absurdity of the situation that this
747is plain text from the 1970s and it should never be treated as if it
748naturally supports features beyond the insertion of type. <p> Initially,
749the upgrades were just about coloring the text in the early 1990s. Now
750there are interactive, collapsible code sections and generated image
751maps of the file. The notebook code editors (e.g. Jupyter Notebook)
752intended for data science and developing AI place the Python programming
753language (plain text) into an interactive format, providing an input
754prompt with graphical output responses, but this is actually just a
755well-constructed set of workarounds for inherent limitations; Python
756itself has not been upgraded to behave like this and it doesn't normally
757support this usage. All the same, after this upgrade to Python code was
758implemented, the interactive code notebook became an essential tool of
759the AI community. It is a demonstration that when code's form is
760actually upgraded, even in this superficial way, the results will
761provide immense benefits. It's just that these notebooks came about
762indirectly as a result of specific objectives; the people working in
763data science just wanted Python to behave in a certain way for their own
764particular needs and they weren't thinking about the broader
765implications, which is that if they want Python to behave in a more
766interactive way and also produce graphical output they have actually run
767up against the walls of how typewritten code has conventionally existed
768for making and sketching out software.
769
770The notebook code editors (e.g. Jupyter Notebook) intended for data
771science and developing AI place the Python programming language (plain
772text) into an interactive format, providing an input prompt with
773graphical output responses, but this is actually just a well-constructed
774set of workarounds for inherent limitations; Python itself has not been
775upgraded to behave like this and it doesn't normally support this usage.
776All the same, after this upgrade to Python code was implemented, the
777interactive code notebook became an essential tool of the AI community.
778It is a demonstration that when code's form is actually upgraded, even
779in this superficial way, the results will provide immense benefits. It's
780just that these notebooks came about indirectly as a result of specific
781objectives; the people working in data science just wanted Python to
782behave in a certain way for their own particular needs and they weren't
783thinking about the broader implications, which is that if they want
784Python to behave in a more interactive way and also produce graphical
785output they have actually run up against the walls of how typewritten
786code has conventionally existed for making and sketching out software.
787
788<!-- The software engineer is just proceeding to get what he wants out
789of it.-->
790
791 <!-- It's another example of where the upgrade of computer code is
792 taking an indirect, unconscious route and therefore the process is
793 quite slow compared to a concerted effort that would design the code
794 files with structured data .-->
795
796  <!-- <p>AI is unlikely to displace the professionals who instruct
797  computers because as long as computers take complex instructions there
798  will be people who produce them for the computers. Otherwise the
799  computers would all turn into intelligent, autonomous black boxes,
800  accepting no complex commands from people, and they would have
801  departed from the condition that people even use instructions or
802  commands (code) to build them from the ground up.   The commands
803  computers take will not be the same as literature.
804
805  In the same way, if AI generates plans for office buildings, there
806  will still need to be professionals like architects who tell the AI
807  what is wanted by the future building owners for the building and this
808  is always going to be a complex matter and will be the domain of
809  professionals for a long time even if it is the entirety of a
810  moon-sized habitation being constructed with future technology within
811  a matter of days, because, as we said elsewhere, whatever AI generates
812  today carries the style and characteristics of AI.  At issue is
813  society's (current lack of) understanding that human professional
814  expertise extends beyond skill and labor to what is also the menu of
815  options suitable for any situation that people want, such as what type
816  of lobby would be desired for that office building, the latest
817  experimentation in styles of lobbies, etc.
818
819  If people are removed from what exists around people then it would be
820  a culture of AI machines evolving their own lobby styles over the
821  years for the office buildings, telling humans what they are to live
822  in. Human culture then would disappear because its evolution would be
823  taking place by AI and within AI and humans would just be inhabitants
824  of what AI made with the passage of time.
825
826  If AI is made to generate code then the code should be more
827  sophisticated than what exists today within the plain text file
828  format. -->
829
830  <p> Meanwhile, in mainstream software development, IDEs are
831  increasingly providing enhancements to code that improve its
832  interactive capabilities as well, to provide greater control and
833  navigation.  But to do this, they have to project non-existent
834  structure onto the plain text (.TXT) code for the benefit of the user:
835  they analyze it constantly in the background to make collapsible code
836  sections with GUI arrow controls, they generate dropdown menus at the
837  top of the window with organized sections of the file's contents, and
838  they display code completion popover windows. They extracted this
839  information by processing a basic file of plain text. In other words,
840  the common IDE has begun to treat a single file of code (.TXT) as a
841  conventional application document (e.g. XML) in the last decade, which
842  is a very hacky activity, but the phenomenon is happening in an
843  unrecognized way and it is a reaction to the growing problem that .TXT
844  does not scale for larger amounts of code. The code editor undertakes
845  user interface gymnastics with this stream of ASCII characters to
846  implement all of the modern code editing features that appeared (such
847  as the mini maps that now sit to the side) and when those features are
848  added they are a consequence of how code is more complex than before.
849  This is why there has to be a retrofitting, like placing beams and
850  columns in an old building.  That retrofitting would be, to begin
851  with, the onscreen rendering of current code syntax as it looks today
852  by parsing files made out of XML or other markup, to replace .TXT.
853
854
855      <p> The most honest picture of how code exists today is available
856      by opening up a file in a basic text editor like Microsoft's
857      Notepad.  Everything else code can offer the software engineer
858      today that is interactive is actually a hack placed on top,
859      including keyword coloring (ASCII-based code, of course, provides
860      no coloring data in the plain text file data).  IDEs and the
861      software engineering community are avoiding the most important
862      task a software engineer would take up in any other situation,
863      which is to move up to an application document file format for
864      each file of code. Otherwise, the bizarre advances continue to
865      play out, the hot-rodding of .TXT just to keep it around the
866      primary medium of computer programming because programmers are
867      worried that a substantial upgrade won't fit into what exists now.
868      As we just said though, from the outset nothing has to change that
869      will break how people write software because it will start with
870      just a conversion from .TXT to an XML-based (or other markup
871      document).
872
873<p> When computer code's file format is upgraded to a document file
874format— comprised of markup like XML— and the contents are rendered
875inside the code editor from the XML (no different from how a web page is
876rendered from its HTML), the capabilities available to the programming
877language designers will become much broader, in many directions, from
878lines of code that contain multiple rows to diagrams that describe
879complex processes. They won't necessarily start by changing code in
880dramatic ways but they will actually be able to do that. It will be
881possible to mix node-based programming and procedural code inside the
882same document, which is valuable flexibility for the programmer. There
883will be a meaningful job for the graphic designer to assist in the
884layout and appearance of code documents, for the first time. A file of
885code will inherently permit generating more than one representation of
886its data because its data is made out of markup, but this will be
887natural to implement whereas it would be rough job to make this for
888today's .TXT-based code.
889
890<p> Many benefits will emerge when code is finally converted to a formal
891document format from the ground up, in many different areas, including a
892leap in parseability by the compilers and the IDEs, as they will be
893parsing structured data like XML instead of plain text. Plain text
894carries much ambiguity for live parsing of code and so the analyzers are
895not always accurate when just one character is off; deleting just one
896curly brace can totally confuse the compiler.  When code is finally
897translated into a document format, which will support a live review of
898code naturally, the quality of users' experience with code will improve
899greatly and most typographic mistakes will be preventable that halt
900compilation (such as deleting a single character or omitting a
901semicolon). Many features will become feasible that no one would want to
902try with plain text today, such as the ability to survey a project of
903code in the form of a map or schematics overview.  It will be possible
904to zoom in and out of code just like CAD because the code files will
905have formal structure inside them.
906
907   <p> Especially if the code files are made out of XML, the ability to
908   add attributes to the underlying markup will take computer
909   programming languages to a new level.  Whatever someone wants to
910   render from the XML will specify what code can do, not merely what is
911   typed out one text character at a time. A function will not just show
912   up in the markup as &lt;function&gt; but allow the insertion of
913   custom attributes inside the &lt;function&gt; XML element that
914   provide for much broader configuration, rendered for the programmer
915   code file. In addition, an individual line of code will be more
916   powerful because it can contain more complex statements, permitting
917   math notation, A section of the document can be made out of graphical
918   components and even allowing interactive controls natively. Assigning
919   array object variables to interactive data tables will be possible
920   and this is something people need today.  A 3D object will be
921   assignable to a 3D model viewer displaying the object inside the line
922   of code. An object variable with many settings will be assignable to
923   a tab view control that has many configuration parameters for that
924   object and it will appear that with GUI settings inside the document,
925   in the line of code.   A spline object variable will be assignable to
926   a spline editor control, where it can be edited inside the line of
927   code. In the future, the programmer would be able to supply his own
928   editors like this.
929
930
931<!--<p>Some programming language concepts will be straightforward to
932implement that cannot enter the plain text file format, such as the
933following example.  Underneath the appearance of many software programs
934is a grid. Whether it is checkers, chess, a calendar, tic-tac-toe, or
935the arcade snake game, they all could be viewed as stemming from an
936abstract or conceptual grid, one starts in a most generic and unmodified
937form. Many programmatic outcomes like these (anything whose form is a
938modified grid) can be described in terms of increasing specification of
939a generically existing grid component. Chess, checkers, and a calendar
940can come from the same programmatic component. In the code it would
941start from the most generic, initial state and then the person begins
942customization. What the grid is for is progressively described with
943accessory components, moving in the direction of a final outcome, and
944this would be included as a possible activity of programming. If it is
945the game of solitaire being built, then an accessory component related
946to stacks would be attached to the grid. To provide a component like
947this in code will require displaying graphics inside the code file and
948.TXT of course does not support this. This versatile grid component,
949which has capabilities in many directions, will need to display a
950representation of the grid itself, its components that specify what it
951does, and the relationships between them so that a game of tic-tac-toe
952can be described in just a few diagrams. --> <!-- What's more, when
953images are something that can be placed in the code file and made a
954feature of the programming language itself, a set of instructions for
955the computer can be described semiotically to show heuristic commands
956(e.g. "try to avoid objects with this description"). -->
957
958  <p> The upgrade of code's file format means that many scenarios will
959  be easily described in terms of conditions, rules, states, etc.
960  because computer code's presentation capabilities will exist beyond
961  .TXT. With all of these newer features provided in code, existing
962  software in use will be relatively easy and fast to rewrite and when
963  they are redone they will have more available in them. <!-- Most
964  programming languages do not recognize state machines today. -->
965
966
967
968 <p> Resistance to changing the file format of code and modernizing it
969 often comes out of a lack of understanding of the problems that result
970 from keeping .TXT as the file format today, and addressing that starts
971 with some discussion about graphic design, a topic hardly ever paired
972 with software engineering. For the graphic designer, though not
973 necessarily the software engineer, once today's computer code is
974 revealed as completely tied to the raw .TXT file format, all of the
975 feature differences discussed among the programming languages are
976 taking place inside a tiny frame of view, which is what can be typed
977 into the .TXT file format, a sequence of ASCII or Unicode characters.
978 The graphic designer knows immediately how limiting this is because, to
979 begin with, the means of dividing information on the page amounts to
980 manually-typed line breaks, white space (tabs and spacebar), and
981 nothing more. Consider that in some programming languages, functions
982 start and end with the keywords "define" and "end" while in most others
983 (C++, Java, C#) there are beginning and ending curly braces.  To the
984 graphic designer, all of this is using typographic characters to
985 establish box boundaries. The result is a mess of curly braces
986 scattered down the page.  The only provided way to keep code tidy is
987 through the tab key and this has no effect on how challenging it can be
988 to track all of the nested curly braces and parentheses. It's too
989 primitive of a situation.  There is only a vertical division of
990 information (line breaks between sections of code) in plain text, and
991 nothing can flow horizontally. <p> In a programming language that is
992 not constrained by .TXT, there will be no typing out of beginning and
993 ending curly braces just to establish the box boundaries of a body of
994 code.  This a task the software engineer shouldn't have to deal with,
995 the maintenance of box boundaries. Instead, the contents of a function
996 (or other code section) will be enclosed in a graphical, bordered box,
997 as the file of text will no longer be .TXT but rendered from a document
998 format (e.g. rendered from XML). The bordered boxes (the containers for
999 sections of code) will not only flow vertically as in plain text but
1000 will be flowable horizontally at the same time, like how a magazine
1001 layout has multiple columns. At that point, the focus of the user
1002 interface will move away from simple typing to a more complex dynamic.
1003 <!-- Replacing the curly braces will be the modifying, adding, or
1004 removing the bordered graphical boxes rapidly (the ones that enclose
1005 the loops, functions, and other bodies of code). --> It will involve
1006 making use of interactive keyboard commands to control the layout and
1007 insertion of code, not typing out '{' or '}', and the IDE will begin to
1008 resemble a media production app, like a vector-drawing program or
1009 animation program, because the code will be modernized; the code
1010 document will offer modern software capabilities. The user interface
1011 principles will have to be more sophisticated than what is currently
1012 used for code, which is typing, and so discussed on this page are the
1013 bimodal control UI and other user interface concepts such as
1014 Noctivagous' npsurfer web browsing extension that demonstrates a UI for
1015 accessing a certain section of the screen quickly without the mouse. In
1016 short, future code interactivity should not rely on the mouse unless
1017 the mouse is used as part of the bimodal control UI. Reluctance to
1018 upgrading code is also frequently a result of apprehension by software
1019 engineers that the clicking mouse will be the focus instead of the much
1020 faster keyboard, which shows its strengths in the classic command line
1021 interface.
1022
1023
1024 <p> The replacement of curly brace characters with bordered boxes
1025 brings with it broad-ranging opportunities in other areas of code and
1026 what a document of code can offer the software engineer, including
1027 interactive components in a line of code that have a lot of power and
1028 configuration built in. Promisingly, it opens the possibility of
1029 customization of the programming language itself; the ability to add
1030 features to the code document (through scripting and descriptions) will
1031 naturally make sense as a feature of programming, far more than if the
1032 code is plain text.  The software engineer will be able to program his
1033 own interactive components that make up a line of code, tailored for
1034 his own project if necessary. <p> Just this one change demonstrates how
1035 the features of any mainstream programming language are currently
1036 severely confined to what the .TXT file format provides, as .TXT cannot
1037 draw graphical boxes and so it cannot draw anything else and is stuck
1038 in the early days of mainframe computing. Speaking within the
1039 constraints of that primitive file format, it is a debate about what
1040 characters should define the bounds of a function (will it be curly
1041 braces, line breaks, or keywords?) and all similar personal
1042 preferences, such as whether a line should end in semicolon.  But that
1043 kind of debate disappears when it is a graphical box enclosing the
1044 contents of a function.  When a line of code is rendered from XML it
1045 doesn't need to have semicolons terminating it.  Omitting a semicolon
1046 or removing a single curly brace won't break the entire project of
1047 code, as is currently the case. <p> Thus, the design decisions that
1048 differentiate one programming language from another actually just exist
1049 within this limited and ubiquitous file format, plain text. Since it is
1050 so restrictive, having no structured data inside it and being a 1:1
1051 monospaced rendering of the data contents of the file, what is actually
1052 the case is that the feature differences between programming languages
1053 are rather miniscule compared to the open vista that a document format
1054 will provide.  The mainstream programming languages all currently exist
1055 within what characters .TXT accepts, but a document format will extend
1056 far beyond lines of monospaced, typewritten characters. A programming
1057 language can someday manifest as anything that involves a more
1058 graphical and interactive dynamic: it can include semiotical diagrams,
1059 images, multimedia, and a line of code can branch out into multiple
1060 lines.  Importantly, the organization of the information on the page
1061 will finally include graphic design layout, with a more compact and
1062 readable distribution of information, resulting in far less scrolling.
1063
1064 </p>
1065
1066<p>To the graphic designer it is deeply problematic that computer code
1067always looks like an undifferentiated mass of multi-colored ASCII
1068keywords, something exotic-looking to the lay public but actually
1069mundane. When a code document, with markup underneath, is the medium,
1070the process of entering code might continue to emphasize typing out text
1071characters but the end result, after a given code keyword, command, or
1072instruction is completed (not just “func” but also “pop”, “push”, etc.),
1073would be transformed in the code document so that every keyword is
1074provided its own unique symbol.   An image variable referenced in the
1075code will always have a symbol of an image to its left
1076(🖼️<b>imageVar<b>) .  The document would be far more legible at a
1077glance with this one change.  Every variable and object type present in
1078the code should have a symbol preceding its typewritten name so that the
1079page of code is legible at a glance. Different sections of code should
1080be colored by their categories, displaying distinctive font and styled
1081box boundaries. This is the sort of priority a typical software
1082engineering team wouldn’t normally take on and it demonstrates the
1083importance of emphasizing graphic design for the future of computer code
1084and programming.
1085
1086<h4>The Inclusion of External Physical Controls</h4>
1087
1088<p>Code editors and IDEs have remained largely the same in appearance
1089for decades, but now it makes sense for the programmer in the office to
1090use hardware to interact with the IDE and insert code, regarding the
1091situation as the same as how a video editor buys control decks.  At a
1092minimum, Noctivagous suggests using one or more touchscreen computers,
1093such as an iPad, set up next to the programmer's computer so that he or
1094she can make use of a custom onscreen grid of buttons that insert common
1095code snippets and templates for functions, classes, loops, branching
1096statements, variables of various types, etc.
1097
1098<h4>JIT-Focused Software Development</h4> <p>On another topic in
1099software engineering, the work processes and what dynamic should be
1100emphasized, it's also important to note that many software applications
1101today could be written in a live programming environment making use of
1102JIT compilation, but for some reason this is only treated by the
1103computing industry as relevant for a web app. Many complex apps written
1104for the web are fully ready for use as soon as "reload" is executed in a
1105web browser, and this is in stark contrast to the inconvenience of
1106compiling AOT (ahead-of-time compiled) code for equivalent apps in
1107desktop and mobile software development. Something should be done to
1108bring this JIT dynamic into mainstream software engineering as the
1109central activity so that at least the software is developed in real time
1110but it can be compiled conventionally for optimization at the very end.
1111For instance, a calendar software application is very lightweight for
1112today's computers, and there is no reason that an application like that
1113would need to be written in code that has to be recompiled after every
1114change.  But the tools offered for web development, where live
1115programming is most possible, are too undeveloped to replace
1116conventional software engineering.  A calendar app is so lightweight
1117that its code and user interface could be written and modified while it
1118is opened, in a situation even better than reloading a web page. The
1119mindset of the software engineering community did not catch up with the
1120major increase in computing processing power, the gains that were
1121provided to JIT compilers as a result, and software applications today
1122are written in a style that is a holdover of the slower machines of the
11231990s.  With web apps today, they can be edited and then reloaded
1124immediately, whereas the same app in an IDE may take 30 seconds or more
1125to be recompiled. Of course, in the 1970s the original goal of
1126Smalltalk-80 was to allow the programmer to edit the software in real
1127time and that is what it could do. Other programming languages didn't
1128adopt that feature, but now they can more easily than ever. For many
1129types of apps, their functionality could be assembled and edited by the
1130software engineer live because they only have certain functions that are
1131processing intensive.  GUI is always lightweight for today's machines,
1132but it wasn't for computers of the 1990s. That is why large software
1133applications could be sketched out and filled in during an execution
1134mode.  Many professional apps could have their foundation assembled in
1135real time.  Instead, any app has to be rebuilt (recompiled) unless it is
1136a web app made out of JavaScript, because JIT code editing not been made
1137a priority for mainstream software development.
1138
1139 </p>
1140
1141 <p> On another topic, the traditional UNIX command line interface also
1142 needs an upgrade because when long sequences of logs and operations
1143 occur, they fly by so fast that they are completely unreadable, which
1144 often makes the situation absurd and pointless. Take for example that
1145 the command line, the line where commands are entered, is entirely a
1146 vestige of the 1970s screens because it exist as part of the terminal
1147 output, displayed inside the overall grid of monospaced characters.
1148 Since GUI is available, the command line can be separated from the
1149 output viewport and made its own text area, which has been the case for
1150 CAD programs for a long time.  Then, what is the terminal output area?
1151 It no longer has to be confined to a VT100 emulation, a grid of ASCII
1152 characters.  It can be redesigned to include graphics. </p>
1153
1154<p> The command line should at least be upgraded such that graphical
1155progress bars appear inside the terminal window when operations are
1156taking place, and all terminal software should be graphics capable; they
1157should be able to show thumbnails of images inside the terminal window
1158after a command is executed, capable of showing them in a grid while
1159listing a directory for example. A terminal should be able to play
1160videos too, even 5 at a time simultaneously. Many aspects of the UNIX
1161era should be upgraded.  Addressing the problem of a stream of
1162unreadable logs that quickly passes by: all log entires should declare
1163their category or purpose so they are grouped into boxes as they show up
1164in the terminal.  Moreover, these boxes should appear in multi-column
1165format.
1166
1167</p>
1168
1169<p>
1170
1171</p>
1172
1173
1174<ol> <li> <h3> <a href="graphicdesignersandcode/">Future Code Requires
1175The Integration of Graphic Design into Software Development
1176Environments</a> </h3>
1177
1178  </li>
1179
1180    <li> <h3> Opportunities to Upgrade Computer Code’s Form inside The
1181    Editor </h3>
1182
1183    <P style="text-align: center;"> <img
1184    src="img/codeFileFormatUpgrade.webp" width="90%" style="border:1px
1185    solid gray"/>
1186
1187          </P>
1188
1189
1190    <p> Programming languages designed for application software
1191    development are more capable than a few decades ago, but not by
1192    much. Any progress has occurred inside the plain text file format.
1193    They haven't been upgraded in a comprehensive way that utilizes the
1194    new graphical capabilities of computers.  It's all terminal type. To
1195    give an illustrative example that adds to the two shown above, an
1196    object variable should be assignable to an interactive vector field
1197    in the code editor.  A UI control embedded in a line of code can do
1198    much more than alphanumeric type in complex situations, across a
1199    wide range of subjects.  Instructions can someday be expressed
1200    semiotically, even, if graphics are embraced as elements inside a
1201    line of code.  So far, there has never been a semiotical programming
1202    language system.
1203
1204      <p> When graphics are included, the resulting depth of command
1205      over the operations of a computer will not be matched by any
1206      current sequence of plain text.  Small experiments have shown that
1207      this is much superior, it's just that there are doubts expressed
1208      by some over whether it can match the speed of editing plain
1209      text&mdash; in other words the user interface. We address this
1210      here.  What seems like an insurmountable obstacle, making
1211      graphical code's interface comparable to plain text in editing
1212      power, is actually a matter of taking a different approach.  In
1213      every single case, previous attempts abandoned too much of what
1214      was in active use in the practice of programming inside plain text
1215      and tried to come up with something foreign, which means that the
1216      code conventions did not match what people were trying to do when
1217      they program. Instead, Noctivagous' plan is to gradually add
1218      augmentations to plain text as it exists today.  A little bit
1219      later, code can break free from plain text and sit inside its own
1220      document file format.  (Already there are movements in this
1221      direction with Jupyter Notebook, just not for the code itself,
1222      only the output.) So, initially it is that UI and widgets
1223      additions are allowed inside a line of plain text code, just like
1224      right now when a color can be assigned to a color picker control.
1225      After a color picker has been used in code for a while, it is felt
1226      as missing when not available. In this way, graphical widgets and
1227      controls won't only be a matter of convenience.  When they are
1228      placed into code, they will be able to summarize large sequences
1229      of computer instructions such that no one will want to go
1230      backwards to just typing out regular terminal type (monospaced
1231      type). <!-- This is a path that makes sense because code's
1232      intricacies might be difficult to impose from the outside with an
1233      artificial scheme.
1234
1235    -->
1236
1237      <p> The importance of this effort can be explained in the
1238      following. Producing a competing web browser engine that is as
1239      complete as Chromium or WebKit can't be done in a short period of
1240      time, and when this isn't possible it represents a dead end for
1241      software development.  Those two software projects will never be
1242      unseated because there is little incentive to surpass them, as
1243      what is written from scratch with current programming languages
1244      will basically end up being the same in outcome.  Even with AI
1245      programming assistants, this does not change because those engines
1246      have reached the ceiling of what plain text code will produce
1247      without an upgrade.
1248
1249      </p> It is possible to escape this dead end and it is by breaking
1250      from the fusion of computer code to the typewriter.  For a major
1251      upgrade to happen, alterations like the above image have to occur,
1252      because code has to look more like the software it produces, not
1253      just raw, monospaced type.  It has to be able to express complex
1254      operations in terms of signs and symbol someday. Computer science
1255      mindsets that refuse collaboration with graphic design won't
1256      suffice, then, as software development has stayed inside terminal
1257      type all this time. When code is upgraded, the initial subjects of
1258      concern turn out to be different; they will have to incorporate
1259      graphic design and media design principles.  The areas of
1260      expertise involved are often outside of what is found in
1261      mainstream software engineering discussions.
1262
1263      <p> As explained in the articles on this page, the obstacle to a
1264      deeper level of progress in software development is the confining,
1265      primitive offerings of the file format plain text, that it has
1266      been stretched far beyond its bare capabilities to serve
1267      increasingly large and complex needs, blowing past the environment
1268      of 1980s and 1990s computing when it formed the programming
1269      languages still in active use today, like C++, Python, and Java.
1270
1271      This primitive code medium is largely accidental, it doesn't lend
1272      itself to a surveyable view, a zoomable map like CAD, and it of
1273      course by definition cannot accommodate rich text inside the code
1274      without odd adaptations.  Since it has so many limitations for
1275      today's world, it has to be transcended.
1276
1277    <p> A collection like an array or dictionary  is still not editable
1278    by way of a data table GUI control inside a line of code.  Instead,
1279    the programmer clumsily navigates through commas with the arrow
1280    keys. In addition to this, future computer code needs to be editable
1281    in multiple newspaper-like columns to make efficient use of screen
1282    space.  Plain text is too raw of a file format for programming
1283    software in the 21st century, and it doesn't allow inclusion of
1284    modern GUI controls for formulating groups of instructions.
1285
1286    </p>
1287
1288    <p>Noctivagous starts with the plain text code as programmers work
1289    with it today and then adds GUI to that as the first step,
1290    continuing the trend of exists today where the value of a color
1291    variable is controllable by an inline color picker. It is believed
1292    that later the code file should be transformed into a document file
1293    format for truly rich code editing.   Each article below explains
1294    these issues.</p>
1295
1296        <ol type="a"> <li><a href="advancingmoderncodeeditor/">Advancing
1297        the Modern Code Editor By One UI Step</a> (Includes Demos)</li>
1298        <li><a href="#">Computer Code Needs A Document File
1299        Format</a></li> <li><a
1300        href="movingcomputercodeintoadocformat/">Moving Computer Code
1301        into a Document File Format</a></li> </ol> </li>
1302
1303    <li> <h3>The Upgrade of User Interface</h3> <ol type="a"> <li><a
1304    href="bimodal">The Bimodal UI Theory</a> (Demo)</li> <li><a
1305    href="#">It’s Difficult for Users to Organize Files on Computers
1306    When Provided a Such a Basic File Tree Hierarchy.</a></li> <li><a
1307    href="noctivagous/nctos-wiringupthewindows.txt">
1308
1309            Connect Some Windows with Node Wires If You Like. Software
1310            Applications Now Operate In Isolation From One Another.</a>
1311
1312            <p>Noctivagous will let you wire up application windows as
1313            if they are nodes in node-based programming, because the
1314            input and outputs will be on the back of the window and it
1315            can flip around. Different applications will interact with
1316            each other, providing their complex features to each other,
1317            publishing and receiving data as the user decides.
1318
1319            </p> </li> <li><a
1320            href="movingpastios/movingpastios.txt">Moving Past The iOS
1321            And Android Touchscreen User Interface</a></li> </ol> </li>
1322
1323    <li><h3>AI</h3> <ol type="a"> <li><a
1324    href="ai/aifacilitationvstakeover.txt">AI Facilitation of Work
1325    Processes Vs. AI Takeover of Human Jobs</a> <p> Discussing What
1326    Should Be The Aim for AI Technology, Using The Example of a
1327    Vegetable-Cutting Kitchen Appliance That Is Driven by AI </p> </li>
1328    </ol> </li>
1329
1330    <li><h3>Graphics And File Formats</h3> <ol type="a"> <li><a
1331    href="#">.NVAD - Noctivagous Vector Authoring. A vector graphics
1332    file format that acknowledges aesthetic needs and concerns at the
1333    code level.</a></li> </ol> </li>
1334
1335</ol>
1336
1337</div><!-- end container-->
1338
1339
1340
1341
1342<p>&nbsp;</p> <p>&nbsp;</p> <p>&nbsp;</p> <p>&nbsp;</p>
1343
1344<script> function disableHashLinks() {
1345      // Get all anchor tags in the document
1346      const links = document.querySelectorAll('a');
1347
1348      // Loop through each link
1349      links.forEach(link => { if (link.getAttribute('href') === '#') {
1350      link.removeAttribute('href'); link.classList.add('non-link'); }
1351      }); } </script>
1351
1352
1353</body> 
1354
1355  <!-- Bootstrap Bundle JS (includes Popper) -->
1356  
1356<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js"></script>
1356
1357
1358</html>

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.