A nice thing from various programming languages ASM BASIC C CPP LUA Python Golang Haskell
Tags: cpp, go, haskell, python
Published: 2021-02-08 22:17:32

---
title: A nice thing from various programming languages ASM BASIC C CPP LUA Python Golang Haskell
published: true
description: I just realize I used 15 programming languages in production. I took took a bit of time to write down one thing useful learned from some of them.
tags: cpp, golang, Haskell, python
cover_image: https://dev-to-uploads.s3.amazonaws.com/i/lwah576kev1lefsxbef2.png
---

# One nice thing from various languages

I don't think there is a best programming language but each of them has some story to tell. Here is a thing I learned from 10 of them.

## Assembly (ASM)

Probably the language I read most without writing a line of it. I learned how instructions are done here and how to compare language performance from a neutral point of view.
ASM is my comparing star. Don't forget that at the end there is a CPU / GPU / TPU running your code.

```asm
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], edi
        mov     eax, DWORD PTR [rbp-4]
        imul    eax, eax
        pop     rbp
        ret
```

https://godbolt.org/ is great for this !


## Basic

```basic
10 LET N=10
20 FOR I=1 TO N
30 PRINT "Hello, World!"
40 NEXT I
```

My first language. Simplicity is the Key. I felt just at home without any programming knowledge, it made it popular in the 80s.

## C 

```
#include <stdio.h>
int main() {
   printf("Hello, World!");
   return 0;
}
```

The Root of Every language. Simple, old but elegant. Few key words and many features. C is the star of longevity.

## Cpp

```
class MyClass {       // The class
  public:             // Access specifier
    int myNum;        // Attribute (int variable)
    string myString;  // Attribute (string variable)
};
```

The meta language. I learned object oriented programming with Cpp. 

Smart pointers is my star for cpp :
- unique pointer (one owner)
- shared pointer (one or many owner)
- weak pointer (user not owner check still exist before use)

https://en.cppreference.com/book/intro/smart_pointers

## Lua

```
    a.x = 10                    -- same as a["x"] = 10
    print(a.x)                  -- same as print(a["x"])
    print(a.y)                  -- same as print(a["y"])
```

Tiny but strong one. Readable without knowing it but fast. Table is my Lua star, a list and a dictionary at the same time.

https://www.lua.org/pil/2.5.html


## Python

```
>>> f'Hello, {name}!'
'Hello, Bob!'
```

Python is the language for scripting. My python star is formatted string. `f'Hello, {name}!'` expanding variables in string feels just more natural than any other language I tried.

## Golang

```
package main

import "fmt"

func send(c chan int) {
	// send 1 to c
	c <- 1 
}

func main() {
    // create channel
	c := make(chan int)
	// run in background
	go send( c)
	// wait for result
	x := <-c
	// print result
	fmt.Println(x)
}
```

Golang is a simple and very portable language from plan9 team. Goroutine and channels are my star for golang. Parallel and concurrent programming fell just simple.

Launch an operation in background and get the result after. The syntax is the clearer I saw.

https://tour.golang.org/concurrency/2

## Haskell

```
let x = 1:x in x
```

Haskell feels like entering programming from an other door. Lost at First it gave me an other vision of programming. Lazy evaluation is my star of Haskell. It allows the language to define an infinite list as it will be used only when requested.

https://wiki.haskell.org/Lazy_evaluation

## Conclusion

I hope this was interesting for you. Learning languages is a new way of looking at computer science.