I've collapsed the seams into 4 seams:

• SEAM_0_0 - Console Apps and Libraries
• SEAM_0_1 - Internet and Store
• SEAM_0_2 - MIDI and Audio
• SEAM_0_3 - Graphics, HMI, and GUI
• SEAM_0_4 - Video

The Stack is fully working but the unit test does not exist and there was a bug at some point with a missing (-1) in the buffer size calculations.

The current benchmark only has performance-per-bit. The benchmark is written already and there is only a little bug in the 10 decimals path. The error is that the upper range of 32 bits is not an even power of 10. My thoughts are that the benchmark needs to be a single loop through half of the upper 32-bit range. This leaves half of the range "untested" but the algorithm does not have a an MSD of 1. This will keep the number of for loops an even power of 2 for all numbers of decimals.

A multi-dimensional array uses a Stack to store the dimensions so this class should not take very long. The Script array format is the same as the C format.

I started writing this super cool maze solver with a mini Machina Speculatrix I can move around. It's cute and perfect to add a neural nets version.

https://en.cppreference.com/w/cpp/memory/align

What happens when a node crashes? There needs to be an automated system for reporting crashes built into Crabs. This will require an abstract client-server system for general purpose.

The only way to guarantee my static data to be in the packed in the order you want it to be in is to use a byte-encoded packed collection of LUTs and provide some functions to get the LUTs using pointer offsets.

The design chosen is to have what we're calling Persenserons, or Sensory Perceptrons, that sample data from various sources such as integers, floating-point numbers, strings, and other data formats.

The way computers handle timestamps is dramatically different, but one format that works across systems is to allow for a variable number of updates per second. For Windows and Linux it's best to update times per second, which is the default OS precision timer update time period may change at runtime. The preferred format is to use a 32-bit TMS timestamp with a decade epoch cycle and 32-bit signed integer sub-second tick.

I've already got the code from the research paper in copied and pasted and the start from a string-to-float algorithm but the algorithm excludes rounding behavior and thus is not acceptable for parsing ASCII Data Types due to ASCII Floating-point String Truncation Rules.

This issue also involves some misc debugging from the ABSOLUTELY MASSIVE AND PAINFUL Unicode and rapid compilation update. Kabuki Toolkit is not one of the fastest compiling SDKs in the world due to our semi-hidden template and minimal header design.

Update 8/2/2018

I had to move the memory alignment functions down to SEAM_0_1 because of the Grisu algorithm I improved upon (Milo's) uses memcpy to make the printed string look better.

I love the ::_:: namespace and a lot of best third-party C++ libraries and game engines use a single namespace so we're adopting that design pattern.

This is where the Layered Seam Trees really start to shine. Rather than shifting up all of our unit tests, we can instead create a Seam Node for SEAM_01_02_03_04_05__06_07. The tree depth levels are now named after SI units: Seam_Layer_{Milli_Micro_Nano_Pico_Femto}__Sprint_Scrum. In each subfolder in the seam_00 in the root project directory contains at least two files: a readme.md that describes the seam node and a seam.h that contains the unit test or unit test runner for that seam node. Only scrums have tests and all other seam.h files are test tree runners. The seam tree runner is been simplified to epically stupid proportions. We have one functions pointer const char* (*TestCase) (char* test_result, const char* args);. This allows us to use a C++ variadic template to construct a near-zero-overhead unit test runner. Each test function is named Seam_01_02_03_04_05__06_07, and we then use a macro FUNCTION to return the function name if test_result or args is null. We then print all error logs to the test_result. args then allows us to pass parameters around to the unit tests.

Also on this commit, Visual Studio has renamed stdafx.h to pch.h so the new seam tree will follow suit.

The Clock is required for the the BIn to work correctly and is closely related to the Print utilities so it shall be on the seam with the Text utilities. Scan is required for Clock and is related to Print.

The FileCabinent is an abstraction layer for the boost filesystem and the mbed filesystem.

You know I got it!

IGEEK is really cool. It's the Interactive Genetic Evolutionary Environment for Kabuki. The code is halfway ported but I got caught up on F2, Crabs, the HMI apis.

I'm adding a console version of Cannibals vs Missionaries.

The Puff algorithm is outlined in the wiki at https://github.com/kabuki-starship/kabuki-toolkit/wiki/Pushing-Grisu-to-New-Speeds-with-Puff

I had thought this out the whole way through and it works best to start the seams at zero. Looks like 10 seams is almost too much to fit on a single page vertically, so if we start at 0 then we can have 10 seams so it's a requirement. At this point, everything is on one page, but it is really pushing it and anything else added will push it over the one-page limit so we have to organize it in a way that allows for scaling beyond the current work-horizon.

So far the Text utilities and Printer have been ASCII only. There is an engineering problem with facilitating.DLL libraries making direct use of templates, not an option. The only acceptable solution is to implement the template classes in the .cc file and map them with inline functions. The Printer needs to have a Printer2 version for UTF-16 because classes cannot use a templated Printer class. Functions should be grouped such that a single macro can be used to turn them on and off.

Update 1:
I've been at it for about 5 days updating code so far and it's been like pulling out teeth. I had to swap everything for template operation including the scan functions, which are now called the Universal Text Formatter (UTF). There are no UTF-8 and UTF-16 compliance checking code at the moment but we have our own number scanning code that works with all Unicode formats.

Update 2:

I've been sloshing through weird template compile errors. Having so much stuff in the UTF doesn't help debug, but if it's not in one file the file count goes up dramatically, which is not what we want. I really need to break up the scrums into issues that aren't out of control, but I'm not sure could do that with this job. It's a messy mess of a mess, and the only way to get through it is to get stuff polished up... so that's the scoop for this week.

One new thing that just got put in is an ASCII Object with a function pointer for a destructor that allows for costless integration dynamic memory with only a small RAM overhead that is only on the stack. The coolest thing about it is for STR, the destructor can be used to print the string to whatever source you want! I had to change the filenames of the files that have templates in them to start with T because it's less confusing and quicker to find.

Other than that the build time has gone from over a minute down to a matter of seconds from using the C ABI; #Wiinning

Update 2018/7/4

I just got it to compile. I've been having some stupid issues with KABUKI inline functions. I'm having some weird errors with the hidden templates, 1.) the compiler doesn't detect some of the hidden templates impls 2. The debugger detects a 0xf...f overflow but call stack crashes at the hidden template wrapper function and not in the function where the crash is occurring (WIERD!) 2.) the KABUKI inline functions have been causing problems and 5 of them had to be removed to fix linker errors from hidden template bugs. It's done though, it's just got some lurkers.

Add 8 Queens AI Demo.

The _::Library class allows you to edit any of the ASCII Data Types. There is a single templated class that can read and write any of the POD types to and from Sets, Stacks, and Arrays. The templated object gets pushed on the Crabs Stack and the Controlling Room can then access the memory and pop the Variable object..

Dictionary has most of the code working but needs the insert and remove functions debugged.

The Library class wraps the ASCII Object Types with a _::Operand and allows Script to interact with the ASCII Data Types.

After we are able to auto-generate the stdafx.h file, the next step is to do a dumb rename of all of the #include that also renames all of the files and folders.

I'm having a problem writing Fastest Method to Print Integers and Floating-point Numbers article because there is so much stuff in Crabs that it is not acceptable to release nor is it required for the paper, and I've been forced out of necessity and convenience to make f2 it's own beast and decouple it from crabs. f2 is now SEAM_0_0_0 and it contains the following files:

• kabuki
  • f2
    • align.h
    • assembly.h
    • binary.h
    • config.h
    • console.h
    • f2_align.cc
    • f2_binary.cc
    • f2_console.cc
    • f2_test.cc
    • global.h
    • public.h
    • random.h
    • stdafx.h
    • stdafx.cc
    • tbinary.h
    • talign.h
    • ttest.h
    • test.h

In order to refresh a library, one must first have git installed, then second #Sloth needs to clone the git repo using console commands, then perform a series of steps to transform the library. One needs to automate Issue Driven Development on GitHub and BitBucket so all git commands needs to get Script wrappers.

Functionally the Slot is identical to a Strand only there is one additional pointer. Given a single additional memory copy compared to the width of the string having slow byte writes this overhead should be negligible but will 100% definitely significantly speed up writing to sockets by eliminating an extra expensive string copy.

Update

This feature got scrapped because it was too much code and I just went with writing to a buffer for now.

It's been a nightmare implementing this last batch of changes so we're not tied down to printf for printing things right-aligned. I'm please to announce, I just fixed the bugs!!!

ASCII Data Types are perfect for using in printf %format. The printf is mapped to ::_::Printf, hiding the printf implementation and only exposing va_arg to the public API (because it is a language feature).

The ASCII Object Data Types need get moved to SEAM_1_3 and everything else pushed up one seam because the ASCII Data Types seam is in between the crabs print functions and the slots.

Once all of the source code for a module has been moved into appropriate folders, a dumb script needs to strip out the #include for headers that may be precompiled, the name of the header added to an ASCII StringArray and then at the end the StringArray needs to dump out an auto-generated stdafx.h file for all of Kabuki Toolkit.

The only way I can figure to print hex using the operator<< is to use a data structure that gets passed back by value.

The List class works similarly to the Book and Dictionary for reading and writing tuples. You need to pass in a type and a pointer to the data to read/write. You need to have a buffer setup so you can accept values large enough depending on what types you've added. List is not sorted so the insert functionality can be shared with the Stack class.

Other updates on this commit include updates to the Printer. Printer now is passed by and back by value not reference. The printer is a 2 pointer data structure, and thus may be passed back on Intel systems using the EDX-EAX pair and back from registers R0 through R3 on ARM, so pass by value is the correct pattern to use. This greatly improves the performance of the text algorithms.

In order to print to the console the _::Console class was added. The Console class is a templated that statically allocates a buffer, maps a Printer to the begin and end of the buffer, and the buffer now exists for the duration of the string of overloaded operator calls. The size of the buffer is set in the assembly.h file. The syntax is:

_::Console<16>.Out () << "Hello world!";

// COUT is #define COUT ::_::Console<> ().Out ()
COUT << "Testing " << 1 << ", 2, " << 3;

In order to access the internet to #Sloth both the serial, midi, and hmi libraries we need the internet, and we have to use the Sloth to automate the process because it's too tedious to do it by hand and the libraries will get updated. The ENTIRE toolkit has to get built with the Sloth, and the first place to start is by moving one file from one folder to another.

The test harness needs to have a test text file with some string we can read to verify file integrity.

The design of the round-robin scheduler should be something like the JavaScript V8 Engine. The software goes through all of the doors connected to the system and scans a maximum number of bytes per door before circling to the next door provide some fairness to execution.

A standardized keyboard is a platform feature similar to how a filesystem is a feature of a platform.

This was my first professional engineering project and newbed it out. I rag-tag submitted commits without any Issue attached to it. This is now a major eye burned now that I figured out my fault. Sorry.

A list of all of the APIs needs to be compiled and create a prototype Sloth Script API to download the repos.

The ASCII Map class is a set of type-value tuples. No work has been done on this class yet. The memory layout can be found in the Script Specification RFC.

I need to get the ASCII data structures working to do matrix math with (specifically the array and stack), so the data structures are all getting moved to the beginning of the SEAM_0_0_3 unit test.

A loom if you look at it is actually an array of strings. It's basically an ASCII Table without a hash table.

The first step is to play a PCM wave file and implement standard audio DAW transport controls.

Cache pages are commonly 2KB and a cache line is commonly 64 bytes. The first cache-page aligned 64-byte cache line needs to be jam-packed with inter-process communication master controller variables, possibly using the rest of the cache page for a TX Inter-process Portal. The goal of the design is to iterate through the buffers sequentially and do some processing on each Door in the wall so that the next page can load in RAM while we're scanning bytes.

I figured out you can index each module by seam number 1 through N, and use a macro to target debug info for that seam. This method the FREAKING AWAZING because you can peal back the layers to the core and debug the seams sequentially. Combine with Issue Driven Development and you've got a big time home run!!!

The hash functions work great in the Book but getting the data out hasn't been as easy because books may have multiple types and this feature is not supported by the C++ language.

The Console isn't working out right now. I'm not sure exactly what is going to happen but I"m just trying to get the original unit test working again.

Most of the kabuki::toolkit::hmi worked before but unit test got ported to CppUTest. The macros just need to get changed and the data structures updated to ASCII Objects.

In order to move an entire folder, we need to make a list of the files with an ASCII String List of files to copy. We need to read the directory contents into a StringList, print them out with the Printer, and move the list to another folder.