Brainstorm zu Semantic Code

future computing includes new technologies like code abstraction,
  recursively generating and self-modifying programs, code analysis
  and environments for simplified development of complex solutions.

Syntax-free development environments will support multi-dimensional
  code linking and significantly increase the productivity and quality
  of software development.

______________________________________________________________________

Advantages of Code Generation Technology:

Search free available generic solutions
Interchange between architectures, devices and programming languages
Access code and support custom modifications
Benefit from higher development productivity
Increase complexity and involve AI in production
Load and execute native sandbox code
Update software during execution


### Code Linking Levels:

## Control:
Control flow
Value expression, parameter references
Native thread control
State control

## Data:
Data, stack, heap access
String
Internationalization
Supported query strings (SQL, regex, ...)
DB model, relation, hierarchy, dependency
Graphical component tree
State data, history log
Code to generate at runtime
Code path (search pattern, navigate)
Various supported/generic structures and models accessible

## Structure:
Type
Class hierarchy, inheritance, interfaces
Organize, fold, bookmark
Constant tables
Code abstraction, dynamic scope data access
Code version, specialized alternatives, parallel implementation
Optional parts, alternatives (construction kit, avoid overhead, ...)
Target language specific, platform specific, language native code
Profiles (release, debug, various tests, ...)
Development status (alpha, beta, release, ...)
State scope, trace resolution (trace overhead, performance)
Distributed execution (distributed architecture, client server, ...)
Maintained custom modification points
Tests, documentation, external links
Machine readable information, "scripted" conventions, suggestions

## Event:
Event, exception, message, callback
Events for data access (constructor, destructor, getter, setter, ...)
Events for arbitrary cases
State restore event (init GUI, ...)

## Advanced:
Thread priority (real, user interface, background, ...)
Multi processor code splitting, balancing
File/variable sync, persistence sync, frequent state backup
Data read only, append only (ROM, log, ...)
GUI views, sub views, represent internal structures
Data/functional focus, limitation, restriction
User accounts, access permission
Security levels (CPU ring, operating system, ...)
Sandbox


### Analytic:
Double linked, deep path tracking (up, down, all coherences)
Data dependency (state hierarchy, thread sync, ...)
Data/functional path, dependency
Thread flow bounds, recursion
Central implementation search, branch relevance
Test status, combinations, paths


### Component:
Convenient plug-in, linking, configuration
Automatic linking, configuration, integration check
Multiple level connectors, optional parts, alternatives
High level programming and administration


### Details:

Some "levels" simply add a property, others duplicate all other levels
  like a new dimension. Root dimension, shared configuration,
  inheritance.

Entire code defined as JSON-like objects w/ string keys. Double-linked
  references w/ optional order, substructure, direction or attributes.
  Except of the basic target language implementation, all other
  properties are optional and modify the result. Symbol names COULD be
  omitted or replaced w/ short text. Named references instead of
  ordered function parameters and return values.

Extensible levels and programming elements, modular generating based
  on separate feature generation. Generated tree w/ compilation log,
  mutual output module integration. Elements represented by string
  properties in all processing states.

Import and output modules for Java and C++. Algorithms and function
  bodies should import cleanly. User interface, event handling, API
  calls, templates and generics may convert inaccurately. Emulates
  functions on limited architecture capability.

Technology core and modules should be implemented in clean importing
  Java or the technology itself, using basic language elements
  respectively.

Transform code by algorithm, search pattern w/ full code access. Check
  convention and specification compliance. Compare code and view
  differences by branch. Upgrade and change to new technologies
  automatically.

Convenient component use, immediately working w/ default settings.
  Additional properties configurable. High level administration of
  complex systems. Display internal structures directly w/ editor
  toolkit. Live trace or trace recording and stepwise playback.
  Context-related structured debug/log output.

Secure "sandbox" code generation, software/hardware security support,
  limited environment access, nestable, also full emulation possible.
  Convenient for plugins, extensions, scripting and web content.

Native filesystem access. Type independent serialization support.
  Native distributed architecture intercommunication.

Code and types are treated as values and can be assigned to variables.
  Abstract code can be passed to other code. Call abstract code within
  abstract code w/ arbitrary parameters. All code is accessible like
  JSON objects and can be discovered, modified, serialized and
  verified at runtime. Access restriction allows monitoring and
  validating remote or sandbox systems w/o security leak.

Future targets include: virtual machine, operating system, hardware
  architecture, nano mechanics.


### Productivity:
Target software integrates editor, editor and compiler customization
Save user input instantly, full editor history log and access
Team: Convenient revision control, live team development
Rapid: Safe development on running live system
Parallel version execution, live testing
Parallel GUI merge (testing, code integration, system change, ...)
Parallel DB difference images
Safe testing and error handling, track all influence, rollback
Generic solution DB, search, compliance check, feedback, statistics
Solutions customizable and extendable through full code access
Convenient custom modification w/ exact tracking
Submit custom modification to project
Organize and exchange parallel projects