Edit

kc3-lang/kc3/README.md

Branch :

  • README.md 
  • # KC3 v0.1.17-git

A programming language providing and relying on facts-db.

KC3 is a programming language with meta-programmation and a graph
database embedded into the language. The graph database allows for
all definitions in the language and can define special operators
in KC3 or in C. With a graph database at its core it aims to be the
language for semantic programming, and programming the semantic web.
It's really easy to devise a data scheme that will persist and
iterate in any order and call KC3 or C functions on it.

For now there is no object abstraction nor reasoning on facts.
Every operation on the database is controlled by C code in the end.

You can easily convert each KC3 function to a C function. KC3 is both
a language and a runtime with powerful, scaling data structures.

This is a development branch, for the latest release see
[KC3 v0.1.16](https://git.kmx.io/kc3-lang/kc3/_tree/v0.1.16).

KC3 is currently a programming language project, inspired by C, Elixir
and Common Lisp. It could be described as C with Elixir modules,
pattern matching, and a semantic object system. The idea is to plug
modules, closures, pattern matching, a graph database and
metaprogramming into C11 with an extremely small set of dependencies.

Components :
 - The pure C11 `libkc3` library is a full KC3 parser and interpreter.
 - `ikc3` is the interactive interpreter (verbose).
 - `kc3s` is the script interpreter (same as ikc3 but terse).
 - There are several C libraries which are installed in `lib/kc3/0.1`
   using the `make lib_links` command.
 - There is a web server in httpd : `kc3_httpd`.
 - DRM, X11 and Wayland backends are implemented in `window/`
 - GTK+4 bindings are in progress, you can find them in `gtk4/`.

All binaries can be compiled for four targets :
 - __main__ : speed optimizations from GCC/Clang -O2 and
   debug code like `assert` is disabled.
 - __debug__ : no optimization and debug code like `assert` is enabled
 - __cov__ : code coverage instrumentation
 - __asan__ : memory safety instrumentation with ASan, an absolutely
   awesome tool to detect all memory leaks, double free, segmentation
   faults, invalid read, invalid write, general memory corruption
   errors, etc., just run the __asan__ target for a full report at
   process exit, the report being empty if all is ok.

Supported operating systems (additional dependencies) :
 - BSD
 - Linux (libbsd, libmd)
 - MacOS X (libmd)
 - Windows (MSys2) (no network)

Supported architectures :
 - aarch64 (arm64, Apple M1, Apple M2)
 - amd64
 - i386
 - macppc
 - sparc64

To install and test KC3 for yourself, you can follow the
[KC3 Installation Guide](https://kc3-lang.org/doc/3_Guides/3.1_Install).

## Users

There are now five full applications written in KC3 that we know of :
 - The KC3 Cairo demo which you can run with `make demo`
 - The KC3 SDL2 OpenGL demo which you can run with `make demo_gl`
 - The [KC3 website](https://kc3-lang.org/) which you can launch
   locally with `make test_httpd` with all the KC3 releases and
   documentation.
 - The [www.kmx.io website](https://www.kmx.io/) which is closed
   source and is hosted on kmx.io servers in France using OpenBSD
   everywhere. We donate to OpenBSD every month because a healthy
   software ecosystem is a funded ecosystem.
 - The [kmx.io git forge](https://git.kmx.io/) is also self-hosted
   in KC3 on OpenBSD.

## New in this release

 - libkc3
   - copying temporary variables for `pthread_mutex` and `pthread_rwlock`
     would cause undefined behaviour as per POSIX, this fixes pthread on
     macOS
   - allow for log hooks (a C function callback with a user pointer)
     in the facts database
   - incremental compilation with cached parser results in
     `.kc3c` files, like Python does. Gives **5x faster loading times**
     for all `.kc3` files. `env_load` automatically handles this.
   - fixed a bug in `ht_iterator_next` where the iterator would not
     go through the first collision list
   - database logging now supports and defaults to binary format
     (marshall + marshall_read)

 - Facts
   - Facts.connect/accept allows for bi-directional synchronization of
     an existing `Facts.database()` over a TLS encrypted connection
     after a successful HMAC-SHA256 shared secret authentication
     challenge/response. Master/replica negociation is based on a
     priority negociation : each node sends its priority and the
     lower priority is the master while the others are replicas.
   - `Facts.accept` accepts connections one by one.
   - `Facts.acceptor_loop` starts a thread that calls `accept()`
     in a loop.
   - `Facts.acceptor_loop_join()` stops the acceptor loop cleanly.

 - JSON
   - fixed parser
     - boolean `true` or `false` → Bool
     - map `{"key", "value"}` → Map `%{"key" => "value"}`
     - array `[1, 2, 3]` → List `[1, 2, 3]`

 - HTTPd
   - allow for configuration of OpenBSD's `unveil(2)` in
     `config/unveil.kc3`
   - dropped `libevent2` support in favor of `kqueue(2)`.
   - allow for graceful shutdown using either SIGTERM or SIGINT
   - plugged memory leaks using otto malloc

 - HTTPS
   - `HTTPS.Client` with libtls and automatic or manual connection
     - GET method
     - POST method
     - JSON response

## Contact

Please contact us for support on the following channels.

### Mailing lists

Send a mail to <kc3-lang+subscribe@lists.mail.kmx.io> to join the
<kc3-lang@lists.mail.kmx.io> mailing-list.

This is a public list with a public archive. The mailing list archive is
available at <https://lists.mail.kmx.io/kc3-lang/threads.html>.

### Discord invite

[Join us on kmx.io Discord server !](https://discord.gg/A4MWkpUDsG)

## [Guides](https://kc3-lang.org/doc/3_Guides)

Follow the [KC3 guides](https://kc3-lang.org/doc/3_Guides)
to discover how to use KC3 for your own projects.

## TODO

 - HTTPd
   - OAuth2 / jwt
   - dynamic router
     - def_route(:get, "/user/:id/articles/*slug/edit", UserArticlesController.edit)
 - tls
 - fx
   - chaining of audio and video previews (folder as a playlist)
   - tags
     - create
       - POST "/tag/:tag/*path"
     - delete
       - DELETE "/tag/:tag/*path"
     - recursive
   - properties
     - recursive
 - libkc3
   - unions
   - enums
   - hash-table as a KC3 value (map ?)
   - special operators hash table
   - pass by reference and reference counting in all data structures
     - array
     - cow
     - frame
     - list
     - map
   - base-specific big floats
   - macro cast : `(Macro) fn (x) { x }`
   - pretty printer
     - 80 columns (`\n`)
   - tags
     - generic walker
     - height function `(TAG_VOID: 1, TAG_TUPLE: (1+ (max (height tuple->tags))))`
     - has_ident
     - collect_idents
   - facts
     - negative facts : 4 + 2n = not 3 + 2n
     - with ignore variables
   - math
     - arbitrary precision floating point numbers (decimals)
   - enums
   - unions
   - errors (setjmp, longjmp)
       - ffi ?
         - libdwarf
   - control structures
     - when
     - unless
     - switch/case/cond
   - livebook
     - gaussian
   - buf_sha256
   - buf_popen
   - tests