The decisive goal of each programming language is to keep it effortless for the user and conceal the complexity in the implementation. The intact notion of theory in computer science verbalizes the abstraction by keeping it easy to the user. The theory puts a demand that every perception needs a formal proof for acceptance. Every concept is goal driven to optimize it to the computer architecture. After completion of my degree, when I have the bigger picture of what I have acquired, I still have following questions unanswered.
The Expression Notation
We study about prefix and postfix notations and its greater advantages. Why do not the programming languages we use follow prefix/postfix evaluation of expressions? Why is not my language a set of expressions formally proving my program is right?
The Data Type
Data is information. User should write the data leaving behind the type of storage to the system. But we don’t do that! Instead we are also asked to communicate the type of data and hence defining a data type. Instead, for the user there should be only one data type. The “data” data-type. May be that’s why I can’t return functions. Language would be so cool if there was a provision to return the functions as well as a result.
The Definition of Data-Type
The definition of the data-type itself looks a faulty one. It’s not about how the data is stored in memory. In the first case, why should I even worry about how the data fits in the memory layout? It should be all about the operations which are possible on the data. Data type should be more of algebra on the data.
The Address Operation
Why the user is made aware of registers and pointer operations? Was it to cover up the limitations of the language? Instead, should not the language implementation take care of all the efficiency issues and not make it a concern to the user?
The Idea of Programmable
We all speak of domain specific languages today. Why is not my language giving me a customization of my choice? It could be as small as possible which can grow as large as possible, where user can bear in mind very few details and grow the language in his own terms. Why there is a restriction that execution has to begin with “main”? Why is writing an interpreter for my required domain so complex? Is it that, the limitations of a language are covered up by adding more features than providing the abstraction?
The list of questions keeps growing like an ant trail. And that’s when I start falling in love with Functional programming.