Nexus (Lower Level Library)
Just feeling that i would post that here, with the recent commits being done on Github.
Few months ago, Colin was asked a question about the LLP and the LLL and how these could be implemented into real world uses in the future.
Here was his answer:
The LLL or Lower Level Library is a template library which means that the code is not set to a fixed set of rules but rather it is designed as toolsets to build anything from them
When it is complete at least in release ready situations it will be just the base templates and base parts of the Library
These are broken up into these categories:
LLD (Lower Level Database):
This is a set of templates to creating high efficiency database systems. The high efficiency nature of it can be used to power some of the largest websites that weren't built with database software designed to scale.
Oracle made a database called "BerkleeDB" which is what powers the Nexus databases currently, which is very slow, terrible indexing, and difficult to get it optimized since it doesn't have as many options to tweak as it could have.
Testing up the "Loading Block Index" on a basic LLD build brought my loading time from 15 minutes to 47 seconds. This is over a 15x speed increase on just the database reads/writes. Combining an LLP SQL engine or some protocol accessor will make a "Completed Custom LLD MySQL" database to handle well into the 50k requests/second depending on the hard drive's read write speeds.
LLE (Lower Level Encryption):
Custom Encryption systems that when developed well enough will provide people resources to simply encrypt any data string using symmetrical or asymmetrical quantum secure algorithms. I am working on what I call Integral Signature Algorithms (ISA) using Integral Transposition Cryptography (ITC) which is a new type of quantum secure encryption I have been creating from scratch.
This will enable very small private and public keys sizes with incredible strength compared to any other algorithms out there.
Symmetrical algorithms will be more simple byte modulation routines along with XOR (Exclusive Or) type modulation from a given symmetrical key (A hashed password, a key both sides would need to know)
This will enable quantum secure database encryption using passwords or ITC, encrypted communication over the internet, encryption of files, ect. This will replace any AES-256 encryption algorithms
LLH (Lower Level Hashing):
This will be a nice collection of high security hashing algorithms. I'm not going to be making the "algorithm" itself but rather hand selecting some of the best new hashing functions similar to how cryptopp acts as a library. Will be a convent way to setup any sort of SHA3 hashing and preset security levels.
LLP (Lower Level Protocol):
The Lower Level Protocol is a template server and client that acts as one step better than asynchronous sockets by creating a load balanced threading using non blocking sockets to achieve a very large number of connections and requests per second. I've seen the LLP handling over 6,000 connections at once with no issues. It is a template protocol which means one doesn't ever need to do any tedious socket programming or learn how to handle the Transport Control Protocol and how to manage connections, disconnects, threads, data transmission, packets and so on
All one needs to do to make a new protocol is to create a function called "ProcessPacket()" and within that designate the messages and their corresponding server responses.
This is very useful in designing any custom protocol or messaging system and allowing it to come to full functionality with very little time since very line of the LLP templates have been optimized and tested thoroughly.
LLS (Lower Level Serialization):
A unified serialization set of templates to allow the conversion of regular data structures to byte streams for use in socket transmission, writing to disk, ect. This also handles all the strange cross platform quirks associated with endianness, ect
LLT (Lower Level Types):
Certain types that are not supported in C++ are numbers bigger than 64 bits which is not usable for cryptography. It contains large integer classes for up to 1024 bits, some wrappers around BigNum classes (Eventually to be coded from scratch for efficiency or integrated with GMP). These types can also range beyond integers as more find use for custom data types.
LLU (Lower Level Utilities):
Very useful utility functions that come in handy making any sort of high efficiency system, a collection of contributed utilities organized and at the disposal of the programmer.
*-------------------- Use Cases --------------------- *
One such is Facebook that was built using the database engine "MySQL". As Facebook grew they had to create clusters of hundreds of servers to handle the growing traffic demand. MySQL can handle only about 2k requests per second, the network programming is a very limited "one connection per thread" limiting the amount of connections possible. It is also a very unstable protocol in a sense that when it becomes overloaded it literally locks up the whole Operating System from overloading the OS's ability to schedule threads. I've seen this happen before and it gets ugly. They have made it better by custom coding "memory caching" to get it up to 5k requests per second, but this is still a very limited number compared to what a good database could do.
Another would be a programmer wanting to power their software with the highest security and efficiency software that uses the templates to create a useful set of tools that could be sold to other developers.
But the true real world applications with the LLL template library is what can be created from these templates: anything. This creations from the base of the Library will extend the templates into specialized software systems such as new MySQL systems, better HTTP protocols, secure SSL systems, more efficient web servers, improvements into FTP or completly new useful protocols for file transfers, web data extraction, remote connections, communication, messaging, emails, anything.
The reason people would find more utility in using software and protocols that are built from the LLL is the level of efficiency. Code inhereted from the templates will always scale to incredible proportions, always be the most secure in their encryption, and always handle the most possible data and processing when compared side by side to any other existing software not inherited from this code.
@Houssam Thanks for posting this. It is entirely rejuvenating to see the systems thinking which has gone into the Nexus architecture. The biomimicry which is applied to the high-level network architecture is beautiful. Cellular dynamics have such elegant design patterns, which have only become replicable as network building blueprints in the last few years. It's obvious in the many aspects of modern-day computing, where the original architects of our current databases and network infrastructure couldn't have possibly foreseen how it would evolve. Why anyone would build DAPPS without thinking forward to the next generation of networking is beyond me, but there is plenty of benefit to short-term solutions as well within the blockchain space. Nexus really delivers the goods with this holistic commitment to outlining what is only recently possible without the insane baggage of our legacy systems. I look forward to building atop these Lower Level Libraries in order to create solutions for the next 100 years. Look for my introduction to the Ecoblockchain framework and The Sense Collective in the coming week. We've had Nexus' cube-sat infrastructure in our brainstorm cycle for months, and I'm stoked to kick around the solutions we've come up with for introducing the human specification interface layer for Ontology Driven Blockchain Semantics, as the basis for managing our social and natural capital resources with integrity. Here's a link to a talk I gave recently on The Ecoblockchain framework, in Perm, Russia at Perm School Of Economics Winter Blockchain conference.