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 > <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> < <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 > <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> < <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> < <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 > <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> < <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 > <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> < <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> < <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 <function> but allow the insertion of 913 custom attributes inside the <function> 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— 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> </p> <p> </p> <p> </p> <p> </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.