High Level Languages

# Compute sum of integers 1..N and print the result
def sum_n(n):
    return sum(range(1, n + 1))

n = 5
result = sum_n(n)
print(f"Sum from 1 to {n} is {result}")

Features of High Level Languages

Readability

High-level languages use natural language-like syntax, making code more readable and easier to understand for programmers. This readability helps reduce errors and improve maintainability.

Abstraction

High-level languages provide a high level of abstraction from the hardware, allowing programmers to work with concepts closer to human thought processes rather than machine-level instructions.

Rich Standard Libraries

High-level languages often come with extensive standard libraries that provide pre-written code for a wide range of tasks, such as file handling, network communication, and data manipulation.

Automatic Memory Management

Many high-level languages, like Python and Java, feature automatic memory management, which simplifies memory allocation and deallocation, reducing the risk of memory-related errors like memory leaks.

Platform Independence

High-level languages abstract away platform-specific details, result in programs that are usually highly portable from one system to another.

Limitations of High Level Languages

Execution Speed

High-level languages are generally less efficient in terms of execution speed compared to low-level languages like assembly or C.

Memory Usage

High-level languages may consume more memory than low-level languages because of the overhead introduced by features like automatic memory management and extensive standard libraries.

Lack of Low-Level Control

High-level languages abstract away low-level hardware details, which means developers have limited control over system resources like memory and hardware registers. 

Resource Intensive

High-level languages may consume more system resources (CPU and memory) than low-level languages, which can be a concern for resource-constrained environments or embedded systems.

Low Level Languages

section .data
n: dq 5

section .text
global _start
_start:
    xor rax, rax
    mov rcx, [n]
.loop:
    cmp rcx, 0
    je .done
    add rax, rcx
    dec rcx
    jmp .loop
.done:
    mov rdi, 0
    mov rax, 60
    syscall

Features of Low Level Languages

Direct Hardware Control

Low-level languages provide direct control over hardware resources, allowing programmers to interact with and manipulate the CPU, memory, and other system components at a very granular level. E.g. system programming and device driver development.

Efficiency

Programs written in low-level languages tend to be highly efficient in terms of execution speed and memory usage, making low-level languages suitable for performance-critical applications.

Manual Memory Management

Low-level languages require manual memory management, which means programmers are responsible for allocating and deallocating memory explicitly. While this can be error-prone, it provides fine-grained control over memory usage and can lead to efficient resource utilization.

Platform Specificity

Low-level languages are often closely tied to a specific CPU architecture or hardware platform. This can make code less portable, as it may need to be adapted or rewritten to work on different systems.