In-Memory
AI
XEPL
In XEPL, nano-computers are Neurons and neurons have inner neurons; Software threads are XEPL lobes and DNA code/data is shared, connected; and the entire XEPL node is in-memory, multi-threaded, magic.
XEPL software represents genes (DNA), as an XML record that functions as both data and code, and introduces a profound shift in how neural networks (and software systems) can operate.
The XEPL DNA record is both data and executable code, the system can modify its own functionality and structure dynamically. This fusion of code and data allows neurons to alter their own genetic structure in real-time based on the tasks they are performing or the insights they generate.
XEPL neurons not only process information but also manipulate the very structure of the system by interacting with and evolving the DNA genetic code that defines them.
This self-referential system of genes describing neurons, which process and generate new genes, offers a dynamic, adaptable, and evolving form of software architecture.
XEPL is Launching
XEPL is multithreaded magic
Works along Side … any application.
You personal Language; your words, your verbs,
XEPL DNA with Connected Neurons
XEPL Benefits and Opportunities:
- XEPL Neurons, lobes, and cores operate concurrently, allowing for real-time task execution with minimal latency.
- XEPL Neurons with inner neurons allow complex tasks to be broken down into simpler ones, while lobes and cores manage task execution across the system.
- XEPL Signals between Neurons are represented as XML documents that provide a structured, connected, and flexible data model that all parts of the system can manipulate and access instantly.
- Neurons with inner neurons introduce a hierarchical structure. Each neuron isn't just a simple processing unit but contains sub-neurons that can process parts of the problem in isolation or handle subtasks within the overall function of the parent neuron. This modularity allows for:
- A high-level task can be broken down into smaller, manageable components that inner neurons can handle, promoting parallelism and specialization.
- Neurons can specialize in different types of processing, allowing combined neurons to handle diverse and complex data by delegating work internally.
- Lobes act as both neurons and software threads, which means they are not only capable of processing data but also handling thread-level parallelism. Each lobe can control a part of the neural network, delivering signals (XML documents) to and from neurons, orchestrating the flow of data across different cores.
- XEPL systems process multiple signals concurrently, leveraging multi-core or even multi-node architectures to process large amounts of data in real-time.
- Lobes can handle signals concurrently across different cores, which means that while one lobe is processing an incoming signal from a neuron, another lobe can handle that same signel, or other signals related to different parts of the system, improving efficiency and throughput.
- Cores (which represent computational units such as CPU or GPU cores) process signals concurrently, enabling highly parallelized computation. Since the lobes manage the flow of signals, this can lead to:
- Increasing core count improveds performance efficiently by processing more signals concurrently, allowing it to handle larger datasets or more complex tasks without bottlenecking.
- XEPL distributes the workload across multiple cores, the system can handle real-time tasks, such as robotic control or decision-making, with minimal latency.
Solutions in XML
In XEPL you build solutions in XML.
You implement your Keywords, your Operators, and build the Neurons you need.
You think in your domain, you solve problems expressed as solutions, in your custom / domain specific language.
<Imagine>
<Designing multi="threaded" code="in">XML
<Axons with="signals"/>
<Synapses with="handlers"/>
<Easily>{scripted.with.operators}</Easily>
<Properties for="key">value pairs</Properties>
<Methods for="neuron processing">using
<custom>neuron code</custom>
</Methods>
<Forms for="rendering content" any="way"/>
<Macros for="automating scripts"/>
<More>
<More>...You choose everything...</More>
<More/>
</Designing>
</Imagine>#include "xepl.h"
void Xml_Keyword ( XEPL::Neuron*, XEPL::Gene*, XEPL::String* ) {
// <AddPowerfulKeywords with="parameters"/>
}
void Rna_Operator ( XEPL::Script*, XEPL::Cord* ) {
// {custom.Operators.to.build.strings(option)}
}
void Cli_Command( XEPL::String* ) {
// brain> Cli Commands
}
XEPL::Gene* Gene_Access( XEPL::Nucleus* ) {
// {$access/to/any/gene}
return nullptr;
}
int main( int, char**, char** ) {
XEPL::Cortex brain ( "brain", std::cout );
brain.Register_Keyword ( "Keyword", &Xml_Keyword );
brain.Register_Command ( "Command", &Cli_Command );
brain.Register_Operator( "Operator",&Rna_Operator );
brain.Register_Mutual ( "Gene", &Gene_Access );
}
XEPL is Coding in DNA
Add Keywords
Add Operators
Add Neurons
Wire It up
Let it grow
<Print>'Hello, World!</Print>Introducing XEPL. A
XEPL is an in-memory processing platform using multi-core for concurrency implementing a distributed Software Execution Environment.
XEPL solves these problems:
- Designing software takes too long
- Coding software is too hard
- Executing software is too slow
- Modifying software is far too tricky
Hello, World!
Neurons
Building
Neurons
XEPL Cortex Power
XEPL implements a digital Cortex using C++ to build Neurons, Lobes and Axons that can deliver any Gene as a Signal to any other Neuron. A Cortex of sprawling neuron networks signaling one another.
Unlike traditional programming languages, XEPL is an Environment for programming. The Environment contains your XML Keywords, scripting Operators, and interface Commands that you supply.
100%
non-blocking
C++
Dynamic Memory Recycler
Dynamic operation !
Before we get too deep, std C++ has a challenge when you use dynamic memory ... aka ... new/delete. XEPL Leans heavily on dynamic memory, so ... XEPL solved the challenge.
Building your own allocator is complex, but by capturing and returning discarded memory during operation, The XEPL Recycler delivers non-blocking re-allocations over 99% of the time.
With dynamic memory challenge solved, applications need data storage.
Binary connected XML
Data management is normally rows and columns, but in XEPL everything is stored in Trees of DNA. Each DNA Gene is a shared XML Database that is Thread safe and is used for both code a data.
The Gene is Recursive and implements a connected, thread-safe database of Traits, a list of named Strings, and a Wire of shared Content connecting Genes, and of-course nested inner Genes.
New School
TRY
Old School
One-Line Build
mkdir xepl && cd xepl git clone https://github.com/xepl/one.git one cd one g++ -std=c++17 simple.cpp && ./a.out
SOLO
Development
Environment
GUI Brain.Kits