Programming Languages Timeline

#include <stdio.h>

int main(void) {
    printf("Hello, World!\n");
    return 0;
}

fn main() {
    println!("Hello, World!");
}

package main

import "fmt"

func main() {
	fmt.Println("Hello, World!")
}

print("Hello, World!")

#include <stdio.h>

static int max_int(int a, int b) { return a > b ? a : b; }
static double max_double(double a, double b) { return a > b ? a : b; }

#define max(a, b) _Generic(((a) + (b)), \
    int: max_int, \
    double: max_double \
)((a), (b))

int main(void) {
    printf("%d\n", max(3, 7));
    printf("%f\n", max(1.5, 2.8));
    return 0;
}

fn max<T: PartialOrd>(a: T, b: T) -> T {
    if a >= b { a } else { b }
}

fn main() {
    println!("{}", max(3, 7));
    println!("{}", max(1.5, 2.8));
}

package main

import "fmt"

type Ordered interface{ ~int | ~float64 | ~string }

func Max[T Ordered](a, b T) T {
	if a >= b {
		return a
	}
	return b
}

func main() {
	fmt.Println(Max(3, 7))
	fmt.Println(Max(1.5, 2.8))
}

from typing import TypeVar

T = TypeVar("T", int, float, str)

def max_of(a: T, b: T) -> T:
    return a if a >= b else b

print(max_of(3, 7))
print(max_of(1.5, 2.8))

#include <pthread.h>
#include <stdio.h>

long indices[4];
long results[4];

void *square(void *arg) {
    long i = *(long *)arg;
    results[i] = i * i;
    return NULL;
}

int main(void) {
    pthread_t t[4];
    for (long i = 0; i < 4; i++) {
        indices[i] = i;
        pthread_create(&t[i], NULL, square, &indices[i]);
    }
    for (int i = 0; i < 4; i++)
        pthread_join(t[i], NULL);
    for (int i = 0; i < 4; i++)
        printf("%ld ", results[i]);
    return 0;
}

use std::thread;

fn main() {
    let handles: Vec<_> = (0..4)
        .map(|i| thread::spawn(move || i * i))
        .collect();

    for h in handles {
        print!("{} ", h.join().unwrap());
    }
}

package main

import "fmt"

func main() {
	ch := make(chan int, 4)
	for i := 0; i < 4; i++ {
		go func(n int) { ch <- n * n }(i)
	}
	for i := 0; i < 4; i++ {
		fmt.Printf("%d ", <-ch)
	}
}

import asyncio

async def square(n: int) -> int:
    await asyncio.sleep(0)
    return n * n

async def main():
    results = await asyncio.gather(*(square(i) for i in range(4)))
    print(*results)

asyncio.run(main())