Have you ever wondered how code was written with the first programming language? It was a question that I pondered on too. And this is my two cents on it.
I would first break this down into two further questions.
1. With what language or class of languages would you consider a programming language comparable to what we know today?
2. What are the steps in implementing a solution?
On the first point, when someone says programming language, then they are most likely referring to high level languages. Its high level because all the work which we would have had to do with assembly languages has been skipped. Thankfully, we can concentrate more on the business logic and spend less to no time thinking about memory allocation, as well as all the zeros and ones.
Still high level languages were not the first programming languages. The distinction is important between the first programming language and the first high level language. For example, when you google for the first programming language, Plankalkül comes up as the answer.
However, in this day and age, the programming languages we refer to are the third generation languages (or simply 3GL). Languages that fall in this category include FORTRAN, COBOL, BASIC, Pascal and C, Java, Python etc. Generally, these are the languages used to create the software we use today.
Once, we narrow our criteria down to 3rd generation languages then the answer on the first high level language should be the IBM Mathematical Formula Translating System (FORTRAN). This was the most widely used and beneficial programming language. I give a thumbs up to the team at IBM that made this language. Even today, it’s the language of choice for large scale numerical calculations.
Since we have now settled the point that FORTRAN and 3GL are what we are considering then, we must return to the question, how was the software first written?
The answer is the same way it has been written for years now and now. Yes, it is true it may have different names, different terms, and variations. However it still remains the same. John Backus and the team that created FORTRAN used it in the same way in which we use programming languages today.
It generally follows these steps;
1. Watch the client do piece of task, manually or speak to client (Requirements gathering)
2. Implementer writes in pseudocode and needed entities and how they all need work together. (Planning)
3. Implementer mimics tasks in small chunks. (Execute)
4. Implementer perfects process (Iterate)
5. Tested out by client (Test. This may lead to iteration later)
6. Client starts using tool (Closure and maintenance)
As I mentioned above, these are my two cents on the question. I invite you all to contribute, share comments and your points of view. And let’s all learn together. We will meet together soon in the next post.