(Image Ref: http://en.wikibooks.org/wiki/Programming_Languages)
|
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.
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 customizable? It should
be as small as possible which can grow as large as possible. User bears in mind
very few details and grows 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 you start falling in love with
Functional programming.
No comments:
Post a Comment
Please Leave your Feedback / Suggestions