Application.Atomatrix: Dynamic Virtual Machine

We don't see that published by Big Engineering, but someone tried the cybersquat on the name. Actually, more than one someone. Whomever did, they even made their game out of the prior art without any credit to originality. With corporate funds behind the maintenance cost, it was easy for them, as some viral app.

It did the job. It pushed any sense of originality off the first few search page results. That made someone look more official. It didn't hurt until further interpretation by popular opinion.

Luckily, CEOs do have more sense than that, not always at the speed beyond said cost. That compares to things we know that works and things we know with ill-classification.

The reality of the dynamic virtual machine is like the autonomous metallic blob that moves like liquid and hardens like the T-1000 model. That sounded too sci-fi'ish.

The logic flow, in the code below, proved it is not so said fiction. Whereas the previous Orbs, as its primary trinary, are of its own raw extensibility; the atomatrix is the secondary trinary, for six-dimesional conception, of said objects. Maybe that did not matter until more engineers wished their virtual machine had more than thermodynamics within the limits of their machinery.

I thought the type-system put into maintenance mode is valuable for justification of Orbs, and for everything else you need this much more for its dimensional comprehension. Some VMs became solid and were never virtual as said, and others kept the polymorphic quality and/or dynamic language run-time.

[Note that the Atomatrice namespace further extends the Orbs namespace, and the logic flow is very similar, but it is different because types are not another level of indirection. Someone wants names for each atom ever known.]

using System ;

namespace Application.Atomatrice
        {
        using Application.Orbs ;
        public class Atomatrix : Orb
                {
                protected Atomatrix
                        precursor ,
                        intranet , z ;
                public Atomatrix Precursor
                        {
                        set
                                {
                                if( precursor == value.precursor )
                                        return;
                                if( value.precursor != null )
                                        {
                                        if( value.precursor.intranet == value )
                                                value.precursor.intranet = value.z ;
                                        else
                                                {
                                                Atomatrix a = value.precursor.intranet ;
                                                while( a.z != value )
                                                        a = a.z ;
                                                a.z = value.z ;
                                                }
                                        }
                               
                                value.precursor = precursor ;
                               
                                if( precursor != null )
                                        {
                                        value.z                        = precursor.intranet ;
                                        precursor.intranet        = value ;
                                        }
                                }
                        }
                public Atomatrix( Orb orb )
                        {
                        Orbit = orb ;
                        }
                }
        }
namespace Application.Orbs
        {
        using Application.Atomatrice ;
       
        public partial class Orb : Orbital
                {
                public Orb( Atomatrix a )
                        {
                        orbit = (Orb) a ;
                        }
                }
               
        public class Atom : Atomatrix where T : Orb
                {
                static protected Orb beta = new Orb() ;
                       
                public Atom() : base( beta )
                        {
                        }
                }
        }