Learning your first programming language

Table of contents 🔗

Introduction 🔗

Wow. It's one of those posts again!

Yes, I'm writing this blog post to fill up my blog. Also, when searching "first programming language to learn", it's always a "top 5" with no example and just bullet points.

Most of them recommend Python, in which I certainly do not recommend.

There is a lot of criteria to consider when choosing a programming language, especially the first.

Criteria 🔗

Before they even start, in reality, someone never wants to program first. Instead, they have an idea in mind, and want to make it possible.

In software programming, the first-time programmer often need to learn these concepts:

• Syntax
• Types
• Operators
• Control Flow
• Functions
• Error handling
• Debugging
• Algorithm
• Data structures
• IO
• Code style and Best practices

That's a lot, and most of the time, the novice programmer doesn't want to learn it all. However, learning as much as possible will certainly benefit the novice programmer's future work.

This is why, my criteria for choosing a programming language are the following:

1. Ease of Learning: Being able to learn most of the concepts in a minimum of time.
2. Availability: Not every programming language is accessible. Setting up a programming environment should not be difficult.
3. Goal: It is possible to program in every language. But some are certainly "domain"-specific.
4. Trend: Learning a dying programming language will simply demotivate the programmer.

I'm also taking account that the person won't be learning one programming language.

To be a good developer is to diversify since the future is uncertain. Do not over-specialize, be a generalist.

I've used all the languages mentioned in this article at some point in my life as a software engineer. I used develop software for Embedded Systems, Machine Learning, DevOps, Games, VR, Backend, Front-end (Web, Qt, Flutter, Android). It's always interesting to learn the syntax, rationale, behavior and paradigm of a programming language to understand how the programming ecosystem will evolve.

Your first programming language for embedded systems: Arduino (C++) 🔗

Are we already starting with something hard? Not really, let me explain.

A good gift to someone to start programming is often an Arduino with an LCD shield.

While C++ is often recognized as a complex language, Arduino has abstracted most complex parts and propose a simple syntax:

1void setup() {
2  // put your setup code here, to run once:
3}
4
5void loop() {
6  // put your main code here, to run repeatedly:
7}

When opening the Arduino IDE, you are already exposed to Arduino's syntax:

• setup is a function that only runs once
• loop is a function that run repeatedly

The IDE has a simple compile button and upload button to verify and deploy on an actual Arduino.

The IDE also includes examples, one being DigitalReadSerial which read the signal of a button and send the result via USB:

 1// digital pin 2 has a pushbutton attached to it. Give it a name:
 2int pushButton = 2;
 3
 4// the setup routine runs once when you press reset:
 5void setup() {
 6  // initialize serial communication at 9600 bits per second:
 7  Serial.begin(9600);
 8  // make the pushbutton's pin an input:
 9  pinMode(pushButton, INPUT);
10}
11
12// the loop routine runs over and over again forever:
13void loop() {
14  // read the input pin:
15  int buttonState = digitalRead(pushButton);
16  // print out the state of the button:
17  Serial.println(buttonState);
18  delay(1);  // delay in between reads for stability
19}

The code is commented, and the syntax is easy to understand:

 1// Decleare a variable
 2<variable-type> <variable-type> = <variable-value>;  // int pushButton = 2;
 3
 4// Declare a function
 5<return-type> <function-identifier>(<function-parameters>) { // void setup() {
 6    <function-body>
 7}
 8
 9// Use a function
10<function-identifier>(<function-parameters>); // digitalRead(pushButton);

Many benefits to use Arduino as a first programming language:

• The syntax is explicit.
• The integrated development environment is friendly.
• The execution is simple.
• The community is alive.
• The language can be generalized in software development with C++.
• Pointers are not shown and Arduino allows global variables instead.

Overalls, Arduino is one great way to start programming!

Your first programming language for software 🔗

No Arduino? Well, It's time to search through the many programming languages available.

I will be quick, these are languages that programmers often start to learn:

• Python
• C
• C++
• Rust
• Go
• JavaScript
• Typescript
• Java
• C#
• PHP
• Kotlin
• Objective-C
• Lua
• Ruby

That's a lot, and all of them can make software (to a certain level). As a senior developer, I would recommend a programming language in which you will be able to refactor and maintain in the future. It's almost certain that the first project of a programmer is ugly, filled with bad practices.

I will immediately remove languages that are too domain-specific and that are hard to make a Terminal User Interface or Graphical User Interface. After all, one concept to learn is input/output, meaning being able to print and read from the user inputs.

This removes Java, C#, PHP, Kotlin, Objective-C.

We can also remove language that a "dying": Lua and Ruby. Note that they aren't really dying, but shine only with certain conditions. Lua is extremely great to write plugins and mods (Garry's mod for example, or Roblox). Ruby shines in backend development, but Python and Go has proven to be more "friendly" to backend development.

I will now talk about the rest.

Python, JavaScript and Typescript: Simple, but full of the bad practices, like the scripting languages they are. 🔗

To understand why I would not recommend Python, JavaScript and Typescript. Let me cite the Wikipedia definition of Python:

Python is a high-level, general-purpose programming language. Its design philosophy emphasizes code readability with the use of significant indentation.

Python is dynamically typed and garbage-collected. It supports multiple programming paradigms, including structured (particularly procedural), object-oriented and functional programming. It is often described as a "batteries included" language due to its comprehensive standard library.

All of these features abstracts a lot of programming concepts that are important as a software engineer.

• Let's start by high-level: this means a lot of computer and programming "details" are heavily abstracted like the compilation step and memory management. While I do also think that memory management (memory allocation and freeing) is not required, I do think that missing the compilation step is a grave mistake. When using an interpreted (vs compiled) programming languages, most errors happens at runtime. To avoid most errors, you need to install tools like the static analyzer pylint (which is not included in the REPL/interactive mode).

• Dynamically typed: This means that types are NOT strict. For example:

  1# <variable-identifier> = <variable-value>
  2a = 2
  3a = "test"
  4print(a) # Prints "test"
  

  This works. However, this behavior is problematic: what is the type of "a" at a certain point in time? Again, this causes more issues at runtime than a compiled language. Typescript also has this issue:

  1// let <variable-identifier> = <variable-value>
  2let a = 2;
  3a = 'test' as unknown as number;
  4console.log(a); // Prints "test"
  

• Garbage-collected: This means that the language manages memory allocation for you. To be honest, this isn't really a problem, especially since we all have buffed computers.

• Multiple programming paradigms: This means there are multiple ways to achieve a solution. While you may say: "Good! That mean I'm free to do whatever I want, with the syntax that I prefer.", this also means: "I cannot read other people solution because I don't understand the syntax". This feature adds complexity and implicitness to the language.

• Indents vs Brackets: In reality, you don't care about indents (tab, spaces...) and brackets. You should let your IDE format your code, so that it is standard.

That's why I would never recommend Python, JavaScript or Typescript. These are scripting languages like Bash and Perl. Learning them can be easy at first, but like any scripting language, you're much more likely to shoot yourself in the foot when you scale up.

To avoid shooting yourself in the foot, you have to learn best practices like the PEP8 and PEP257 and have a multitude of tools to lint and format.

To summarize, Python, JavaScript and Typescript suffer from:

• Implicitness
• Error-prone and likely at runtime
• Syntax is simple, but the number of solutions adds in complexity
• Prone to bad practices

And I haven't talked about Typescript let, var const, ===... and the packaging ecosystem which is also dreadful (pnpm or yarn or bun? pip or conda? left-pad???).

Overall, to be avoided at all costs. Especially, for learning programming concepts.

C: simple to write, hard to bootstrap, compile and debug 🔗

Compared to what we saw, C is a low-level compiled programming language with a static type system. C is not designed for Object-Oriented Programming, but it is still possible to do OOP by using structures, header files and composition.

C syntax is quite explicit and simple:

 1#include <stdio.h>
 2
 3int main() {
 4    int count = 1; // Initialize the counter to 1
 5
 6    while (count <= 10) { // Continue looping while count is less than or equal to 10
 7        printf("Count: %d\n", count); // Display the current count
 8        count++; // Increment the counter
 9    }
10
11    return 0; // Exit the program
12}

But one concept can be difficult to learn: Pointers and Memory Management:

 1#include <stdio.h>
 2#include <stdlib.h>
 3
 4int main() {
 5    // Declare a pointer to an integer
 6    int *ptr;
 7
 8    // Allocate memory for an integer dynamically
 9    ptr = (int *)malloc(sizeof(int));
10
11    if (ptr == NULL) {
12        printf("Memory allocation failed\n");
13        return 1;
14    }
15
16    // Assign a value to the dynamically allocated memory
17    *ptr = 42;
18
19    // Access and print the value using the pointer
20    printf("Value: %d\n", *ptr);
21
22    // Deallocate the memory to prevent memory leaks
23    free(ptr);
24
25    // After freeing, the pointer should be set to NULL
26    ptr = NULL;
27
28    return 0;
29}

To summary, a pointer holds a memory address. malloc(sizeof(int)) allocates memory for a integer (natural number) and returns the memory address. To change/get the value of the allocated memory, you must invoke *ptr. After doing malloc, you should always call free at the end.

Since C is too "simple" and low-level, managing the memory can be quite dreadful. There is no safety for the pointer: when reading the value of a pointer (also known as dereferencing), this may read garbage because the memory wasn't allocated, or the pointer is NULL. Reading a NULL pointer also crash the program with a segmentation fault (core dump), with no log nor stack-trace. You need to use a debugger to be able to check where the program crashed. Also, fetching the core dump is not trivial.

There are other drawbacks too:

• Not friendly with Windows (but you should switch to Linux anyway)

• Dreadful linking step: While you can learn how to compile with C (compilation = convert code into binaries), linking third-party libraries is quite difficult. You need to learn how to use a build system like Make or CMake to be able to link safely, which may adds a configure step:

   1# Makefile for compiling the main.c program with math library
   2
   3# Compiler and flags
   4CC = gcc
   5CFLAGS = -Wall -Wextra -g
   6LDFLAGS = -lm
   7
   8# Target executable
   9TARGET = main
  10
  11all: $(TARGET)
  12
  13# Linking step
  14$(TARGET): main.o
  15    $(CC) $(LDFLAGS) -o $(TARGET) main.o
  16
  17# Compile step
  18main.o: main.c
  19    $(CC) $(CFLAGS) -c main.c
  20
  21clean:
  22    rm -f $(TARGET)
  

• Dreadful static compilation and export: The program is hard to share. You need the libraries versions to match between computers if compiled as a dynamically-linked executable (default behavior). If compiled as a static executable, you need all the C library to be statically compiled. However, glibc is not statically compilable, and you need to use muslc.

• Dreadful ecosystem due the last two points.

• Macros which are used for compile-time operations. This is often abused due to the lack of "checks" to the macros.

I would recommend learning C as the second programming language to understand how memory allocation works. Otherwise, there are better alternatives.

C++: same as C, but with a better standard library and easier to use for OOP 🔗

Like the title said. It has the same drawbacks as C.

At least it easier to use a dynamically-sized list with C++:

 1// Example with C
 2// structure definition
 3typedef struct {
 4    int *data;
 5    size_t size;
 6    size_t capacity;
 7} IntList;
 8
 9void initIntList(IntList *list, size_t initialCapacity) {
10    list->data = (int *)malloc(initialCapacity * sizeof(int));
11    if (list->data == NULL) {
12        fprintf(stderr, "Memory allocation failed\n");
13        exit(1);
14    }
15    list->size = 0;
16    list->capacity = initialCapacity;
17}
18
19void pushBackInt(IntList *list, int value) {
20    if (list->size == list->capacity) {
21        list->capacity *= 2;
22        list->data = (int *)realloc(list->data, list->capacity * sizeof(int));
23        if (list->data == NULL) {
24            fprintf(stderr, "Memory allocation failed\n");
25            exit(1);
26        }
27    }
28    list->data[list->size++] = value;
29}
30
31void freeIntList(IntList *list) {
32    free(list->data);
33    list->data = NULL;
34    list->size = list->capacity = 0;
35}
36
37int main() {
38    IntList intList;
39    initIntList(&intList, 2);
40
41    pushBackInt(&intList, 42);
42    pushBackInt(&intList, 56);
43    pushBackInt(&intList, 78);
44
45    for (size_t i = 0; i < intList.size; ++i) {
46        printf("%d ", intList.data[i]);
47    }
48    printf("\n");
49
50    freeIntList(&intList);
51
52    return 0;
53}

 1// Example with C++
 2#include <iostream>
 3#include <vector>
 4
 5int main() {
 6    std::vector<int> intVector;
 7    // The return type here is a little complex. This means:
 8    // <namespace>::<object name><[template type]>
 9    // C++ is able to template classes and functions, meaning it is able to "generalize" a class or a function to other types.
10
11    intVector.push_back(42);
12    intVector.push_back(56);
13    intVector.push_back(78);
14
15    for (size_t i = 0; i < intVector.size(); ++i) {
16        std::cout << intVector[i] << " "; // This is printing.
17        // Basically, cout is a input stream/flow. By doing "<<", you adds the value to the stream.
18        // Different, but actually quite clever.
19    }
20    std::cout << std::endl;
21
22    return 0;
23}

A lot of data structure is included in the standard library, making a great language for competitive programming.

However, C++ adds a few new drawbacks:

• New syntax which may be more complex. For example, there is too many ways to iterate:

   1// 1. Using a for loop with vector
   2for (int i = 0; i < 5; i++) {
   3    std::cout << vec[i] << " ";
   4}
   5std::cout << std::endl;
   6
   7// 2. Using a range-based for loop with vector
   8for (int num : vec) {
   9    std::cout << num << " ";
  10}
  11std::cout << std::endl;
  12
  13// 3. Using an iterator with vector
  14for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
  15    std::cout << *it << " ";
  16}
  17
  18// 4. Using for_each with a lambda from the algorithm library
  19std::for_each(std::begin(arr), std::end(arr), [](int num) {
  20    std::cout << num << " ";
  21}); // A lambda (anonymous first-class function) is used here.
  22// The syntax is the following:
  23// [](<function-parameters>) -> <return-type> {
  24// The identifier is [], which means anonymous.
  25std::cout << std::endl;
  

• Functions overloading, which adds complexity to the language by making multiple functions that hold the same name. Even the auto-completion is hard to read.

   1#include <iostream>
   2
   3// Function overloading
   4int add(int a, int b) {
   5    return a + b;
   6}
   7
   8int add(int a, int b, int c) {
   9    return a + b + c;
  10}
  11
  12int add(int a, int b, int c, int d) {
  13    return a + b + c + d;
  14}
  15
  16int main() {
  17    // Calling functions with different parameter lists
  18    int sum1 = add(2, 3);
  19    int sum2 = add(2, 3, 4);
  20    int sum3 = add(2, 3, 4, 5);
  21
  22    std::cout << "Sum 1: " << sum1 << std::endl;
  23    std::cout << "Sum 2: " << sum2 << std::endl;
  24    std::cout << "Sum 3: " << sum3 << std::endl;
  25
  26    return 0;
  27}
  

• Abusive templates in some cases, making it hard to debug or even read/write code.

Overalls, C++ is a no-go to learn as a first programming language.

Rust: an alternative to C++, but a lot more "safe" 🔗

Rust is a compiled low-level programming language with type safety, null safety, memory safety, concurrency and multi-paradigm. It borrows concepts from functional programming like immutability, first-class citizen functions. Basically, it solves all the problems with C.

Some people say that Rust has a steep learning curve, I would argue that the steepness only come when using functional programming features and memory management.

Syntax-wise, it is quite simple:

 1// Function that adds two numbers and returns the result
 2fn add_numbers(a: i32, b: i32) -> i32 { // fn <function-identifier>(<function-parameters>) -> <return-type> {
 3    let sum = a + b; // Variable declaration and addition
 4    return sum
 5}
 6
 7fn main() {
 8    // Variable declaration with explicit type annotation
 9    let x: i32 = 5;
10    let y: i32 = 7;
11
12    // Function call and assignment of the result to a variable
13    let result = add_numbers(x, y);
14
15    // Printing the result to the console
16    println!("The sum of {} and {} is {}.", x, y, result);
17}

Rust also has multiple ways to iterate a vector (dynamically-sized array):

 1// Method 1: Using a for loop
 2println!("Using a for loop:");
 3for num in &numbers {
 4    println!("{}", num);
 5}
 6
 7// Method 2: Using a while loop with an iterator
 8println!("Using a while loop with an iterator:");
 9let mut iterator = numbers.iter();
10while let Some(num) = iterator.next() {
11    println!("{}", num);
12}
13
14// Method 3: Using `iter().enumerate()` to get both index and value
15println!("Using `iter().enumerate()` to get both index and value:");
16for (index, num) in numbers.iter().enumerate() {
17    println!("Index: {}, Value: {}", index, num);
18}
19
20// Method 4: Using the `iter()` method and `for_each()`
21println!("Using the `iter()` method and `for_each()`:");
22numbers.iter().for_each(|&num| {
23    println!("{}", num);
24});

Rust is still complex due to the richness of the ecosystem. This could cause issues when reading the code of a person.

Rust solves these issues compared to C++:

• Memory safety by using an ownership system instead of malloc or smart pointers.
• Null-safety by using Option.None and Option.Some(T)
• Package management: There is cargo, package manager that can be used to compile and pack your program, and manage dependencies. C++ has no official package manager.

The most difficult part is memory management, due to its borrower checker. Although the borrow checker enables memory safety, learning it before you know "why it's needed" can be quite "paradoxical" (maybe). It's probably a good idea to learn C and Rust at the same time.

Another criticism of Rust is the "implicit" nature of macros. This point is also debatable.

Overalls, Rust is pretty good to start with, until you hit the memory management wall combined with concurrency.

Go: THE language that I recommend 🔗

Go is a compiled high-level programming language with static typing and garbage collection.

Immediately, one drawback is implicit memory management and hardware abstraction. However, this issue only comes if we WANT to manage memory and handle hardware at low-level.

Go's syntax is simple and explicit and actually shines because of it. Almost all program written in Go will have the same solution. This is to iterate a slice (dynamically-sized view of an array):

 1package main
 2
 3import "fmt"
 4
 5func main() { // func <function-identifier>(<function-parameters) (return-types) {
 6	// Create a slice of integers
 7	numbers := []int{1, 2, 3, 4, 5}
 8
 9	// Iterate over the slice using a for loop
10	fmt.Println("Iterating over the slice:")
11	for index, value := range numbers {
12		fmt.Printf("Index: %d, Value: %d\n", index, value)
13	}
14}

While the language has no ;, the indentation is also not important compared to Python. Go determines a statement by reading ahead and insert the semicolon when two statements are not compatible.

Since this is the language I recommend, let me list all the benefits of Go:

• Explicit and simple syntax.

• Easy install and setting up of Go in your favorite IDE

• Easy package management, directly included in Go via go get.

• Easy formatting with goimports or gofmt.

• Easy concurrency with goroutines and standard patterns like the Context API.

• Standard concurrent stream with channels:

   1package main
   2
   3import (
   4    "fmt"
   5)
   6
   7func main() {
   8    // Create a channel
   9    ch := make(chan int)
  10
  11    // Start a goroutine
  12    go func() {
  13        ch <- 42 // Send a value to the channel
  14    }()
  15
  16    // Receive and print the value from the channel
  17    value := <-ch
  18    fmt.Println("Received:", value)
  19}
  

• Easy directory structure via modules and packages:

  1.
  2├── cmd # <your-module>/cmd
  3│   └── cmd.go
  4├── main.go
  5├── go.mod # <your-module>
  6└── go.sum
  

• Easy and explicit error handling via error as a value:

  1// Divide function returns a result and an error
  2func Divide(a, b float64) (float64, error) {
  3    if b == 0 {
  4        return 0, errors.New("division by zero")
  5    }
  6    return a / b, nil
  7}
  

• Easy testing and benchmarking:

   1// mymath_test.go
   2package mymath_test
   3
   4import (
   5    "testing"
   6    "mymodule/mypackage/mymath"
   7)
   8
   9func TestAdd(t *testing.T) {
  10    result := mymath.Add(2, 3)
  11    expected := 5
  12
  13    if result != expected {
  14        t.Errorf("Add(2, 3) = %d; expected %d", result, expected)
  15    }
  16}
  17
  18func BenchmarkAdd(b *testing.B) {
  19    // Benchmark the Add function with inputs 2 and 3
  20    for i := 0; i < b.N; i++ {
  21        _ = mymath.Add(2, 3)
  22    }
  23}
  

• Easy static and multi-platform compilation:

  1CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o ./executable ./main.go # static executable for linux
  2CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -o ./executable ./main.go # static executable for windows
  

• And more...

Go shines by being simple and explicit, making it easy to read by other people. It enables to follow best practices automatically and write idiomatic Go code. Therefore, it is a great language for open-source.

Even if Go is simple, it might be too simple. Go is missing some features that some other modern programming language has:

• No default parameters. But there is one way to achieve this, is to use the optional functions via variable-length parameters list:

   1// Options is a struct for specifying optional parameters
   2type Options struct {
   3    Param1 string
   4    Param2 int
   5}
   6
   7// DefaultOptions returns an Options struct with default values
   8func DefaultOptions() Options {
   9    return Options{
  10        Param1: "default_param1",
  11        Param2: 42,
  12    }
  13}
  14
  15func MyFunction(requiredParam string, options ...func(*Options)) {
  16    // Create an Options struct with default values
  17    opt := DefaultOptions()
  18
  19    // Apply the provided options
  20    for _, option := range options {
  21        option(&opt)
  22    }
  23
  24    // Use the options in the function
  25    fmt.Println("Required Parameter:", requiredParam)
  26    fmt.Println("Optional Parameter 1:", opt.Param1)
  27    fmt.Println("Optional Parameter 2:", opt.Param2)
  28}
  

  Rust also has this issue.

• No compile-time solution besides code generation. No customizable build-system.

• Visibility by naming: Majuscule for public, minuscule for internal. This is actually debatable. In my opinion, it isn't that bad and you write code faster.

• No nil safety combined with Interfaces as pointers, making it "panic"-prone:

   1// MyInterface is an example interface
   2// An interface is a "unimplemented" type used to define public behavior (e.g. public methods).
   3type MyInterface interface {
   4    SayHello()
   5}
   6
   7func main() {
   8    var myVar MyInterface // MyInterface is nil, not MyInterface{} because it is an unimplemented type
   9
  10    // This will cause a runtime panic because myVar is nil
  11    myInterface.SayHello()
  12}
  

And, that's it. Some may say that Go is too simple. I do believe that explicitness and simplicity are the most important criteria to select the first programming language to learn all the programming concepts.

Overall, Go is the language I recommend.

Bonus: Zig: THE next language that I recommend 🔗

Zig is a compiled low-level programming language with static typing that can be used to replace/complement C.

It looks like this:

1const print = @import("std").debug.print;
2
3pub fn main() void {
4    print("Hello, world!\n", .{});
5}

Syntax-wise, it almost looks like Rust, but it is way more explicit.

Zig has already an article explaining why Zig is needed. To summarize, it wants to be even more explicit and simple:

• No hidden control flow

• No hidden allocations

• Optional standard library

• A Package manager (vs C/C++)

• Easy static compilation (vs C/C++/Rust)

• Build system included (vs C/C++/Rust/Go)

• comptime statements to declare compile time variable and functions:

  1fn multiply(a: i64, b: i64) i64 {
  2    return a * b;
  3}
  4
  5pub fn main() void {
  6    const len = comptime multiply(4, 5);
  7    const my_static_array: [len]u8 = undefined;
  8}
  

Zig is still not production-ready, so we have to wait for concurrency. Zig is also lacking in linting/formatting due to the zig language server slow development.

Overall, if Zig is stable, you should learn it, because it may be as good as C/C++/Go/Rust. It is already used in production with Bun.

One last point: To OOP or not 🔗

Object-Oriented Programming or Functional Programming are programming paradigms that can be used to architecture your code.

Some talk about Clean Code, Clean Architecture, others talk about functions purity.

In reality, as I said at the beginning, you should never over-specialize. Always take these principles with a pinch of salt. You can try them, but you have to accept that there may be other ways.

A computer is naturally "procedural", so functional programming may not be adapted. Same for OOP:

• There are more cases where composition is better than inheritance.
• Over-architecturing is useless if your coworker don't know about it.

Conclusion 🔗

Based on explicitness and simplicity, here's my recommendation on which programming language you should learn:

1. Zig (when stable)
2. Go
3. Rust + C (together would be great)

With these programming languages, you can learn most of the programming concepts rapidly and naturally, without learning bad practices.

Also, this is my recommendations for domain-specific programming languages:

• Web front-end: TypeScript
• GUI: C++ with Qt, or Python with Qt. (Or Typescript with Electron, please don't). Dart with Flutter. Kotlin with JavaFX.
• Android: Kotlin or C++.
• Embedded Systems: C, C++, Zig, Rust or Arduino (if possible).
• High Performance Computing: C, C++, Zig, Rust.
• Games: C++ with Unreal, C# with Godot (F- Unity). For the choice of the game engine, I would recommend to start with any of them and let your passion go crazy.

I also recommend you to learn about:

• Auto-completion
• Auto-formatting
• Linting
• Snippets

Which should be included in your favorite IDE. These are the tools used to make programming more fun.

Although I've given you some recommendations on these languages, the final criterion is often the same: "Do you have enough resources (time, money, ...) to learn and use it?". Like any tool, the real cost is not the tool itself, but the consequences that come from it.

If you have more or less time and are used to programming syntax, you can learn numerous programming languages with Learn X in Y minutes.