Click here to Skip to main content
Click here to Skip to main content

The time machine

, 9 May 2012
Rate this:
Please Sign up or sign in to vote.
Long time strategy of software design and development.

Time machine

Useful links

1. Introduction

Recently one aviation designer told me that he had a lot of ideas. However his collagues threatened him with a madhouse. It is a typical reason for Russian immigration. I was not threatened with a madhouse by my colleagues found that my ideas are stupid. The best chance had persons which did not have any ideas. Now designer is 60 years old, and he is former designer. I would not like his destiny for myself. I would like implementation of my ideas. But I understand that waiting for better time is not good way. Men from above picture returned to past for fixing past bugs. But reality does not support this option. Past bugs cannot be fixed. So I invented "The time machine", for future. I did not know my future. However I would like have good software for my unknown future. Any good software should support Change Pattern and Change Pattern paradigm can be regarded as the time machine. However my time machine predicts time by decades. The most important was usage of Category Theory as main idea. I shall write a lot about it. In this article some particular ideas are described. My invention of time of time machine has three purposes. Besides time machine as itself I would like to show an example for talents. If talent did not have opportunity for implementation of his ideas, then he/she can invent time machine. Moreover I would like to show a good style of software development. At 2002 I was engaged by 3D graphics. I had need for multiwindow mode. De facto DirectX did not support multiwindow mode. So I should use OpenGL. I found that high coupling to OpenGL is not good idea. Later I found that Autodesk 3ds Max can use both OpenGL and DirectX. I developed abstract layer for 3D Graphics for future. A lot of years I was not engaged by 3D Graphics. At 2010 I had resumed 3D Graphics development, and implemented WPF implementation of abstract 3D Graphics level. I found that high coupled to OpenGL software could not be adapted to other 3D Graphics technologies. I had no need abstract layer in present, however I need it in future.

2. Background. Metadriver

Math contains levels of theories. First level arithmetic contains theorems about integers. Second level theorems (metatheorems) are theorems about first level theorems. There third arithmetic, forth one, etc. The duality theorem concerns to theorems and therefore it is metatheorem. In this chapter metadriver is discussed. Following code can be regarded as metadriver. This code is looking for singletons of objects which implement one interface:

        /// <span class="code-SummaryComment"><summary>
</span>        /// Gets interfaces from assembly (Searching of driver assembly)
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><typeparam name="T">Interface type</typeparam>
</span>        /// <span class="code-SummaryComment"><param name="assembly">Assembly</param>
</span>        /// <span class="code-SummaryComment"><returns>Interface objects</returns>
</span>        public static IEnumerable<T> GetInterfaces<T>(this Assembly assembly) where T : class
        {
            Type[] types = assembly.GetTypes(); // Assembly types
            string st = typeof(T).FullName;     // Interface full name
            foreach (Type t in types)
            {
                Type ti = t.GetInterface(st);   // Gets interface
                if (ti == null)
                {
                    continue;
                }
                FieldInfo fi = t.GetField("Singleton"); // Gets Singleton field
                if (fi != null)
                {
                    yield return fi.GetValue(null) as T; // yeild Singleton
                }
            }
        }
    

Following code snippet contains search of singletons in a set of assemblies

         /// <span class="code-SummaryComment"><summary>
</span>        /// Gets interfaces
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><typeparam name="T">Interface type</typeparam>
</span>        /// <span class="code-SummaryComment"><param name="directory">Directory</param>
</span>        /// <span class="code-SummaryComment"><returns>Interface objects</returns>
</span>        public static IEnumerable<T> GetInterfaces<T>(this string directory) where T : class
        {
            string[] fn = Directory.GetFiles(directory, "*.dll");   // Dll files
            Assembly[] ass = AppDomain.CurrentDomain.GetAssemblies(); // Current domain assemblies
            List<string> l = new List<string>();
            foreach (Assembly a in ass) // Looking for objects in loaded assemblies
            {
                l.Add(a.Location);
                IEnumerable<T> en = a.GetInterfaces<T>();
                foreach (T t in en)
                {
                    yield return t;
                }

            }
            foreach (string f in fn) // Looking for objects in directory
            {
                if (!l.Contains(f))
                {
                   IEnumerable<T> en = Assembly.LoadFile(f).GetInterfaces<T>();
                   foreach (T t in en)
                   {
                       yield return t;
                   }
                }
            }
        }

        
        /// <span class="code-SummaryComment"><summary>
</span>        /// Gets interfaces from base directory
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><typeparam name="T">Type</typeparam>
</span>        /// <span class="code-SummaryComment"><returns>Interfaces</returns>
</span>        public static IEnumerable<T> GetInterfacesFromBaseDirectory<T>() where T : class
        {
            return AppDomain.CurrentDomain.BaseDirectory.GetInterfaces<T>();
        }
         

In many cases one driver only is needed. Following code contains looking for a single driver:

         /// <span class="code-SummaryComment"><summary>
</span>        /// Gets first interface object
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><typeparam name="T">Type of interface</typeparam>
</span>        /// <span class="code-SummaryComment"><param name="directory">Directory</param>
</span>        /// <span class="code-SummaryComment"><returns>First object</returns>
</span>        public static T GetFirstInterfaceObject<T>(this string directory) where T : class
        {
            IEnumerable<T> en = directory.GetInterfaces<T>();
            foreach (T t in en)
            {
                return t;
            }
            return null;
        }
 
        /// <span class="code-SummaryComment"><summary>
</span>        /// Gets first interface object
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><typeparam name="T">Type of interface</typeparam>
</span>        /// <span class="code-SummaryComment"><returns>First object</returns>
</span>        public static T GetFirstInterfaceObjectFromBaseDirectory<T>() where T : class
        {
            return AppDomain.CurrentDomain.BaseDirectory.GetFirstInterfaceObject<T>();
        }
         

Instruction of above code usage is very simple. Dynamic link library file (files) should be copied to base directory of current domain.

3 Applications

3D Graphics

Following code represents common 3D Graphics interface:

     /// <span class="code-SummaryComment"><summary>
</span>    /// Factory of 3D objects and cameras
    /// <span class="code-SummaryComment"></summary>
</span>    public interface IPositionObjectFactory
    {
        /// <span class="code-SummaryComment"><summary>
</span>        /// Creates  3D object
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><param name="type">Object's type</param>
</span>        /// <span class="code-SummaryComment"><returns>The object</returns>
</span>        object CreateObject(string type);

        /// <span class="code-SummaryComment"><summary>
</span>        /// Creates new camera
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><returns></returns>
</span>        Camera NewCamera();

        /// <span class="code-SummaryComment"><summary>
</span>        /// Creates editor of properties of camera
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><param name="camera">The camera</param>
</span>        /// <span class="code-SummaryComment"><returns>The property editor</returns>
</span>        object CreateForm(Camera camera);

        /// <span class="code-SummaryComment"><summary>
</span>        /// Creates editor of properties of visible object
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><param name="position">Position of object</param>
</span>        /// <span class="code-SummaryComment"><param name="visible">Visible object</param>
</span>        /// <span class="code-SummaryComment"><returns>Editor of properties of visible object</returns>
</span>        object CreateForm(IPosition position, IVisible visible);

        /// <span class="code-SummaryComment"><summary>
</span>        /// Type of camera
        /// <span class="code-SummaryComment"></summary>
</span>        Type CameraType
        {
            get;
        }

        /// <span class="code-SummaryComment"><summary>
</span>        /// Creates label on desktop
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><param name="obj">Object for label</param>
</span>        /// <span class="code-SummaryComment"><returns>The label</returns>
</span>        IObjectLabel CreateLabel(object obj);

        /// <span class="code-SummaryComment"><summary>
</span>        /// Creates label of visible object
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><param name="position">Position of object</param>
</span>        /// <span class="code-SummaryComment"><param name="visible">Visible object</param>
</span>        /// <span class="code-SummaryComment"><returns>Editor of properties of visible object</returns>
</span>        object CreateLabel(IPosition position, IVisible visible);
         

        OpenGL and WPF implementations of this interface are developed at present day. Following class diagram represents these implementations:

Every implementation class contains Singleton field as it is presented below:

     /// <span class="code-SummaryComment"><summary>
</span>    /// WPF implementation of 3D Graphics
    /// <span class="code-SummaryComment"></summary>
</span>    public class WpfFactory : PositionObjectFactory
    {
        #region Fields

         /// <span class="code-SummaryComment"><summary>
</span>        /// Singleton
        /// <span class="code-SummaryComment"></summary>
</span>        public static readonly WpfFactory Singleton =
            new WpfFactory();

        #endregion

        #region Ctor

        /// <span class="code-SummaryComment"><summary>
</span>        /// Private default constructor
        /// <span class="code-SummaryComment"></summary>
</span>        private WpfFactory()
        {
        }

        #endregion
         

Both these implementations are contained in different dynamic link libraries.

N Technology Implementation class Dynamic link library file
1 OpenGL OpenGLFactory InterfaceOpenGL.dll
2 WPF WpfFactory WpfInterface.UI.dll

Following code snippet represents selection of 3D Graphics interface:

         /// <span class="code-SummaryComment"><summary>
</span>        /// Global factory
        /// <span class="code-SummaryComment"></summary>
</span>        public static IPositionObjectFactory BaseFactory
        {
            get
            {
                if (baseFactory == null)
                {
                    baseFactory =
                        AssemblyService.StaticExtensionAssemblyService.GetFirstInterfaceObjectFromBaseDirectory<IPositionObjectFactory>();
                }
                return baseFactory;
            }
         }

So if we would like use OpenGL technology then InterfaceOpenGL.dll file should be copied to base directory etc. More information about applications of 3D Graphics is contained in article devoted to virtual reality.

3.2 Scientific data

3.2.1 Scientific data processing

Database can be good warehouse of scientific data. Otherwise user of software should have good interface for data access. Let us consider sample both data access and data processing. In this sample we have following two nonlinear functions f1, f2:

Parameters a, b, c, d, g of these functions are not known. Values of functions and variables x, y, z are stored in database which have following scheme:

Parameters with "id" prefix are id of values of variables. Meaning of database parameters is clear. Following SQL Query provides retrieving of values of variables and functions.

SELECT x.x, y.y, z.z, f1.f1, f2.f2 FROM f1, f2, x, y, z WHERE x.Id = f1.Idx AND y.Id = f1.Idy AND z.Id = f1.Idz AND f1.Idx = f2.Idx AND f1.Idy = f2.Idy AND f1.Idz = f2.Idz  
           

Now let us consider full solution of this task. Following picture contains components of this task:

.

The Data component performs Database query. Properties of Data are presented below:

Properties of this component are clear. The Sql Server driver is used. Other properties are connection string and SQL Query. The Iterator component can be regarded as cursor. The Formula component contains definition of f1, f2. Properties of Formula are presented below:

Parameters a, b, c, d, g are constants of formulae. Variables x, y, z correspond to retrieved from database real numbers. The Processor component performs definition of above constants. Properties of Processor are presented below:

Left panel of above picture means that we would like to define constants a, b, c, d, g of Formula component. Right panel means that we would like approximate retrieved from database f1, f2 by Formula_1 and Formula_2 of Formula. Left and right parts of below picture contain prior and posterior values.

3.2.2 Database drivers

In above sample Sql Server has been used. It is clear that scientist can use Oracle for same purpose. Software should support following options:

Drivers should be contained in different assemblies. Low coupled software should separate Oracle driver from SQL Server one since good software should support following options:

  • Support of Oracle;
  • Support of SQL Server;
  • Support of both Oracle and SQL Server;
  • Do not support any database;

So soft should contain abstract database layer. Following code represent this abstract layer

    /// <span class="code-SummaryComment"><summary>
</span>    /// Factory for creating data set metadata from connection
    /// <span class="code-SummaryComment"></summary>
</span>    public interface IDataSetFactory
    {
        /// <span class="code-SummaryComment"><summary>
</span>        /// Name of factory
        /// <span class="code-SummaryComment"></summary>
</span>        string FactoryName
        {
            get;
        }

        /// <span class="code-SummaryComment"><summary>
</span>        /// Creates connection
        /// <span class="code-SummaryComment"></summary>
</span>        DbConnection Connection
        {
            get;
        }



        /// <span class="code-SummaryComment"><summary>
</span>        /// Command
        /// <span class="code-SummaryComment"></summary>
</span>        DbCommand Command
        {
            get;
        }

        /// <span class="code-SummaryComment"><summary>
</span>        /// Gets metadata data set from connection
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><param name="connection">The connection</param>
</span>        /// <span class="code-SummaryComment"><returns>The metadata data set</returns>
</span>        DataSet GetData(DbConnection connection);

        /// <span class="code-SummaryComment"><summary>
</span>        /// Gets metadata data set from connection string
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><param name="connectionString">The connection</param>
</span>        /// <span class="code-SummaryComment"><returns>The metadata data set</returns>
</span>        DataSet GetData(string connectionString);

        /// <span class="code-SummaryComment"><summary>
</span>        /// Data adapter
        /// <span class="code-SummaryComment"></summary>
</span>        IDbDataAdapter Adapter
        {
            get;
        }

        /// <span class="code-SummaryComment"><summary>
</span>        /// Creates type from metadata row
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><param name="row">The metadata row</param>
</span>        /// <span class="code-SummaryComment"><returns>The type</returns>
</span>        Type GetTypeFromRow(DataRow row);

        /// <span class="code-SummaryComment"><summary>
</span>        /// Table name in metadata
        /// <span class="code-SummaryComment"></summary>
</span>        string TableName
        {
            get;
        }

        /// <span class="code-SummaryComment"><summary>
</span>        /// Column name in metadata
        /// <span class="code-SummaryComment"></summary>
</span>        string ColumnName
        {
            get;
        }

        /// <span class="code-SummaryComment"><summary>
</span>        /// Is nullable in metadata
        /// <span class="code-SummaryComment"></summary>
</span>        string IsNullable
        {
            get;
        }

        /// <span class="code-SummaryComment"><summary>
</span>        /// Gets string representation of type
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><param name="type">The type</param>
</span>        /// <span class="code-SummaryComment"><returns>The string representation</returns>
</span>        string GetStringFromType(Type type);


        /// <span class="code-SummaryComment"><summary>
</span>        /// Generates statement from desktop 
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><param name="desktop">The desktop</param>
</span>        /// <span class="code-SummaryComment"><returns>The statement</returns>
</span>        string GenerateStatement(IDataSetDesktop desktop);

        /// <span class="code-SummaryComment"><summary>
</span>        /// Gets object type
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><param name="column">Column</param>
</span>        /// <span class="code-SummaryComment"><returns>The type</returns>
</span>        object GetObjectType(DataColumn column);

        /// <span class="code-SummaryComment"><summary>
</span>        /// Generates script
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><param name="column">Column</param>
</span>        /// <span class="code-SummaryComment"><returns>Script</returns>
</span>        string GenerateScript(IColumn column);

        /// <span class="code-SummaryComment"><summary>
</span>        /// Generates create script
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><param name="table">Table</param>
</span>        /// <span class="code-SummaryComment"><returns>Script lines</returns>
</span>        List<string> GenerateScript(ITable table);

        /// <span class="code-SummaryComment"><summary>
</span>        /// Generates creation script from metadata
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><param name="metaData">Meatadata data set</param>
</span>        /// <span class="code-SummaryComment"><returns>Creation script</returns>
</span>        List<string> GenerateScript(DataSet metaData);

    }        

List of database drivers can be extended. Now ODBC, Sql Server and Oracle drivers are already developed. Following picture represents class diagram of these drivers.

Following code represents usage of these drivers:

        /// <span class="code-SummaryComment"><summary>
</span>        /// Initialization of database drivers
        /// <span class="code-SummaryComment"></summary>
</span>        /// <span class="code-SummaryComment"><param name="path">Path of drivers</param>
</span>        void Initialize(string path)
        {
            // Gets all database drivers from this directory
            IEnumerable<IDataSetFactory> en = path.GetInterfaces<IDataSetFactory>();
            List<string> l = new List<string>();
            foreach (IDataSetFactory f in en)
            {
                factories[f.FactoryName] = f; // Dictinary of drivers
            }
            List<string> ln = new List<string>(factories.Keys);
            ln.Sort();
            names = ln.ToArray(); // Ordered names of drivers
        }        
If Oracle driver is used instead Sql Server one then properties of Data would be changed by following way:

In above picture driver and connection string are changed. In some cases change of query is required.

3.3 Other samples

List of samples can be extended. However general idea is already clear. Other samples shall be described in future specific articles

Points of Interest

I do not know what is more useful, my code or inspiration of you for good work even if you are threatened with a madhouse.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

About the Author

Petr Ivankov
Architect
Russian Federation Russian Federation
Ph. D. Petr Ivankov worked as scientific researcher at Russian Mission Control Centre since 1978 up to 2000. Now he is engaged by Aviation training simulators http://dinamika-avia.com/ . His additional interests are:
 
1) Noncommutative geometry
 
http://front.math.ucdavis.edu/author/P.Ivankov
 
2) Literary work (Russian only)
 
http://zhurnal.lib.ru/editors/3/3d_m/
 
3) Scientific articles
http://arxiv.org/find/all/1/au:+Ivankov_Petr/0/1/0/all/0/1

Comments and Discussions

 
GeneralMy vote of 5 PinmvpKanasz Robert28-Sep-12 7:19 
GeneralMy vote of 5 PinmemberMohammad A Rahman22-May-12 17:48 
GeneralMy vote of 5 PinmemberVolynsky Alex21-May-12 6:38 
QuestionInteresting, as always with Dr. Ivankov PinmemberZakPatat9-May-12 11:50 
It is nice to see you address the 'future' and sort of a 'theoretical implementation' of it Dr. Ivankov!
 
Recently, at my current employer, we had a six hour 'meeting' (utter chaos is more like it, sadly) regarding the topic of the future, theorizing non-existing but most likely required technology (including needed software/firmware/drivers on top of the hardware) to keep pace with the ever increasing complexity of designing aviation products (be it 'middleware' (think, for example, targeting systems) or complete systems (think, for example, an entire UAV/UCAV, which are a lot more complex than most people think, they are not 'large remote controlled toys').
 
While the 'madhouse' bit is hardly ever an issue over here in the United States, at least on a scientist/engineer to scientist/engineer level, toward management is another story, some pretty crazy ideas were discussed causing slight friction with the somewhat more rational engineers, but diffused by informal (non-personal) jokes and bringing the crazy ideas down to theoretical concepts that might be workable while retaining the core ideas. I must admit that the theorizing of ideas that are simply not feasible (for one reason or another, be it technological or financial, or some other obstacle) is a lot more fun than just dealing with rational ideas/theories.
 
While your article is (as always?) somewhat confusing, I can see the concepts you have in mind. These are not trivial by any means, being prepared for the future is what sets a business (any business!) ahead of its competitors. On a more personal level, being prepared and able to understand the theoretical requirements the future will need puts the person ahead of his or her colleagues (which could explain the 'madhouse', the other people feel threatened perhaps? This is certainly the case over here, on all levels of business).
 
I think, however, that the future is hard to translate into 'current' software. While I, of course, can not cross certain boundaries, I can say that we are going for the simulation model approach, using super computers (or desktop computers, as speed is the main limitation, accuracy being a lesser limitation due to the nature of these theories, 256-bit, using one or more GPUs, is plenty for the basics) to attempt to calculate the needs of the future, or perhaps better, to calculate whether or not the future needs 'an idea' and whether or not 'the idea' is feasible within certain time frames and many other factors. The simulation models will only take a small bit of data in order to encourage the models to use prediction (based on many many years of history as well as other information, much of it also calculated). A slightly different approach, but early prototyping is proving to be quite accurate although many issues need to be ironed out.
 
One thing I noticed in your article is the 'Russian immigration' bit. I am guessing that you are somewhat frustrated with this 'trend'? I admit that I am hardly an expert on this (considering I am not Russian nor working in Russian aerospace, in fact, technically, we're competitors in this field) but you seem to imply that hostility of other scientists/engineers towards those with ideas they don't have is pushing your experts to move to other nations. Now, assuming that pay is higher, standard of living is possibly higher, and new ideas are often embraced by corporations, and, of course, the access said corporations get to Russian Federation expertise (across the board, not just aerospace!) I always thought that these corporations simply 'buy' your experts away from Russia. Seems there is more to it than just that. I certainly don't see this happening around me, apart from people moving from one corporation to another, not down-right emigrating to another nation (although it happens, I myself being one of these people (I am not American), but that was for more practical reasons than being 'pushed by peer pressure')!
 
Either way, as always Dr. Ivankov, highly interesting material, food for thought and a slight touch of 'humanity' in a cutthroat field (and this is much appreciated, our area of work severely lacks 'humanity', which seems to be one of the few things in common between the United States and Russia when it comes to this particular field).
 
I do suggest that you attempt to make the article itself a bit more 'digestible', it really is rather confusing at the moment. Basically, it feels like there are important pieces missing, which is understandable considering the topic, but a bit more information (even if it is highly theoretical) in between would certainly help. Oh, and your English is rapidly improving, impressive, considering the complexity of your articles.
GeneralI'm not sure... Pinmemberii_noname_ii9-May-12 3:49 
GeneralRe: I'm not sure... PinmemberVitaly Tomilov9-May-12 7:10 
GeneralRe: I'm not sure... PinmemberPetr Ivankov9-May-12 8:13 
GeneralRe: I'm not sure... Pinmemberbitterskittles9-May-12 22:51 
GeneralRe: I'm not sure... PinmemberZakPatat9-May-12 12:12 
GeneralRe: I'm not sure... PinmemberVitaly Tomilov9-May-12 15:21 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Mobile
Web03 | 2.8.140709.1 | Last Updated 9 May 2012
Article Copyright 2012 by Petr Ivankov
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid