LPDAC – A Future Technology

Over the past many years, people have pioneered the process of making the world run better. For every new development, there is a lot of thought process involved with which humans get centered to only one specific problem and somewhere the mindset to innovate new gets compromised. In the past, people from different walks of life have come together to put their learning into the software, but today, the same people deter from using the advanced resources, computing power, experience and knowledge to solve the problems.

Time is money and in the business world, money matters the most. However, by sticking to the traditional approach of software design we are compromising on money and time. We need to evolve and to evolve at a rapid velocity, we need to think in a different direction

Technology has the potential to make society more inclusive. For instance, the software industry can be revolutionized by the inclusion of differently abled people. Just by eliminating the impedance factor, we can bring in a fresh perspective to the problem-solving industry.

In the world of advanced computing power, we are subpar in our methods to utilize the resources available. Thereby, we need to come up with a better and a more efficient approach.

The approach to solve the problem at hand lies in the this quote.

“The irony of life is, Machines are learning to think like a human and Humans are thinking to learn like machines.” – Pankaj Gupta

LPDAC: Language Processed Design and Automated Coding

We just need an inspired solution interpreted from it that can be implemented effectively and the results will can be better than ever imagined, or even thought of.

The solution majorly contains 5 parts:

To start with the explanation, let’s consider an example where we have a user named “Pankaj” and a machine named “Mish”. Pankaj is a techie and has decided to develop a software. Now, he prepares “Mish” to learn the algorithms & pseudocode and convert it to productive code.

Recently he experimented the scenario as illustrated through conversation below:

Pankaj: Hi Mish!

Mish: Hi Pankaj, which code are you looking for today.

Pankaj: Mish you got me right, I am looking if you can print hello world on to a screen and show me the code.

Mish: Sure, Pankaj! Here you go….

Pankaj: Thank you Mish!

The code was:

#include <iostream>        // line 1
using namespace std;       // line 2
int main()                 // line 3
{                          // line 4
        cout << "Hello, World!";    //line 4.i
        return 0;                   //line 4.ii
}                          //line 5

To our surprise the machine is taught with the knowledge base of a pseudocode of how to print a “hello world” which was:

1. Begin.

2. Print “Hello World”.

3. End.

Having learnt this program, “Mish” is now capable of printing any statement given to her. Now, all I have to do is to say, “Mish print me a statement ‘test successful’” and she shall do it for me. The benefit here is, Mish has learnt printing statements, which can be enhanced to tables, controls, views and other things and Mish will paint them on to the screen. The rendering is much easier than before.

Also, to speak it took me hardly a second to say “Print Hello world” to Mish and the output was ready within a second. The contemporary approach can easily take me up to 30 or more seconds. ‘Mish’ has increased productivity thirty-fold.

The machine interprets the code provided to it. It observes that most of the lines remain the same and the change required to adapt the program to different use-cases is a minute. For example in the sample code provided, line no. 1,2,3,4,4.ii and 5 will always be same for every case of printing. It’s only the line no. 4.i that is subject to change wherein, it requires only the text that needs to be printed.

In future, when she know the algorithm has “Begin” do print line no. 1,2,3,4,4.ii and for “End” line no. 5, The thing will become easier for future.

Similarly let’s take few other examples where my machine has been taught how to sort an array of elements.

The pseudocode taught to her is:

1. Begin

2. Input array of element

3. for j ← 1 to n-1

4. smallest ← j

5. for i ← j + 1 to n

6. if A[ i ] < A[ smallest ]

7. smallest ← i

8. Exchange A[ j ] ↔ A[ smallest ]

9. End.

One more time let’s see the conversation between Pankaj and Mish:

Pankaj: Hi Mish, Write a program to sort values 10,30,43,25,3,5,4,65,2,5,2,5.

Mish: Sure Pankaj, The code is:

#include<stdio.h>							// line 1
int main()									// line 2
{											// line 3
       int i,j,n,loc,temp,min,a[30];				// line a
       printf("Enter the number of elements:");		// line b
       scanf("%d",&n);								// line c
       printf("\nEnter the elements\n");			// line d
       for(i=0;i<n;i++)								// line e
       {											// line f
                scanf("%d",&a[i]);					// line i
       }											// line g
       for(i=0;i<n-1;i++)							// line 4
       {											// line 5
            min=a[i];								// line a
            loc=i;									// line b
            for(j=i+1;j<n;j++)						// line c
            {										// line d
                  if(min>a[j])							// line i
                  {										// line ii
	                   min=a[j];						// line 1
                       loc=j;							// line 2
                  }										// line iii
            }										// line e
            temp=a[i];								// line f
            a[i]=a[loc];							// line g
            a[loc]=temp;							// line h
       }										// line 6
       printf("\nSorted list is as follows\n");	// line 7
       for(i=0;i<n;i++)							// line 8
       {										// line 9
            printf("%d ",a[i]);						// line a
       }										// line 10
       return 0;								// line 11
}												// line 12
​

Now my machine knows how to do a Sorting, in future my machine can learn how to sort records and then with time it can determine which algorithm to use based on the input data.

The user query is passed through NLP API, my system can analyze the query, then the query is matched with the existing knowledge base scenarios. The code will be reproduced by making the necessary changes. For the printing scenarios, Mish will add print statement to the fixed piece of code and the fetch what needs to be printed from the spoken word, once this is done, the process can be automated to print statements.

Now if Mish is smart enough to produce the same algorithm converted to different programming language then it will be advantageous as this will make the coding pattern more generic and unified in approach. The programming languages need to be distinguished viz. functional based, object oriented and others. This is required as each programming language is designed for a specific purpose and the same logic can be implemented in different languages just by modifying the syntax. On training my machine extensively, it would have the ability to determine the purpose of each piece of statement. Thus, it can develop the code that is generic and adaptable to any programming languages.

Adapt Code reviewing and learning techniques using Machines:

Code quality is something which is directly proportional to the quality of a product and there are numerous of action and efforts that can be taken to achieve high quality code. From the experience, this idea deals can help to attain high quality of product and it will be more efficient. To explain it let’s consider two machines Mish1 and Mish2 both are having some experience or may be newly deployed for automated coding. Assume Mish1 has produced a piece of code then there are 3 possible cases:

1. Mish1 is more experienced than Mish2, in this case Mish 2 will review Mish1, if she has something which Mish1 can learn, then she will make the corresponding comment across the respective lines of code. At the same time Mish2 will learn from Mish1 on why such a code is produced.

2. Mish2 is more experienced then Mish1, in that case the Mish2 will put comments across the respective lines of code which per Mish2 can be improved, may be in terms of best practices, syntax, logic, indentation or some other things which she has learnt in her deployed period.

3. If both are of same experience, they will attempt to understand how the other machine computed the output.

In each of the above cases, it’s a win-win situation as the knowledge base and experience for both the machines will continuously grow and this will enhance their learning and will result in more productivity.

The show shall continue to be run by humans as they will be the sole master of the entire process. The code is reviewed and submitted by a developer. Additionally, Mish1 and Mish2 will learn from the human made changes by analyzing the code in the productive environment.

Now consider it is not two, it’s a network of Machines or a graph of Machines who review and learn from each other. This will bring an unseen level of maturity in the machines every day. Care must be taken that the humans shall always hold the power over the machines.

So far the mentioned ideas teach the machine to be efficient, but to be effective they need to learn OOPS/OOAD and Design patterns. This will allow them to tackle real-life scenarios and bring a new level of knowledge discovery. Whenever I ask Mish to write a piece of code, she will always first check if something is already there, if so it would be reused, if not it will extract the logic into a method and expose an API for future consumption. Mish here would be capable to do so if it learns the OOPS design. Teaching a machine, the design patterns can help reduce time. Having learnt the architectural patterns, Mish would be capable of reducing the dependency of human intervention.

These approaches and ideologies are for SAP products. Most of the business applications at SAP are developed using ABAP. These lines of code being the backbone of SAP, can be best used as they are written like what we say general in English and understanding those words and making them to ABAP code can be much easier from LPDAC rather than any other language. Similar case is with SQL as the syntax is quite like the High-level languages (English). Integrating this idea (when converted to tool) can outrage the no of development.

This is not only the benefit of using this idea, there are many more:

“Changing with time is essential, but moving at the pace of time will bring excellence.” -Pankaj

Reference blog: https://ideaforfuturetech.blogspot.com/ -Owned by me