Modeling a making software

Nota de esclarecimento

Eu estou publicando esse artigo em inglês na tentativa de alcançar uma audiência maior.
O objetivo é expandir e não limitar o acesso, e caso haja demanda eu escreverei em português.

O assunto desse artigo é de interesse global e tem um viés mais técnico do que outros textos que eu tenho publicado.

Before I start, I would like to tell you that english is not my primary language so you will see creative english, non standard english also known as errors. 

I will try my best to explain the idea of “making software”.

Introduction

Technology is evolving faster and faster day after day. Some advocates that this process draw a exponential line, and by 2045 technology will have reached a new singularity that human bean will have difficulties to comprehend the surrounding technological environment.

I will present a software that is far from this reality, but it innovates in the sense that it carries facility to the end user, so he or she can write his own system without wright a line of programming code. I named this concept “making software”, as a noun not a verb.

This kind of software are not ordinary for most of the people, but will become more and more accessible, and is just a matter of time. Technology is not reaching this stage, but it has already surpassed this stage a long time ago.

The only reason this kind of software is not present in people or companies lives is because it is still possible to achieve high revenue exploring old technologies. Most of the technology that brings billions of money to the market are between ten to twenty years old.

Their lifecycle are still ongoing, but there are other advanced technologies waiting on the shelf. Technology points much more to the future than indicates the products of the actual mainstream, and this article shows what the people is going to be using in the near future to build their own systems.

I wrote this article after I developed a product called InteliForm, based on the making software concept. But this article is neither defending a theory nor it is a white paper about the product. Instead, it demonstrates InteliForm as a proof of concept (POC) of a viable theoretical product.

A making software

The concept behind the name is something that makes software. I use making software as a noun and not as a verb, something similar to vending machine and building blocks. I will use the pronoun “a” or “the” only when necessary, but making software will always mean a noun, except when explicitly the contrary.

InteliForm is the name or the product derived from a making software, and I will use it when referring to the product and not to the concept. InteliForm is a proof of concept of a making software indeed.

Software is a generic definition, and I am using this word in the context of this article, for a web based system only. Software here means a web based system where the admin user has an admin interface to control features of the software, that I will explain further along this article.

Software here does not mean a static website. The making software is not a site constructor, it delivers a dynamic web based system.

A making software is a software that makes software.

Information flow

An information flows in many directions among the participating actors in a system. Some different models of information flow have been listed here to take clear which model we are talking, when we show our model.

1. Many users send data to one actor (i.e. a company or government).
   ie: It can be used to collect data from the world to a company.
   
2. One actor spread information to a broad audience (Internet users).
   ie: It can be used to spread data from a company to the world.
   
   

3. B2B. Small audience in both sides but high aggregate value.
   ie: Sharing information or simple data between companies
   
   
   
4. C2C. Social media of any kind of business
   

The model we are going to explore, is the first one where the world, customers or people that make up any group of interest, send information to one participant. These model is about get data from the world, gather data and centralize in a database to analyse and generate information.

In this case, forms are the main interface between users and the system made by the making software, and the direction of the flow of data will be from the users to the system, where the owner of the system can be a company, a person, a government department or anything else.

The POC can be used in the third model too, but certainly not in the second and the fourth. But theoretically, build a making software for the second and fourth model is not too much different, it is just a matter of modelling the system for these use case.

Software

On the computing world the concept of software is used many times in opposition to the concept of hardware. But both are broad worlds with lots of variation. Softwares are distributed over many layers of programs, interacting one another. It is a giant ecosystem.

I said that the making machine is a web based software and is implicit that it is a layer of software that will communicate with many other layers of softwares, like the operating system, web server, application server, database and so on.

Overall

Source code

The deliverable of the making software is the source code of a software, the software itself. The making software is a machine with some little japanese guys inside, who writes software code. In order to automate the process of writing a software code it would be nice to use a language that has a very strict defined structure, so you can analyse its syntax and teach the little japanese guys on how to write code on this syntax, on a fast process with a clean result.

Programming language

Some years ago me and a friend have started to make one website to deploy one service on the Internet. We came from the Java world, he as a programmer and I as a project manager. We decided not to use Java, thanks to its wordier style of coding, which requires unnecessary efforts for programming.

By that time we decide to use a relative new framework written in Python, but our project did not evolved and it has been archived since then.

Django

This year, after finish two new projects I was willing to write a making software, as a new project to my portfolio, and I open the code of the project that me and my friend had written in the past. It was written in Django, a Python framework, and I saw again how easy to generate a system with that framework is.

People who knows Django knows what I am talking about, it is a very well structured and clean framework that follows DRY (don't repeat yourself) concept.

Python

I was not a Python programmer before start to write the making software, and I still do not consider myself as Python programmer even after write many things in Django framework. I saw that many programmers on the Internet discover later after learn how to programming in Django that what they know of Python is a mix of Python and Django. I am luck to read this comments on the web and I have discovered early that I am not a Python programmer, even if I write some Django websites.

While coding the making software, sometimes I need to go depth in Django and I meet pure Python to solve some extra needs, like for exemple get some attributes of a model´s object that I can not access directly with Django. So, there I need to write some code direct in Python, which is not a problem for any programmer, who is just not fluent in Python hence not productive.

Outcome

The product that results from the making software is a Python´s framework code, Django.

Interface

The interface of the making software is a website. This interface offers the user all the choices he or she has, in order to build his or her software.

Features

The making software provides some features, that the user can use to make their own system. As described on the beginning of this article, the user is able to develop web based system.
The borders of the making software are established by the features it offers, and are listed here:

• There are three types of system that can be created on the making software.

1. Simple forms
   The administrator creates the forms and the users fills them. Data can be accessed on the admin interface.
2. Simple form with data generated by the admin user
   The admin user can create some data on the admin interface to present on the forms as the user´s choices.
3. Forms and relationship between entities
   The admin user can create more complex systems, relating entities, database tables with foreign keys and one-to-one or many-to-many relationships.

• Admin Interface
  Admin user can create, read, update, delete any kind of data of the system, and some structures of the created system.

• Access control

• Registration
• Authorization
• Authentication
• Facebook authentication integration
• Can integrate with Twitter API, Google+ etc

• Define sections of the system
  The system can have more than one section, which of them with his own form.
  They can be also have relations between then and will be distributed in a set of menus.

• Two interfaces available

1. One web interface with 5 templates available
2. One interface to generate a Facebook app. Actually it is a web standard interface too which uses a stylesheet to follow Facebook´s visual standard.
   It works as an IFrame on Facebook.

I hope that you have the right comprehension of what is the making software and what is the software generated by it, because at the end all are software and we could also think in the possibility to create a making software with the making software. No, this is not possible at the stage of the making software, but conceptually, it is true, this is what the making software does.

Main blocks

On the image below you can see in the middle 3 main coloured blocks. Beside the blocks there are an arrow pointing down and an arrow pointing up.

Creating a system

The arrow pointing down indicates the direction the user follows while creating a system with the making software.

1. He or she access the interface, a web site and compose the system that they want, with the features described above in the previous section. 
2. Since he or she finishes the system or want to test the system, they can ask the making software to generate the software.
3. The final deliverable is a web based system up and running.
   I will describe latter the other components of the system.

Creating the making software

The arrow pointing up shows that in order to analyse and modeling the making software, it is better to follow the opposite way:

1. Start studying the Django framework deliverables
2. Map and develop all functions needed to generate the Django code
3. Develop the web interface to the end user

The two curved arrows along the blocks indicates that the process is iterative for both, for the end user developing a system on the making software and to analyse and modeling the making software itself.

More blocks

The interface of the making software is a website that records data on a standard relational database.
To create and deploy the system the user only needs to click a button to activate the making software.
The making software has the knowledge to create all the artifacts needed to run a completely independent web based application:

1. models.py, views.py, urls.py, settings.py, wsgi.py, admin.py, manage.py, static files, required libs and all other resources.
2. It creates an Apache WSGI appointment to the created system too.
3. And it runs manage.py, which creates all database tables and related resources and start the application to the world. The application is deployed in a secure environment with https protocol enabled by default.

The making software internals

If you note, I didn’t talk about the technology of the interface of the making software and it’s own technology. The reason is because it doesn’t matter.
You can use anything you want to create the interface to activate the making software. In my case it is a Django site too, but it could be a PHP, JAVA or anything else. This web site has no intelligence, but only exposes the making software features to the user.

The making software can be of any technology too, it is a choice that depends mostly on your preferences. I developed in Perl to easily manipulate files, texts, database and anything else needed to create Django artifacts.

The making software main functions

Most of the functions listed below calls the Django API.
The making software has some features, and once the user select them the system stores on a database. To create the user application the making software just call the Django API passing the features required by the user as parameters of the Django API.

• createDB
  Initiate a database instance for the Django project

• createProject
  Create the Django project

• editSettings
  Edit settings.py file

• copyDefaultApps
  Actually this functions clone all Django applications needed for the created project. Some of them are third part application to control access, generate html template, facebook template and so on.

• syncDB
  Read models files, and create or synchronize the database

• setSuperUser
  Create Django admin user

• startApps
  When start an app in Django, some files are created by default. This file are created and edited here.
• models.py
• views.py
• admin.py

• sqlInicialData
  Create SQL files to provide initial data for the application. Initial data can be of two nature, for tables of reference data, like a list of states of a country, list of ZIP code and so on, or it can be used to generate mock data for tests purpose, inputting mock data to databases.

• editUrls_py
  Set the Django control layer

• editTemplate
  Configure html template file of the project

• editSettings
  Add Django applications to settings.pý and set other parameters

• createDjangoSite
  Set Django site on database

• createStaticPages
  Generate flat pages and record on database

• configWebServer
  Setup the web server and take the system up and running

Some functions direct access commands of the filesystem. They are auxiliary to generate the ultimate Django application deliverable.
They are simple commands to create, copy and delete, files and directories

Conclusion

In future articles I will explain further the insides of the making software. It is not easy to write this kind of software but automate parts of the process of building software is the future. And I said in the introduction of this article, it is already possible to perform this.

The POC on the Internet www.inteliform.com.br shows this kind of making software totally functional. There a user can create a system only by selecting options and filling forms. After he or she finishes the process, InteliForm create the entire system and deploy it on the web in a secure environment.

Unfortunately, InteliForm is entire in portuguese without translation in place. If you need extra information please feel free to ask me.

After build this POC, I can say that build a making software of many nature is a possibility in our hand, it just depends on human efforts since the technology is all available.

And just to finish, I would like to have another open question regarding the language I used as the output of the making software. I have used Django as the output language, but with some extra researches I think that it would be possible to deliver the code in Ruby/Rails, Perl/Catalys, PHP frameworks and others web frameworks.