I was walking to class today thinking about the problems with current software design and what could be improved. Currently coding is just writing text files that are parsed and compiled. Integrated developer environments like Microsoft Visual Studio are just fancy text editors with some nice functionality – such as debugging or code tracing
Logical Databases to Store Functions
If code was instead organized into relational databases, with semantic information included in addition to the actual code of functions, the process of coding could greatly benefit. The relational database could store useful library functions and algorithms as well. Instead of copying and pasting important algorithms into code, they could simply be referred to in the database.
Datatype specifications would need to be worked out. All stored algorithms would need to follow specific formatting in order to integrate well with custom written code and other library functions. Semantic information about functions would also be included in the database. If each piece of code included searchable comments, parameter specs and even algorithmic breakdowns, these variables could be searched for in the database. During coding, a programmer could search the database for commonly used processes and algorithms and simply open up the database record without even looking at any code. For example, I could search for a fibonacci algorithm that took in an integer and returned a linked list of strings. The search would also tell me the function takes log n to run and uses recursion.
Dynamic Code Object Diagrams
Dynamic visualization of code could also be done. UML diagrams could be created based on the functions and connections between algorithms. This could then be transformed into a diagram that shows the links between functions.
Combined with the usefulness of the database, a programmer using this system could simply drag and drop blocks of functions, linking them together with designated parameters. Programming would no longer involve writing or copying texts, but manipulating abstract code objects. For very large-scale programs, this visualization would be invaluable.
Database searching techniques could also be utilized if semantic information was incorporated into the functions. Bottlenecks in code could easily be tracked down. Tracing code would no longer involve setting breakpoints in text, but watching a cursor snake through the UML of the program.
Source control could also be incorporated into this system, and it would be very simple to include multiple versions of functions and files. Switching between versions of functions could be done on the fly, instead of checking out a different file and recompiling.
The memory layout of datatypes could also be visualized and manipulated in a similar way. Memory would be smartly allocated based on the job the data needed to do, and the database functionality would easily be able to search and trace through the code path to determine this.
Compilation would build code in objects that interact with each other. Of course the final product would be compiled and optimized much as it is done today, but the actual development of software would work better without full 30 minute builds.
Applications of the future could be developed orders of magnitude faster. Standardized UI sets could be bought and sold and easily integrated as front ends. 3D engine code, AI algorithms, and Networking protocols – all these could be packaged into relational database sets.
Dynamic visualizations of the parameter sets and datatypes would easily be searchable and algorithms could even be developed to “link” up differing data standards. Small teams with a much smaller budget could develop games. Simply buy or use the open source version of each of the important components. All of the energy could be focused on creating the new and innovative content, not creating the framework.