Skip to content

Latest commit

 

History

History
76 lines (60 loc) · 4.9 KB

TODO.md

File metadata and controls

76 lines (60 loc) · 4.9 KB
Raw

TODO List

CORE

  • Merge serial, detour and loader systems into a generic plugin system.
  • Improve versioning of loader plugins and it's interface.
  • Extend loading process to accept scripts as string, uri or memory block.
  • Add a cross-platform library for managing path tree and allow scripts to be loaded by path.
  • Add watchers and reload policies in order to provide on-the-fly changes and make it fault tolerant against corrupted scripts.
  • Add error management.
  • Add new type management and its implementation in each loader (ptr, array, callback, object).
  • Improve scope management for encapsulation and add tie-breaker to avoid conflicts between functions with same name.
  • MetaCall++ front-end compatible with SWIG (avoid common exceptions and unimplemented templates).
  • Possibly convert the whole project to C++ and export critical parts like MetaCall front-end and loaders plugin interface as C API.
  • Implement a meta-object protocol in order to support a complete AST abstraction representing class and object tree.
  • Implement an event protocol for supporting reactive architectures based on callbacks.
  • Make an automated architecture and test generation for implement all tests with a workflow (TDD) and similar semantics, and implement them.
  • Add custom benchmarks and small utility library for supporting benchmarks, and integrate it in build process of CMake.
  • Improve security of loaders and scripts loaded with signatures, and avoid memory injection with a driver.
  • Implement thread safety.

LOADERS

  • Loader C/C++:

    • Clang as a parser for reflect generation for .h and .hpp files.
    • Libffi as a foreing function interface caller.
    • LLVM as a JIT compiler for .c and .cpp files.
    • Dynlink library as a cross-platform library loader.
    • Alternatively use EmbedCh.

  • Loader C#:

  • Loader Java:

  • Loader PHP:

  • Loader LUA:

DOCUMENTATION

  • Write a complete documentation of the core source and libraries.
  • Write a separated text with a complete manual of each example.
  • Integrate automated generation of documentation with CMake build:

EXAMPLES

  • Simple example of a front-end web-page (Js with Angular or React) with a logic based on (C/C++).
  • Extension of first example providing a custom service as mark-water implemented natively and a custom database layer implementing a persistent cache.
  • Custom threading, high performance example based on script host language (Python, Ruby, Js) and a guest native language (C/C++), to implement a matrix based solver (Sudoku or some Math problem).
  • Implement an example of software migration from an old software language to a newer one (possibly Visual Basic 6 to some script).
  • Implement a CLI for MetaCall++ and extend current CLI for MetaCall (possibly with a common front-end and different adaptors for the back-end).

DEPLOY

  • Integrate project with SWIG and provide automated port generation for MetaCall and MetaCall++.
  • Add continuous integration for multiple architectures and operative systems:
    • Docker for deploying.
    • Vagrant for generating workstations for developers.
    • Set up scripts (sh, bat) for multiple architectures for each CI container.
    • CI/CD release of .deb and .rpm packages
  • Add cross-compiling toolkit for multiple architectures integrated with CMake

MISC

  • Standarize code style guidelines and tabulation (editorconfig and editorconfig tools).
  • Implement a linter step in build process for style guidelines, static analysis, etc... for C/C++ code (possibly Boost style).