Over the past decade and a bit, on almost every project I've worked on, I've come to realise that there is often quite a massive gulf between what the Standard Library + UI Toolkits typically offer, and what it is that you really typically require when building anything of consequence for the real world. The problem is such that really, you end up needing to spend quite a bit of time re-inventing the following sub-systems for each project OR end up paying the tax of not having these for each and every feature you add (by effectively reimplementing them *per feature* instead, but without the benefits that having the standardised system brings).
While the initial seeds of what I'm about to discuss date back to around 2010, things really started to take shape around 2018/2019, when I first seriously started mooting the idea of maybe creating my own Programming Language / Environment someday (i.e. "Kea"), a batteries-included environment for doing everything "my way"...
One of the key aspects of that language would be that the following functionality / capabilities would end up being "baked" into the language as first-class citizens. Before fully embarking on that journey again, I thought it would be good to first prototype these systems in other environments where they may help advance the overall state of the software industry. Hence this blog post.
The Short List - Core Functionality:
* 1) Property Metadata System (i.e. something like Blender's "RNA" system)
* 2a) Bidirectional Property Binding (Data Objects <-> UI Widgets)
* 2b) Widget / Factory that creates standard auto-bound widgets, given only the Property ID + host object reference (i.e. something like Blender's UI widgets)
* 3) Automatic hierarchical property serialisation system (i.e. something like Skyline-X's Preference Sets)
* 4) Version patching (i.e. something like what is used for Blender's SDNA system)
* Includes utilities related to version number management and/or Git branch/revision info
* 5) System for Physically-Based Unit Handling and/or Unit Conversions
The Short List - Extended Functionality:
* 6) Static/Dynamic Expressions / Drivers, Expression-Evaluation, and/or String Template Substitutions
* 7) A "Datablocks" System + CRUD API's for managing those
* 8) "User Preferences" system
* 9) "Operator"-like system (for standardised logging / error handling, undo/redo, and background-exec of expensive long-running-processes) - inspired by what Blender uses since 2.5
* 10) Basic Extendable Templates/Base-Implementations for Handling the Following Functionality (Optional)
* Standard logic for New / Load Project/ Save Project stuff
* Standard logic for handling cache files / support data files
* Built-in screenshot per-viewport/view-angle screenshot functionality (with repeatable / savable parametric configuration)
* Grease Pencil / Built-in Freehand Annotation Tools
* Node-editor
* 11) UI Toolkit Extensions + Features
* Collapsible Panel implementation (Note: This is surprisingly absent from most UI toolkits in practice)
* Control-Gain Ladders / Input Convenience mechanisms
* Popup panels templates
* "Overlay toolbar / interactive viewport tools" system
* Popup info panels / extended menus for Unit Conversions + String Templating functionality
