0. Goals

Some goals:

☑ Change line termination from \r to \n

☑ Provide for fonts containing many thousands of glyphs

☑ Integrate Unicode (UTF8) Characters

☑ Execute a command on Shift-Enter

☑ Provide for batch processing

☐ Provide readline functionality like /~https://github.com/jart/bestline

☐ Introduce a primitive serial command loop

☐ Make 64-bit

☐ Introduce namespaces, e.g. FROM aarch64 IMPORT opcodes; FROM platform IMPORT HAL; etc

☐ Introduce IMPORT vs. USE for early vs. late binding and UNIQUE identifier for MODULE which says it may only be used, not imported

☐ Include a marker for PROCEDUREs assignable to procedure variables to ease module unloading

☐ Provide for independent instances of modules imported by another module (e.g. IMPORT M1 ~= M) preparatory for module replacement e.g. run-time specialization, introduce e.g. IMPORT OWN M for module with globals private to this import, introduce SUBMODULE for a module that may only be OWN

☐ Consider https://stevana.github.io/towards_zero-downtime_upgrades_of_stateful_systems.html

☐ Implement Replace(S, R: Module) in Modules.Mod allowing a source module to be swapped out for a replacement module in modules that import its instance when S and R are replacement compatible. Consider having dereferences of a module's own name refer to the previous instance of the module, converted to a trap at the end of the BEGIN section of the module.

☐ Introduce a convention of module self-unload at the end of a Module.command execution for appropriate modules (OXP.Compile, etc.)

☐ Consider the Memory Pool System Kit /~https://github.com/Ravenbrook/mps for GC.

☐ Generalize mouse messages into Pointer Events https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent

☐ Provide an Input Method Editor framework for keyboard input https://en.wikipedia.org/wiki/Input_method

☐ Incorporate resilient parsing as in https://matklad.github.io/2023/05/21/resilient-ll-parsing-tutorial.html

☐ Adopt web convention of mouse and mouse button behaviors for select, copy, paste (use mouse-over underlines for command identification)

☐ Assist screen readers and assisted navigation via deep integration of a regular and traversable directory structure also used for text-to-speech and speech-to-text

☐ Encourage consistent and comprehensive documentation for: 1) Core Interfaces 2) System Commands 3) File Formats 4) Devices 5) Library Functions 6) Core Calls 7) User Commands (see FreeBSD documentation structure)

☐ Support multiple cores with an Oberon loop on each core

☐ Consider pervasive sync objects as containers for a completions implemented as a DMA fence like https://www.khronos.org/opengl/wiki/Sync_Object

☐ Consider Transactional Composition of Non-Blocking Data Structures https://arxiv.org/pdf/2301.00996.pdf

☐ Consider Named Data Networking https://www.cs.princeton.edu/courses/archive/fall18/cos561/papers/NDN18.pdf

☐ structure parallel computation along the lines of "Rethinking Classical Concurrency Patterns" https://drive.google.com/file/d/1nPdvhB0PutEJzdCq5ms6UI58dp50fcAN/view

☐ Leverage VLists as in "Fast Functional Lists, Hash-Lists, Deques and Variable Length Arrays" ( https://infoscience.epfl.ch/record/52465/files/IC_TECH_REPORT_200244.pdf )

☐ Consider (Concurrent) Node Replication between sockets/cpus with Flat Combining between cores in a cpu as in nr (https://cs.brown.edu/~irina/papers/asplos2017-final.pdf) and NrOS (https://www.usenix.org/system/files/osdi21-bhardwaj.pdf) to synchronize key data structures across a non-uniform memory access (NUMA) system. Introduce a Nodes module allowing an Oberon loop per core, FC per loop in a node, CNR between nodes in a machine, distributed consensus over a cluster of machines.

☐ Consider Distributed Snapshots https://blog.fponzi.me/2024-05-30-distributed-snapshots.html

☐ Bind-mount Oberon loops as reified objects in a distributed network

☐ Consider realizing objects via paths as in class hierarchy of objects in a hierarchical file system (https://patents.google.com/patent/US5187786A/en) and NeWS (https://donhopkins.com/home/monterey86.pdf)

☐ Define distribution groups of Oberon loops for context of execution

☐ Dispatch commands to a distribution group via modified click or command prefix

☐ Implement map/reduce reactive events across the distributed file system

☐ consider porting s2n-tls /~https://github.com/aws/s2n-tls for compatible encrypted communications

☐ Port to other hardware architectures

☐ Support SOC heterogeneity of cores and physical memory map inconsistency between cores and a core-wake-chain model and messaging discipline

☐ Institute a discipline for persisting module state to storage driven by a module hierarchy sweep and provide for restoring the most recent state on system load

☐ Introduce a compose key (right-ctrl) and alternative keyboard mappings for Unicode grapheme cluster entry

☐ Adopt Pikchr https://pikchr.org/ and SVG

☐ Add TextAlignment and LineBreakStrategy to Text attributes like Font and Color

☐ Standardize argument parsing including a mode where inputs are hashes of file content

☐ Consider a 'with' or 'to' function in standardized modules presenting a regular interface to exported objects for fs like access.

☐ Perform ToUpper and ToLower using fast-case-conversion as in /~https://github.com/apankrat/notes

☐ Integrate icon fonts like https://fonts.google.com/icons

☐ Change graphic coordinates to floating point, take inspiration from cuis and morphic3

☐ Appropriate Stack & Tile windows from Haiku

☐ Provide a Stdio module including argparse functionality for argument parsing (with option for hashes of file content as input arguments as above), io redirection (stdin, stout, stderr), compound statement composition, and allowing TextFrames to serve as terminal sources/sinks/interfaces

☐ Incorporate bip buffers https://ferrous-systems.com/blog/lock-free-ring-buffer/ https://blog.adacore.com/from-rust-to-spark-formally-proven-bip-buffers

☐ Integrate into Texts.Mod and Files.Mod the stream implementation stdio module above based on Ritchie's Unix 8th Edition Streams for co-routine design, "Multiprocessor Streams for Plan9" for namespace design, and "RPC in the X-Kernel: Evaluating New Design Techniques" for protocol composition, learn from FreeBSD's Netgraph https://people.freebsd.org/~julian/netgraph.html or just steal Netgraph from FreeBSD

☐ On a colon-terminated command, place output inline in the source text after the command instead of in system log (like Jupyter notebooks). On tilde-terminated commands, place it in the log, on pipe and greater than signs redirect to background tasks and files respectively

☑ Introduce docstrings for Oberon (odoc) and generate documentation automatically

☐ Enhance warning and error logging, provide static analysis ('lint', 'gofmt'), adopt code review, continuous integration, performance counters + profiling, and module unit tests

☐ When color use generated color palates and procedural color selection for UI elements https://chris.de/posts/an-algorithm-to-generate-color-palettes/ https://shahriyarshahrabi.medium.com/procedural-color-algorithm-a37739f6dc1

☐ Turn the compiler into a compiler suite with alternate front-ends for other languages

☐ Automatically generate an "Integrated Language Report" for each front-end language from source-level comments via odoc

☐ Implement ECMA-55 Minimal Basic https://buraphakit.sourceforge.io/Learn_BASIC.pdf as alternate front-end demonstration

☐ In addition to the User and System pane introduce a Meta pane rising from the bottom of the screen and have bouncing the mouse off the bottom (or left) of the screen show and hide the Meta (or System) pane. Populate the Meta pane with a Modules (class-like) browser.

☐ Document the Polyglot Runtime Environment (PRE)

☐ Provide bits for aliased-reference (e.g. refcount) and shared-reference (e.g. not-thread-local) in pointers and object headers and adapt the compiler and garbage collector to use these bits.

☐ Implement safepoint checks in loops and calls to allow preemptive GC and thread scheduling, expose Read, Write, and LightweightLayoutLocks to coordinate shape changes in shared arrays other dynamic structures as in https://dl.acm.org/doi/pdf/10.1145/3276478

☐ Enable module sharing between Oberon instances by separating start-of-global-variables from start-of-code-and-signatures-and-strings, place module code-and-signatures-and-strings in an immutable heap, place the module global variable block in a mutable heap

☐ Place records shared between Oberon instances in an immutable heap, prepare cooperative garbage collection of the immutable heap

☐ Place stacks for Oberon instances in a mutable heap, Use CSP to enable Oberon instance communication

☐ Provide parallel GC with a thread-local nursery as in https://arxiv.org/pdf/2004.11663.pdf

☐ Integrate a debugging file system interface like acid to the Oberon loop for local and remote inspection of Oberon instances

☐ Appropriate Parameters, Eventspaces, Custodians, and Threads from MrEd and DrScheme to implement Oberon-on-Oberon https://www2.ccs.neu.edu/racket/pubs/icfp99-ffkf.pdf

☐ Integrate Users/Roles/Tags/Acts for rbac beyond posix permissions like https://tailscale.com/blog/rbac-like-it-was-meant-to-be/

☐ Generalize permissions: Given this person and this object, what can they do? Given this object and this action, who can do it? Given this person and this action, which objects can they act upon?

☐ Introduce a Data module in the Query package with datum tagging and hashed recognition of contents for system-wide data loss prevention, pervasively use the Data module in Integrated Oberon

☐ Use sortable UUIDs for time based data indexes https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format

☐ Provide for parallel and distributed joins of Query package data (http://www.systems.ethz.ch/projects/paralleljoins)

☐ Keep statistics about the distribution of data eg row counts, histograms of values in each column to enable estimating the size (cardinality) of intermediate results at each point of a plan of queries across the data, alternatively use query execution on samples to predict cardinality as in https://db.in.tum.de/~leis/papers/lookingglass.pdf, refer to https://scattered-thoughts.net/writing/why-query-planning-for-streaming-systems-is-hard for streaming

☐ Consider EventReduce /~https://github.com/pubkey/event-reduce for streaming optimization

☐ Implement an asynchronous Audit system that applies rules to operations on data resulting in dispatchable events on matches

☐ use SegCache to cache all the things https://www.usenix.org/system/files/nsdi21-yang.pdf

☐ Provide for minimal Oberon instances (e.g. threads or processes) being attached via CSP to texts using readers and writers

☐ Prepare a distribution on the lines of https://venam.nixers.net/blog/unix/2020/03/29/distro-pkgs.html

☐ Give Oberon a CONTINUATION type with PAU (pause) and PLY (play) built-in functions to enable algorithmic effects

☐ Give Oberon a UNIFICATION OF type to enable dataflow and logic variables as in OZ and MOZART

☐ Give Oberon-2 Go style Interfaces a.k.a. Rust's 'dynamic traits', extend the concept to value witness tables as in Swift

☐ Give Oberon-i (Oberon-2 plus INTERFACE plus CONTINUATION) a REQUIRE reserved word which allows referring to another module by name without depending on the type signature of the module (for INTERFACE matching)... alternatively, stay with Oberon-1 and provide a new TRAP for filling an interface struct from a pointer to another struct add convenience keywords THIS (for a pointer to the structure a procedure field resides in) and THAT (for a pointers to the structure being interfaced to be resolved at TRAP time)

☐ Allow modules as well as record pointers to satisfy interfaces

☐ Implement Weiher & Hirschfeld's Storage Combinators as an interface for operating on stores of files ('directories'), make FileDir a storage combinator

☐ Introduce keyword 'dyn' for dynamically scoped variable reference, enabling event handling like the Common Lisp Condition System

☐ Optimize Oberon-2i via single-pass compiling with Delayed Code Generation like https://www.piumarta.com/doc/dcg-1992.pdf

☐ Support integrated bench-marking, unit-testing, and fuzzing like the Go ecosystem

☐ Give Oberon-2i Maps a.k.a. Dictionaries based on Hash Array Mapped Tries with variable-sized hashes

☐ Reify modules as records in the heap with procedures as type-bound to the module record

☐ Sketch out a Meta-Object Protocol on top of reified modules (as records with type-bound procedures)

☐ Incorporate something like Generic-CL /~https://github.com/alex-gutev/generic-cl in the object protocol

☐ Consider reifying Oberon messages as MQTT for multicore and distributed operation conflated with Smalltalk / CLOS messages

☐ Provide boilerplate demonstrating how to make a service *Discoverable *Addressable *Trustworthy and truthful *Self-describing in semantics and syntax *Inter-operable and governed by global standards *Secure and governed by a global access control

☐ Implement new kernel generation as suspend with substitutions to same or alternate location; implement boot as resume

☐ Incorporate LIL http://runtimeterror.com/tech/lil/ as a scripting language making all Oberon commands available as scripting commands and vice versa but perhaps with T-Expressions as in Choc http://service.scs.carleton.ca/sites/default/files/thesis_repository/TH_mcs_2010_macinnis.pdf or Oh /~https://github.com/michaelmacinnis/oh

☐ implement a JIT much like YETI for LIL and other interpreters https://www.researchgate.net/publication/221137811_YETI_A_graduallY_extensible_trace_interpreter

☐ Introduce to TextFrames the capability for structured editing of text like TeXmacs https://www.texmacs.org/Data/TeXmacs.pdf perhaps informed by https://star-tex.org/

☐ Build UIs like Visual TCL http://vtcl.sourceforge.net and TclSqueak http://www.xdobry.de/tclsqueak/

☐ Adopt uni-width typefaces https://uxdesign.cc/uniwidth-typefaces-for-interface-design-b6e8078dc0f7 for system default text & use color and weight for reactive feedback of commands & state

☐ incorporate Archy https://en.wikipedia.org/wiki/Archy UI elements into the TextViewer subsystem

☐ Provide a Lens.Mod that exposes a derivative text from a source text and --Frames.Mod allowing editing in a marked-up environment and format conversion

☐ Make the file system hierarchical with symbolic links, long unicode file names, and capable of file sizes greater than 3MB

☐ Make the root of the local filesystem //localhost/ (abbreviated /) allowing transparent access to //whatever.host.com/path/to/file

☐ Consider extending file permissions to rwxpkd (read,write,execute,protect,keep,disregard) for user[:group/ou]*:world inspired by http://bitsavers.org/pdf/apollo/014962-A00_Domain_OS_Design_Principles_Jan89.pdf

☐ Consider the benefits of a no-order filesystem: http://pages.cs.wisc.edu/~vijayc/nofs.htm

☐ Use MEDOS-2 style free block bitmap protection (store packed bit value * 13 for single bit error detection at 25% space cost)

☐ Introduce TLA+ for defining protocols

☐ Make text a CRDT with FRP like in https://www.inkandswitch.com/local-first.html using techniques from yjs /~https://github.com/yjs/yjs and ORDT http://archagon.net/blog/2018/03/24/data-laced-with-history/ (fast: https://josephg.com/blog/crdts-go-brrr/ /~https://github.com/josephg/diamond-types )

☐ Compose computation graphs of module commands operating on hashed inputs for distributed computation based on gg https://www.usenix.org/system/files/atc19-fouladi.pdf

☐ Incorporate the unification of dataflow, lattices, and reactive programming for distributed computation like HYDROFLOW http://cidrdb.org/cidr2021/papers/cidr2021_paper16.pdf

☐ Incorporate Actors, Promises and Futures, and MPI equivalent patterns as in HYDROFLOW, integrated to a parallel Smalltalk, Lisp, and Occam

☐ Analyze a distributed Oberon in terms of Patterns of Distributed Systems https://martinfowler.com/articles/patterns-of-distributed-systems/

☐ Use the CRDT and FRP on top of content-addressed file system to make an 'intertext' live xanadu-like document environment, make topics and sub-topics pervasive in IO storage and processing with zz-structures (http://ceur-ws.org/Vol-508/paper1.pdf)

☐ Provide multiple 'Nicks' with separate private keys for user accounts, Map a 'subatomic' social system using pki, hashes, time, replicated interest, digest nick--nick chains through customizeable logic inference to trust, replicate, mute, block, ban values

☐ Incorporate a module with array functionality like April has

☐ Include an Immediate Mode Graphical User Interface style parallel to Frames with a published display list of blit primitives optimized by the subscribing renderer, code Frames to use it when sufficient resources are available

☐ Use Cached Software Rendering https://rxi.github.io/cached_software_rendering.html to reduce user interface computation cost, pipe commands through a filesystem interface to enable terminal composition and remote displays like 8 1/2

☐ Rasterize ttf like /~https://github.com/tomolt/libschrift or /~https://github.com/vurtun/nuklear

☐ Adopt 3D/2D graphics api from /~https://github.com/lunixbochs/tinygles

☐ Consider preparing UI guidelines like http://www.gnustep.org/resources/documentation/OpenStepUserInterfaceGuidelines.pdf adapted to the Oberon TUI in combination with a system of gadgets and incorporation of Smalltalk and McCLIM

☐ Allow for contexts (pwd, tz, kbd layout, interface language, bin path, display charset, etc.)

☐ Accept or infer mime types of text, integrate a MIME database like https://specifications.freedesktop.org/shared-mime-info-spec/shared-mime-info-spec-latest.html

☐ Provide simhash feature comprehension tied to mime-tagged text informed by https://ferd.ca/simhashing-hopefully-made-simple.html

☐ Introduce error handling like /~https://github.com/phoe/portable-condition-system

☐ Minimize state spill through opaque resource export like Thesesus http://kevinaboos.web.rice.edu/docs/theseus_boos_osdi2020.pdf

☐ Develop Oberon-native conventions for utility structure and functionality like coreutils: http://maizure.org/projects/decoded-gnu-coreutils/ with consideration of impact on odoc Oberon documentation

☐ Introduce "equations for system administration", compile them to assertions and datalog terms

☐ Consider Strftime and BCP 47 language tags.

☐ Provide time data type encompassing alternate timestamp formats e.g. unix and OpenVMS

☑ Introduce package description with semantic versioning, e.g. v<Major>.<Minor>.<Patch>

☐ Provide Attest module for signing source code and propagate attested characteristics into produced binaries. Also use Attest to sign rows in csv files and data stores enabling querying on attested characteristics. Formalize how individual users, groups, and organizations manage private and public keys as the sources of attestation, and how users, groups, and organizations manage their trusted sources.

☐ Migrate to ELF binary format with provision for signed binaries and a uuid hash of the source

☐ Develop a HAMT with the intermediate tables partitioned into precise and continuing entries enabling variable-sized keys

☐ Try stealing ORC from NIM https://nim-lang.org/blog/2020/12/08/introducing-orc.html

☐ Incorporate Object Capable Security and CapTP like Goblins in the Spritely project https://spritelyproject.org/

☐ Support a merkle tree of hashed file and directory contents, content defined chunking, deduplication, compression, ephemerality, Git functionality and plausible deniability encryption.

☐ Implement file diff like https://blog.jcoglan.com/2017/04/25/myers-diff-in-linear-space-implementation/ and /~https://github.com/git/git/blob/v2.12.0/xdiff/xdiffi.c

☐ Consider /~https://github.com/nicolagi/muscle as a model or interoperate with muscle

☐ Consider A practical scalable distributed B-tree (Marcos K. Aguilera, Wojciech Golab) and GrowT (/~https://github.com/TooBiased/growt) and non-blocking resizeable concurrent hash tries and RRB Trees / Standard Vector Nodes (Phil Bagwell, et all) for key-value stores, alternatively Bw-Trees (https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/bw-tree-icde2013-final.pdf https://www.cs.cmu.edu/~huanche1/publications/open_bwtree.pdf /~https://github.com/wangziqi2013/BwTree)

☐ Implement distributed data, index and querying like Helios http://www.vldb.org/pvldb/vol13/p3231-potharaju.pdf

☐ Implement Guarded Horn Clauses for logic programming over data like https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.25.2460

☐ Enhance text with org-mode

☐ Make TextFrames windows on streams of text

☐ Make parameter-less commands global across an Oberon cluster

☐ Implement compression inspired by /~https://github.com/klauspost/compress/tree/master/zstd

☐ Enhance text to recognize & prettyprint command names from hashes of reproducibly generated command packages, with the package containing the hash & operands that produced the package

☐ Enable module instance / file system directory duality like as in "Metaprogramming in Oberon" (Josef Templ) and polymorphic write streams (Marcel Weiher, Robert Hirschfeld)

☐ provide scripting and command completion, absorb citrine and wenyan-lang concepts for localized programming

☐ consider introducing a DOM and CSSOM to the text UI

☐ consider flatbuffers for serialization

☐ Introduce 9p style file system protocol and mounting

☐ Emulate ANTS and 9gridchan namespaces for resilient collective resources

☐ Provide Redis-like functionality

☐ Adopt GraphQL-like queryability

☐ Use Redis-like functionality in io-notify style producer/consumer queues for file system state change

☐ Form a standard library of modules organized into packages with semantic versioning

☐ Introduce a hash-based object store for reproducible artifacts

☐ Deploy source and binary package management

☐ Monitor latency distribution and successful/unsuccessful request counts (plus error types) for all RPCs served.

☐ Monitor latency distribution and success rate for all other services depended on, as well as circuit breakers tripping.

☐ Monitor the last success time for anything that’s supposed to happen periodically.

☐ Monitor percentage utilization for resources (quotas, rate limits, physical and logical system resources), as well as saturation signals for the same, and errors or timeouts.

☐ Monitor how many instances are up and healthy/unhealthy, restarts, running versions of binaries.

☐ Monitor system invariants: other properties of your specific system. For instance, the count of leaders for a leader-elected system (expected to be one - you want to know if it isn’t). Other examples could include the number of replicas of parts of a replicated dataset, cache hit rates, and so on.

☐ Integrate additional system-level document types with the same degree of integration as 'text' with later tools/interfaces/structure/primitives able to rely on previous ones, e.g.:

Tool/Pkg	Interface	Structure	Primitives	File Types	Service
Kernel
Files		FileDir	Files	Volume
Modules				elf
Oberon
System
Edit	TextFrames	Texts	Fonts	Text, md...	Classifier
Build	ASTFrames	ASTs	Statements	Mod, elf...	Compiler
Script	SessionFrames	Sessions	Expressions	Cmd	Shell
Get	PackageFrames	Packages	Needs	Pkg	Fetcher
Calc	SheetFrames	Sheets	Formulas	Sheet	Tabulator
Paint	ImageFrames	Images	Bitmaps	Pict, bmp...	Blitter
Draw	GraphicFrames	Graphics	Macros	Graphic	Drafter
File	FileFrames				Filer
Relate	GraphFrames	Graphs	Nodes	Graph	Registry
Query	DataFrames	Data	Indices	Query	Database
Log	LogFrames	Logs	Events	Log	Logger
Chart	MapFrames	Maps	Locations	Map	Locator
Sched	CalendarFrames	Calendar	Events	Cal	Scheduler
Test	CaseFrames	Cases	Tests	Test	Builder
Talk	DialogFrames	Dialogs	Messages	mbox	Relay
Reason	LogicFrames	Logic	Assertions	Logic	Reasoner
Infer	NNetFrames	NNets	Matrices	NN	Recognizer
Learn	CortexFrames	Cortex	Neurons	cla	Learner
Control	StateFrames	States	Interfaces	Panel	Controller
Stream	MediaFrames	Media	Streams	Smpl, avi...	Streamer
Attend	ChatFrames	Chats	Utterances	ifttt	Attendant
Score	TabFrames	Tabs	Notes	Tune	Conductor
Render	SceneFrames	Scenes	Vertices	World	Renderer
Show	SlideFrames	Slides	Elements	Pres	Presenter
Simulate	ModelFrames	Models	Components	Sim	Objectbase
Emulate	VMFrames	VMs	Gizmos	VM	Pretender
Browse	SiteFrames	Sites	Tags	html	Webserver
Play	GameFrames	Games	Pieces	Game	Gameserver

☐ Assemble composite glyphs from composing Unicode characters, Implement Unicode text directionality as in http://userguide.icu-project.org/ , Support variable line heights in Texts

☐ Adopt LSP (Language Server Protocol) interface to text and example servers for system-wide integrated development

☐ In the Score package adopt the Lilypond format of text to display in staff notation in the TabFrames

☐ Implement TCP/IP, consider Ouroboros (https://ouroboros.rocks/)

☐ Integrate binary, script, and source code signing

☐ Introduce a Real Numbers package: Towards an API for the Real Numbers https://dl.acm.org/doi/pdf/10.1145/3385412.3386037

☐ Give every core its own IPv6 interface address for each hardware interface, merge IPC and IPv6

☐ Develop an "Us" protocol with decentralized group membership algorithms

☐ Provide Zanzibar (or Topaz), Spanner, TrueTime-like distributed consistency, CASPaxos, Kademlia DHT

☐ Borrow cluster resource tracking from slurm

☐ Borrow Timely Dataflow from Naiad

☐ Borrow distributed processing from Legion

☐ Borrow Addressing, discovery, Control plane, pub/sub messaging from NATS

☐ Provide encapsulation, rearticulation, and incorporation guidelines and examples for integrating external projects and upstreaming the port to io

☐ Prepare encapsulation frameworks to accelerate integration of projects, e.g. provide a base Java, Smalltalk (80, mini squeak 2.2, cuis), Lisp/Scheme, UNIX/C usermode, etc.

☐ Harvest overlapping windows architecture from https://www.unitedbsd.com/d/442-fvwm3-and-the-quest-for-a-comfortable-netbsd-desktop

☐ Demonstrate cooperation of Integrated Oberon, Integrated Smalltalk, Integrated Lisp with Interlisp/Medley bootstrapping to SICL, Integrated BSD with GNUStep, Integrated Forth http://retroforth.org/ https://factorcode.org/ and Integrated Go /~https://github.com/benhoyt/mugo, perhaps femtolisp (/~https://github.com/JeffBezanson/femtolisp) to get an Integrated Julia reproducing https://julia-doc.readthedocs.io/en/latest/devdocs/eval/ and Integrated Pascal conforming as much as possible to FreePascal (https://www.freepascal.org/docs-html/ref/ref.html)

☐ build a COLA like /~https://github.com/attila-lendvai/maru perhaps to be the femtolisp for Julia

☐ implement a Higher-order Virtual Machine for functional languages like /~https://github.com/HigherOrderCO/HVM

☐ Write some introductions: A BASIC Oberon Language; Go for Oberon; C an Oberon Compiler; Forth Native Oberon Language, Smalltalk Over Oberon, Lisp In Oberon Modules, (Net)Logo my Oberon.

☐ Surface java.base as a module in Integrated Oberon, alias Oberon modules with java modules for interoperability