Introduction

Have you ever given a thought to- how to learn programming a language at the very bottom? How about beyond syntax and libraries to actually understand where languages come from? 

Although writing a programming language from scratch seems like a very hardcore thing to do, it is a life changing experience and helps you to understand all about what is programming language and a lot more, actually dealing with software on a very core level.

Here is a guide to the first steps for that worthwhile journey, it will provide helpful advice to students going into fields related to engineering and others as well. This blog will answer you- How to learn Programming Language - everything you need to know!

What is Programming Languages?

To begin with, we need to know what is programming language. Answer to this is:

A programming language is a set of commands and syntax that transfers instructions from humans to a computer. It bridges that gap, an interpreter that the developer can write code for machines to do what they need or solve a problem

Now you might be wondering how many programming languages are there? To be precise; Programming Languages are: low-level (e.g. Assembly, machine code) and high-level languages (Python, JavaScript to name just two)

Different types of programming languages:

1. High-level languages (e.g. Python, Java): It is most readable and writes the easy human level abstraction of many machine level details.
2. Low-Level languages (assembly-language /C): They are closer to Machine level code hence give hardware level control but become less readable.
3. Object-oriented programming languages (Java, C++): object orientated focus (sp)and classes that make modeling real-world problems more intuitive
4. Functions and immutability: Functional languages(like Haskell, Lisp)
5. Scripting languages (JavaScript, PHP): Commonly used to create integrations or websites.

Because every programming language has it's own syntax (rules) and semantics (meaning) as to how the code is typed and how the computer will “get” it. These are the building blocks for creating everything from websites, apps, operating systems and algorithms. 

How to Learn Programming Languages: Lexing and Parsing for Beginners 

This section offers you insights into post and before you start programming. To start, you have to know the basics of any programming language. What is the common process between these two stages? It is: lexing and parsing, in that order. 

• Lexing (or lexical analysis): It is to break down a sentence into words. Especially for us, this is taking the uninterpreted source code and turning it into a stream of white. For example, `x = 5 + 3;` would be divided into tokens such as `IDENTIFIER(x)`, `ASSIGN`, `NUMBER(5)`, `PLUS`, `NUMBER(3)` and `SEMICOLON`.

• Parsing: On the other hand, parsing takes these tokens and produces the abstract syntax tree (AST). Abstract syntax tree or AST is the structure representation of your program where the tokens are related to each other. In other words, think of it as assembling your sentence's grammatical structure. A parser ensures that the code abides by grammar rules of the language. For example, it would see that 5 + 3 is a statement that you must evaluate before giving to x.

Example: Let's consider a very simplicial language (we want variables and arithmetic operations).

• Lexing – the tokenized version of let a = 10 + 20 is KEYWORD(let), IDENTIFIER(a), ASSIGN, NUMBER(10), PLUS, NUMBER(20), SEMICOLON.

• Parsing – the parser would feed this expression into an AST and demonstrate that 10 + 20 is an add operation, which is to be assigned into a.

This is helpful to understand how many programming languages there are and how do they work, no matter what their particular features are.

AST to execution: Interpreting or Compiling

After getting the AST, you have to pick how it will be executed. There are two ways to do it: interpret and compile.

• Interpretation: An interpreter walks the AST directly step-by-step. It is relatively more easier to write your first language from here as it this fairly simple and often used as the starting point of interpreters in the community, mainly Python and JavaScript (though many implement developers are using a mix of techniques).

• Compilation: Algorithm Compiler turns Ast into machine code or low-level language which can be executed by machine. Usually leads to faster execution, but harder to write this way. C and C++ are typical examples of compiled languages.

Beginners should start learning with an interpreter CLOS. Interpreters are best for most use cases. Ast to traverse and apply operation specified by each node that you do. When encountering an addition node you would for example call recursively evaluate the left and right operand, than add both results.

Teaching students how to learn programming language is learning you have at a young age. Throughout your degree in computer science and engineering, the knowledge obtained cannot be over-valued. The understanding of how software is built from the ground up is very important to develop great applications.

Fact: In a data published at Science Tech Today, the Programming Language market is expected to reach over $300 billion by 2029. This surge can result in its expansion influence across industries.

Example:

You would probably implement a simple interpreter using a tree traversal recursion in it's AST. If you have an addition node, maybe that is a function evaluate_addition(node) that makes calls such as evaluate(node.left) and evaluate(node.right), so it gets operands out of the two.

Conclusion 

Despite how difficult it may sound, the experience of designing a programming language from scratch is also one of the most rewarding. It gives you a profound understanding of how a programming language operates and how software functions at its core. It demystifies the entire programming language process and genuinely imparts to one's appreciation of programming concepts in computer science and engineering. 

Of course, correlating this with complexity would sound complicated, but disaggregating those processes in small sections will be beneficial in making it easier to execute. Generally, one will start with lexing and parsing techniques and move on to an interpreter or compiler. This provides one with a deeper sense of appreciation for the art and science of programming. This knowledge and skills thus acquired will open a new vista in the ever-changing world of technology.