Right now, everybody is discussing about .NET and its
future in the near future.
Is this all stuff only for advance users (developers) ?
Well ! Nobody is worried about that because the final aim for everybody is, Do i
know this ?
If yes then whats next ? and if the answer is no then Who is going to answer my
problem ?
This is just a series of questions where every answer is raising more and more
questions.
But WHY ?
Why every answer is creating more confusions, more
questions and more discouragement to discover this technology.Reason being is
most of us are just learning about the technology (may be syntax and a bit
concepts) but how many could think about the root cause of the evolution of this
technology and becasue we are not clear about the need of the technology thats
why we are always facing the problems to discover something new and in a
creative way to develop something new.
So, here in this series of articles, I'm going to
explain the need (demand) of the industry across different time zones (IT
industry term) for new technologies and about the problems, industry was facing
and asking about the right solutions.
So, throughout the way I'll be making the base of very
simple examples to make the things very clear and easily understandable thats
why at some points this could make a feel that why we are doing such things
(even in straight words technology movement) to just add two numbers (just an
example) but that is only to explain the things and you can try out the things
on some more complex parameters.Again I would not be considering the terms
punching a program or writing a program in different ways because my goal here
is to explain the problems with the technology of the current era and the
solution proposed rather not the way we were pushing our program to get the
output.
BINARY ERA:
We would not go back in the times when PASCAL was
inventing first Calculator to assist his father and suddenly that was the
starting of our computing era. We'll start the things with the face of the
computer, when we got a room to accomodate our computing machine and water flow
through pipes to make the processor cool.I would not discuss about the
operating process of the machine or the expertise to run a program rather I'll
discuss about the process to write a program, its efficiency, its production
time and moreover the way this was standardized.
So at this time, to make a program or in fact to write
a program for some specific machine we had to write our program in terms of
binary numbers. This looks very ridiculous today that we are programming just
with 0's and 1's and again the problem was with debugging, efficiency in terms
of production time and the way our program can behave on different machines.
For example, if we want to add two numbers like 5 and
9,so actually we want to perform 5+9.
The way we have in binary programming is first of all
writing the value of 5 in some certain hardware specific number representation
(Binary, EDBIC, Hexadecimal etc. again depends upon the memory occupied by the
registers) and then binary representation (Just an assumption) of "addition"(+)
operation and finally the second operand means the value of 9 in our case in the
same number representation scheme.
So just for a case if we represent 5 as 0000 0000 0000
0101 and '+' operation as 0000 0000 0000 0001 and for 9 we have 0000 0000 0000
1001 so the code for 5 + 9 will be :
000000000000010100000000000000010000000000001001
...(Expr 1)
Program Clip (A) : Incorrect program
110100110010100010010011001100111111101010101000001010001001100110111010100011010
011001011000101100010101100010101000101010101111111101010011111101010100001101001
011000101000101010001010100001010001010000101000010101111110100010100001010001010
010100100000000000000000000000000000000000111111111111111001001111001001001000111
Purpose of the program : To solve a mathematical
expression like : 3 * 5 + 10 - 43 + 67 / 2.
Are you thinking, this can not be a program but trust
me that was the phase of our so well developed industry to make a move on their
computing machines.But the programs written at that time were not so small (as
our four lines code) rather they were bulky and very time consuming (many number
of pages) because mostly machines were used for the scientific and complex
calculations.
Now just think that we are doing it manually as they
were doing at that time (no visual tool is doing this for us) and how much is
the possibility to just skip one 'Zero' ( 0 ) or one 'One' ( 1 ) or may be just
being fooled by the long expression and pressed 1 instead of 0.Just one mistake
and we are ready to crash our machine most of the times and we lost our
resources for a long time and started a long process of almost impossible
debugging to trace out the error.
Program Clip (B) : Correct program
.............................................................
......................................................
..............................................................
110100110010100010010011001100111111101010101000001010001001100110111010100011010
011101011000101100010101100010101000101010101111111101010011111101010100001101001
011000101000101010001010100001010001010000101000010101111110100010100001010001010
010100100000000000000000000000000000000000111111111111111001001111001001001000111
.............................................................
Program Clip (A) and (B) are the same part of a program
but in part (A) developer has made some mistake that has been corrected in part
(B).
As it looks that Program Clip (A) and Program Clip (B)
are similar but when we submit the program 1 to the computing machine, in most
of the cases machine crashes and we loose our many days until the machine is not
up again.To make the code error free, always the better choice was to rewrite
the programs from very scratch.so this approach of writing and running programs
was very expensive and inconvenient and at that time industry demanded some new
technology to write programs easily and to find out the errors as soon as
possible at least something better then to rewrite the program from very
scratch.So the problem was not only with debugging but the production time of
the task development was also very high because of the rewriting of the code
again from very scratch.The process of development was also very much irritating
and montonus and needed the keen concentration of the developer at the time of
development.
Time passed, many communities and
developers group talked on this issue and finally the answer they got was
Assembly Language (Well ! before that some hard coded routines were also known
as Assembly Langugage Programs).
In the coming parts of the series, we'll go through
Assembly, High Level Languages, Structured Programming Languages, Object
Oriented Programming Languages, OLE1, OLE2, OLE Automation, COM, Beans, Active
X, COM+ & Finally .NET ....