The DRY Principle and Information

DRY

In software development, DRY stands for Don’t Repeat Yourself. Conventionally this principle gets implemented by frameworks like ASP.NET MVC and Ruby on Rails by having a single source for column/field names, either the database or a class.

Framework Challenges

The challenge with these systems is to manage the sources. This requires high integration, and makes it very difficult for these frameworks to play with others. They are also very solidly based in a data oriented approach, meaning that they institutionalize hard coded context. With hard coded fields even when there is only one source for each, framework APIs become inflexible.

An Information Based DRY Framework

An information approach would treat each field as something to be processed and characterized rather than just as a field name and a type and other hard coded attributes. Information could provide flexible relationships between fields, flexibly created new fields, and control for the source of the field names, labels, types, and parsers.

Interacting with Another Framework

An endemized English vocabulary could be used to come up with an automatic signature for each of the columns in a database, each of the fields in entity framework, and each of the members of various data classes. These could be glommed. I have an endemized signature vocabulary for about 5000 words already available. Adding synonyms and two word definitions, and including another 1000 very common database column words could push this to 10000. Relationships could be identified from class memberships, operations and stored procedures. In this way an endemized framework could interact with MVC and Ruby on Rails without a lot of code written (once this framework was written).

An API to Anything

A further DRYing of code could happen by making the endemized framework a source. Once the framework above works, then this step becomes simple. And the endemized information framework can be a conduit to the other sources. We can build an API for interacting with the endemized framework giving other systems access to fields and rich metadata about fields in apps and databases. Endemizing provides flexible metadata, so there could also be an API to adapt the generalized framework to specific sources.

Glomming a Database Part II

Once you have the endeme sets, you can automatically build a UI to access the information and the data
– the data with endeme based context UI’s, these ‘views’ would have to be generated in a big info searchable list, along with context-info ‘advanced’ search ‘screens’
– the information with endeme UIs, returning -summaries, -totals, -endematic profiles, -data mined correlations, -etc.
– once you have a row you can edit it
– you can also edit the columns of a list given specially selected data fields and endeme metadata

data: a big honkin list of database data column paths including column, path, endeme(s)
info: a big honkin list of database information paths including endeme, column(s), path(s)
context: a big honkin list of database context including join(s), table(s), path(s), column(s), endeme(s)

combine databases?

unfortunately we may have to get level 4 working before we can do this properly.
Fortunately this project could be a good test bed for getting level 4 working.

Companies Shouldn’t Have to Outsource IT

Why do companies outsource their IT departments and software development? It hurts them in the long run, as they lose control of the knowledge of how their company works. They also have trouble conveying the changes they need to make to people outside their company. And the their party can also get into trouble, go out of business, disappear etc.

Companies outsource because the connection between IT people and non-IT people has not been made. The non-IT people who run companies feel out of their depth in knowing how to build a proper IT infrastructure and software development for their business. So they just want someone else to do it for them who knows how to do it.

Software development has failed to create the intermediate communication medium that both IT and non-IT can use to think about their infrastructure and software development. Without a communication medium, non-IT people can not think about IT without becoming IT people.

The communication medium does not exist because software development has failed to find a way to have programs understand information. That is level 3 work. The focus of my work is to build the connection between IT people and non-IT people. Level 3 can solve the IT outsourcing problem.

The Dreams of Computer Programming

The dreams of computer programming:

  • The dream of writing a true AI program.
  • The dream of writing programs to meet our needs and desires and to provide benefits to us, for example including increasing productivity.
  • The dream of extracting information from data by writing a program.
  • The dream of a general purpose problem solver that for example can fly your car, cook your eggs, play chess with you and write a symphony etc. the key idea being that it is able to tackle whatever problem you might set it.

We have not met these dreams yet. Instead, true AI is still very far away. Only a fraction of our needs and desires get met. Instead of writing programs we use big honkin’ data mining and big data tools. We still write specific programs to do specific things.

I think the problem is that software development has reached a glass ceiling because we have not developed level 3 programming yet.

Level 3 programming requires three things

We need general programming, domain programming, and level 3 programming frameworks:

  1. General programming is what we do right now with object oriented coding and object oriented code reuse.
  2. Domain programming has to do with mixing our programming with concrete exececutable models of combinable, permutable concept lists focusing on the concepts and concept groups of the domains. i.e. endemes. This is just another definition for endeme sets.
  3. A level 3 programming framework allows us to execute the executable models of combinable, permutable concepts. Rather than just complaining, I think it is important to also provide solutions to resolve what I complain about. Therefore, I am working on a level 3 framework. My latest framework is posted here.

The Cost of Bad Information

The world GDP is about 75 Trillion.
More half of people are mismatched to their jobs which means they are working at less than half productivity.
More than half of managers are not matched to being managers which means that their employees are working at half productivity.
Information could tell us how to match most of these people with the proper job.

So

               Matched managers              Mismatched managers
               Matched        Mismatched     matched        mismatched
               individually   individually   individually   individually   Total
------------   ------------   ------------   ------------   ------------   -----
Now, without   25%            25%            25%            25%            75 T   (8.3*9)
information    
Productivity   100%           50%            50%            25%            56%

With           100%                                                        133 T  (8.3*16)
Information
Productivity   100%                                                        100%

Just with this one information measure, we are currently working at about 56% productivity.