Evobolics is Evolutionary Development Shop

We research, build and implement .NET applications and web apis to enable software to evolve. Ideally applications and web services can be created and interconnected without having to write additional code for each feature. In reality, developers have to construct each feature from scratch each time they want to add new business functionality. This is labor intensive and creates an ever expanding code base. The result is that thousands, if not millions of development hours are needed each year to write the ever growing and changing number of business features. Thus we are researching and engineering how systems that can be augmented without continuous hands on development and refactoring.

Providing True Evolutionary Architectures

It is time to move beyond Object Oriented and Functional Programming. We are transforming how software is designed and written to enable continuous change. Biology and computer science are subject to the same laws of information. With these same constraints biological programs have been able to evolve continuously for billions of years, but computer programs often need to be rewritten from scratch every three to ten years. The result is a lot of time and energy is wasted. We found out if we structure applications more like biological systems, we can greatly reduce these costs. Bacteria don't need billions of dollars to keep up with our antibiotic development efforts.

Structuring Applications to Evolve

Applications and the method of developing new features both have to be structured to enable applications to gradually change over time. This means not only just breaking applications into pieces, but changing how code is structured in memory and enabling features to be created without having to always directly involve a developer. The result is that it is possible to create applications that can update, adapt and evolve in real time without without having to be restarted.

Enabling Code to Change

Code can be enabled to change by modifying how we are writing OOP programs. Right now developers mix methods and properties into the same classes. When this happens, it is not possible to quickly update an application's methods without having to replace all the objects in memory that hold data. Thus, generally speaking, as there are exceptions, objects holding onto data need not have methods directly declared upon them. Biological systems perform this same separation via the use of enzymes and substrates.

Enabling a Processes to Change and Memory Stability

For a process to continuously change, it must be able to continuously load new assemblies (code modules) and unload modules that are no longer needed. This can done if programs always use and load collectible assemblies. Not all assemblies are though. Thus, Evobolics has created a recompiler to transform static assemblies into collectible assemblies. The result is memory stability can be achieved.

Programming in Parallel

Biological systems are plentiful and bacteria are able to come up with new novel solutions by working collectively together. Bacteria break up their 'programs' / genomes into very small pieces and exchanges the pieces with each other. The result is they program in parallel and each instance of a program shares in the development costs. This in contrast to how most development shops work where code is created by a relative few individuals and then disseminated in a spoke an wheel fashion.

Enabling Parallel Development

Parallel software development can be accomplished by 1) breaking a program into genes, 2) enabling a program to be changable in realtime, then then finally by enabling non-developers and end users to change the code. For every function and groups of functions, editors neeed to be created. These editors enable non-developers to create and modify genes. Editors can be simple or as complex as needed, and are themselves genes that can be edited by other editors. This last piece of the puzzle allows for modifications to be made to a program without having to hire costly development resources. Test cases also go with the code and editors.

Sharing is Important

Once one user has modified a program using an editor, those changes need to be shared so others can capitalize on those changes. By using a combination of social networks and software stores, an ecosystem of software genes can be created that allows for new functionality to be bought and sold. The result it is possible to edit large applications like they were individual apps. The combination of social networks and dissemination small program pieces can enable users to have have large desktop applications totally customized to their needs. New genes can be found by search, but by also looking at what your friends have bought. Users in the same environment often have the same problems and need the same solutions.

Moving Beyond Apps to Pathways and Ecosystems

Once apps can evolve, we need to move to creating and sharing information pathways. Today it takes time finding the correct programs, api, and people to network together. By treating pathways as genes too, we can share and evolve the application interconnections in addition to just the application. For example it is not only important to evolve a system to create a timesheet, but to also know what are the best systems to submit timesheets too and what banking systems are the best to manage the payment of invoices.

Decreasing Time to Market and ROI; Reduce Risk

The result of using this strategy is that developers can write, produce, sell and buy individual genes and pathways. This enables a developer and a development company to be able to start receiving revenue from their development efforts in hours, not months or years. This drastically increases ROI and decreases the risks involved in writing software. It also creates a sustainable open source software economy.

Want your programs to evolve too?

If you are intrigued by this software approach and want to structure your programs to evolve in real time too, contacts us at info@e01d.com and we can help. We build evolving metabolic pathways for software.

Enabling Continuous Programmatic Change

Enable your program to continuously auto update without restarting or writing IL by hand. Our assembly converter is now in BETA. Try it out.