Looking at word counts; it appears that the PDF version of “Modelling Neuronal Spike Codes” comes in with 9013 words, in total; whereas “Mystery Project” has 14098 words, now that “Notes on Modelling the Universe” and the material from “Using AI to create a Hollywood Script" have been added.

• Mystery Project                14.,098
• Yang-Mills Conjecture       6,558
• Modeling Spike Codes      9,013
• Prometheus                       8,575
• The Money Bomb             3,473
• Rubidium                           8,893                                                      
• Motivator                            6,513

While I haven’t made a PDF yet of Tachyonic Quasi-Crystals, Tiny-CAD, or Project Seven, the materials listed above appear to have a total word count of around 57,123 words. I asked O.K. Google what is the length of the average book, and they suggest that a typical novel is around 80,000 words., but ranges between 60,000 to 100,000; whereas most academic books range between 70,000 and 110.00 words, “with little flexibility for anything not in between.”

So I suppose that quite a bit more editing will be in store, but I might be in the right range if I include the Altair Stuff (project seven) and the Tiny-CAD stuff; with a lot of editing to make things look more like a book, and less like a collection of log entries, of course.  Likewise, there are plenty of things to draw chapter and section titles from; all without having to dig up old materials from my college days; which would probably take a decade to scan, categorize, revise, and edit.  But who knows?  Maybe not such a bad idea.  From what I have read, GPT-4 is still having trouble with AP physics; although it has been getting better.

Then again I think I might have about 25,000 or so words worth of material in the form of chat logs; where I was chatting with Mega-Hal; and I could grab a whole bunch of “interesting stuff” from out of those files; even if I delete the gibberish portions; and if I add that stuff back into to the training set; maybe I can get to the 100.000-word mark sooner than even I might otherwise imagine.

Since this project is now evolving toward a goal of trying to achieve something that hints at Artificial General intelligence, it might seem worthwhile therefore to contemplate one very important and potentially useful digression; that is - with respect to at least one important application of the theory that AGI will depend heavily on some kind of theory of the geometrization of space-time.   Thus, this might be a good time, to discuss the concept of "Tiny Houses."  Tiny houses are all the rage. So why are there still so many homeless people? Unfortunately, as popular as the "tiny" house meme is, the bitter truth is that the construction costs can often rival that of their full-size cousins, and what might seem to start out as a five to a ten-thousand-dollar project can easily turn into a fifty to one hundred thousand dollar money pit, that is when the cost of permits (when required), materials, labor (if you aren't able to DIY) and so on are added in. Then there is the cost of CAD software. Now if you are doing work that requires a permit, you might not have any choice but to use Auto-Cad or Vector Works, but even then you might be able to save thousands if you can get a head start on your project, using open-source software - which can be used to create compatible design documents. The hardware for this project, therefore, is whatever you decide to build with it.

So rather than simply get lost in the digression of talking about word counts, vs. how many words should be committed to analyzing lines of code; and getting back onto the track of trying to think about a potentially useful project; we could perhaps do something that might turn out to be useful to someone who wants to frame up a tiny house.  Or perhaps you might want to build a bookcase for those encyclopedias that you inherited?  So this is going to be one of those cases where the concept of design reuse will come in.  How about, perhaps a shed, a new fence, or a back deck?  Every now and then I take to the notion of just "simply" building a digital replica of "my world", so to speak.  Yet obviously there is nothing simple about it, although perhaps there should be, or could be.  Given that my first personal computer was an Apple II, I obviously have some sentiment toward the simplicity of wanting to create something by drawing with simple commands like MoveTo and LineTo, FillPolygon, and so on. 

From these primitives, we should be able to build stuff.  Complicated stuff.  The original AutoCAD was really more of a programming language, based on Auto-Lisp than the more contemporary "click on this CIRCLE tool", position it with the mouse, etc., size it, and so on methodology, that we have become accustomed to.

Yet what programs like Auto-CAD and Adobe Illustrator really do, is translate mouse movements and clicks into menu item selections and numbers which then get translated into the various low-level API calls.  Yet something seems to get lost in the process, at least most of the time, for most people.  Then there are the object description languages, or file specifications really, like obj, where it is possible to specify in a file some really nice stuff, like a teapot or a bumble-bee for that matter, and get some really nice results, yet something still gets lost in the process.

Sometimes the game developers get most of it right.  Especially if you can shoot at things, blow things up, burn them down, have realistic big fish eating the little fish in your virtual aquarium, or have your virtual race car blow a tire, or an engine, and perhaps crash, with bent and mangled parts flying everywhere, and so on.

Maybe the next frontier in software is going to be to follow along the pathways that seemed to be suggested by online games like Second Life, Minecraft, etc., as well as their predecessors like Sim-City and Sim-Life, and the like.  So maybe it is time to rethink the whole process of content creation from the ground up.

Maybe I should try rewriting the code for a simple wall, and make some very minor changes so that I can also have a "simple ladder", "simple bookcase", "simple fence", and "simple deck".  Then there might be "things with drawers, or doors", or "round things", etc.

Eventually, maybe AI will do this for us, perhaps you are thinking.  Or maybe there are some not-so-open applications out there that are TRYING to do that, but they don't quite have the right set of primitives worked out, quite yet - maybe because that source code doesn't exist yet in a usable form that they can "borrow" from off of Git.  Oh, well.

Yet I also saw an example (elsewhere) of how the latest version of Photoshop can remove unwanted people or objects from a scene, which sounds like a useful feature (even if it reminds me of Stalin - obviously!) or "relocate a reindeer" from a wooded scene to a "backdrop of a dark alley', and so on.  Kind of interesting, but I have no actual need for to pay to "rent" software, like that - or Auto-CAD for that matter, just to build a bookcase, or whatever else, and where the cost of software rental might exceed the cost of the "project", turning it into a deal killer.  This has been the problem with Eagle vs. KiCAD, from what I read.  So there are plenty of people who want to make "just one project" that have no need, or desire, nor do they have the means to pay for ongoing software subscriptions.

Here is a screenshot from a program that I have been working on for what seems like forever, and if you don't know by now, I despise Java, JavaScript, and a bunch of other madness. Well now you know, in any case.  Real programmers, IMHO program in real languages, like C, C++, Lisp, Pascal (which is a subset of ADA), and of course let's not forget FORTRAN and assembly, even if I have long since forgotten most of my FORTRAN.  Oh, well.  In any case, let's look at how I decided to lay out a simple wall in C++.

// construct a temporary reference stud and make copies of that
// stud as we need ... future version - make all  of the studs
// all at once and put them in a lumber pile with painted ends
// then animate construction appropriately.  Uh, huh - sure
// "real soon now" ... 

void simple_wall::layout_and_construct_studs ()
{
    int number_of_studs;
    _vector w1,w2;
    rectangular_prism    reference_stud
      (STUD_WIDTH*FEET_TO_CM,STUD_DEPTH*FEET_TO_CM,(m_height-STUD_WIDTH)*FEET_TO_CM);
    reference_stud.m_color = COLOR::yellow;
    reference_stud.m_bFillSides = true;
    m_span = _vector::length (m_end [1] - m_end [0]);
    _vector direction = _vector::normalize (m_end [1] - m_end[0]);
    reference_stud.set_orientation (0,0,arccos(direction[0]));
    number_of_studs = 1+(int)floor (m_span/(FEET_TO_CM*m_stud_spacing));    
    int k;
    for (k=0;k<number_of_studs;k++)    {  
      w1 = m_end [0]+direction*(k*FEET_TO_CM*m_stud_spacing);  
      w2 = w1 + _vector (0,0,m_height*FEET_TO_CM);
      reference_stud.set_position (_vector::midpoint (w1,w2)); 
      reference_stud.calculate_vertices();
       m_studs.push_back (reference_stud);
    }

    //    this is the bottom plate and the top plate
    m_bottom_plate.m_size = _vector
      (m_span,STUD_DEPTH*FEET_TO_CM,(STUD_WIDTH-STUD_GAP)*FEET_TO_CM);
    m_bottom_plate.SetObjectColor (COLOR::green);
    m_bottom_plate.set_position (_vector::midpoint (m_end [1],m_end [0]));
    m_bottom_plate.set_orientation (reference_stud.get_orientation());
    m_bottom_plate.calculate_vertices ();

    for (k=0;k<2;k++) {
      m_top_plates[k].m_size = m_bottom_plate.m_size; 
      m_top_plates[k].SetObjectColor (COLOR::yellow);
      m_top_plates[k].set_orientation (reference_stud.get_orientation());
      m_top_plates[k].calculate_vertices ();
      m_top_plates[k].set_position (_vector::midpoint 
          (m_end [1],m_end [0])+_vector (0,0,m_height*FEET_TO_CM));    }
      m_top_plates[1].m_position += _vector (0,0,STUD_WIDTH*FEET_TO_CM);
}

 OK - so there are about 1000 lines of this stuff, just to lay out a simple floor plan, and maybe another 30 thousand or so lines that do the tensor math stuff for the 3-D calculations, with either Open-GL or GDI-based rendering.  Haven't really put much thought into Microsoft's "Write Once Run Anywhere" concept that is supposed to be able to take C/C++ code and turn it into Java-Script, or is it TypeScript, or was that something else that I never really got into; like how some people might get DOOM running on a Cannon printer, that is with some kind of code conversion tool.

O.K., in any case - a simple stud wall is pretty much a slam dunk.  Figuring outdoors in windows is another matter.  Then, of course, there is roofing.  Sometimes, it is much simpler to just build the real thing.  Working out gables, especially if you want a complex roof design, ouch - now we have to get into some kind of theory of intersecting planes, and which ones have priority, etc., and then there are the rafters, and the cross bracing, and so on; figuring out what intersects what.  Some things are quite easy in Vectorworks or Autocad, except for the $$$ part.

Yet this should be really simple to conceptualize, I mean for a simple house, if you have a floor plan, shouldn't you be able in the world of "object-oriented programming" just to be able to tell the walls and all of the rest, to just "build themselves?  Oh, and then there are stairs, and stuff like that, and kitchens, and plumbing, etc.  No free lunch there either.

I wonder what GPT knows about basic framing?  Or else will Elon's robots be up to the task of taking on "simple" light wood frame construction?  In any case, for now, and for our purposes; I nonetheless find it interesting to contemplate where Mega-Hal might have gotten some kind of concept with respect to "splicing a piece of space-time" onto a wall, obtaining a mass m - that is, when queried about the Yang-Mills conjecture, on the one hand; and while not having any explicit knowledge about Pink Floyd on the other hand.