1  # SPDX-FileCopyrightText: 2026 Le'Core collective
  2  #
  3  # SPDX-License-Identifier: LGPL-3.0-or-later
  4  
  5  #+TITLE: Le'Core - Development Status
  6  #+LANGUAGE: en
  7  
  8  Development happens in spurts, and there is still a ways to go before this can
  9  be pronounced fully Ready, let alone usable.  I have a readiness status on
 10  each piece, which is one or more of:
 11  
 12  - Planned ::
 13  
 14    To be designed and implemented.  So far, it is only an idea.
 15  
 16  - Deferred ::
 17  
 18    The component is pushed to the future, i.e. it doesn't stop the
 19    encompasing component from being deemed Ready.
 20  
 21  - Rejected ::
 22  
 23    There was a plan, but the component was deemed unnecessary, or was
 24    replaced with something else.
 25  
 26    Items marked this way will disappear entirely in a future commit.
 27  
 28  - Design in progress ::
 29  
 30    A first rough design is being written, describing the ideas that are to be
 31    implemented.
 32  
 33  - Implementation in progress ::
 34  
 35    A first implementation is in the works.
 36  
 37  - On hold ::
 38  
 39    A design or implementation exist, but there are serious doubts about
 40    them.
 41  
 42  - Testing in progress ::
 43  
 44    Implementation is pretty much done, but is undergoing feasibility tests
 45  
 46  - Ready ::
 47  
 48    This first rough design is pretty much done, and there's a working
 49    implementation.
 50  
 51  - Documented ::
 52  
 53    This has proper documentation
 54  
 55  At some point, this status marker will not be necessary any more.
 56  
 57  Ideally, all components should reach a state of Ready + Documented.
 58  
 59  * Designs
 60  
 61  Designs are made in the form of stories, which are maintained in a separate
 62  repository, Le'Sec stories[fn:Le'Sec-stories].
 63  
 64  [fn:Le'Sec-stories] https://seed.le-pri.me/rad:zQ8psYPsgeSGJQrsUqXCP5oWdrPM,
 65  or =rad:zQ8psYPsgeSGJQrsUqXCP5oWdrPM= on the [[https://radicle.xyz][Radicle]] network.
 66  
 67  * Intended library names:
 68  
 69  - On Unix: ~liblecore_s.a~, ~liblecore.so.{major}~
 70  - On Windows: ~liblecore_s.lib~, ~liblecore.lib+liblecore{major}.dll~
 71  - On VMS: ~LIBLECORE_S.LIB~, ~LIBLECORE{major}.EXE~
 72  
 73  * Intended public header directory:
 74  
 75  =${PREFIX}/include/lecore/=
 76  
 77  * Source directories and files
 78  
 79  - Documentation source: =doc/=
 80  - Code source: =src/=
 81  - Public header source: =include/lecore/=
 82  
 83  * Components
 84  
 85  ** Core C type factory
 86  
 87  Status: Ready
 88  
 89  This is a foundational C type factory, implemented as as the inclusion file
 90  =include/lecore/core.inc= that works as a template for what core types that
 91  need to be defined.  Comments in this file explain how it's intended to work.
 92  
 93  ** Environment
 94  
 95  Status: Ready
 96  
 97  This is a generic data store, and the root of all other data that concerns
 98  libraries that extend Le'Core.  Applications must create at least one
 99  environment to be able to used anything else.
100  
101  *** Plugins
102  
103  Status: Ready
104  
105  This is functionality to start and stop plugins.  The plugins can be built
106  into the applications, provided by libraries, or provided as dynamically
107  loadable modules.  It's entirely up to the application to decide how to get
108  them; all this commponent does is give support to get them started an
109  stopped.
110  
111  *** Parameters and Parameter Descriptors
112  
113  Status: Planned
114  
115  This is functionality to pass diverse parameters between applications and
116  plugins, or even between plugins.  The idea is that parameters are key:value
117  tuples, defined by the "owner" of the parameter with the help of parameter
118  descriptors.  The "other end" is responsible for formatting the value to be
119  passed according to that descriptor.
120  
121  *** Operation factory, and Registration
122  
123  Status: Planned
124  
125  This is a C type factory for all sorts of operation classes, implemented as
126  the inclusion file =include/lecore/operation.inc=.
127  
128  *** Object factories, and Registration
129  
130  Status: Planned
131  
132  This is a C type factory for all sorts of object classes, implemented as the
133  inclusion file =include/lecore/object.inc=.  Object classes are an extension
134  of the Core types, specifically made to handle a payload with which diverse
135  operations can be performed, as well as support for associated data
136  operations:
137  
138  - Generator: Planned
139  
140    This is an associated operation that generates an object payload, given
141    some input Parameters.
142  
143    The input Parameters may be anything that can be used to generate a
144    payload, including some of the payload facts, but the main function of a
145    Generator is still to generate a whole payload internally.  If the caller
146    has all the payload facts, then it's better to use the Constructor.
147  
148  - Constructor: Planned
149  
150    This is an associated operation that constructs an object payload, given
151    payload Parameters.
152  
153    This is almost like the Generator, except that this takes input from the
154    caller to construct the payload,
155  
156  - Extractor: Planned
157  
158    This is an associated operation that is used to extract the object payload
159    in form of Parameters.
160  
161  Extended Operation support to create operation classes with an associated
162  Object class and type is supported as well.