My programming experience.

I started with the classic HTML+CSS+Javascript stack. My first exposure to programming was in my aforementioned IPT class, where our task was to just follow the CodeAcademy course for basic HTML/CSS. The ability to write some abstract code and have something actualise onto the screen facinated me.

I started to learn some basics in Javascript in order to do more. I followed the Javascript basic course on CodeAcademy, but I believe the book Eloquent JavaScript" by Marijn Haverbeke really taught me what code could be, and the many various approaches to structuring and developing a codebase. I found myself favouring the more functional map/filter/reduce aspects of Javascript, which still defines the types of languages I am interested in (i.e Rust).
I even liked taking the map/filter/reduce to its extremes, writing one-line expression challenges for trivial programming problems. One such admitedly awful instance of this is a one-liner I wrote for a joke Discord bot, which just reformats text into a square with the edges being the word:

const meme = (str: string) => Array(str.length).fill(true).map((_, i) => (!i || i === str.length - 1) ? (!i) ? str.split('').join(' ') : str.split('').reverse().join(' ') : (str[i] + ' '.repeat(str.length * 2 - 3) + str[str.length - 1 - i])).join('\n')

While this one-liner is horrible and not an example of good, concise and maintainable code, and while it may strike fear into the heart of a Java developer, I think it shows the power of what just expressions can do.

What I've worked with.

Over my journey of self-taught programming, I've played around with a lot of different frameworks, languages, operating systems, toolings etc. This section will mention some highlights / languages I've worked a lot with.

JavaScript / TypeScript

Javascript was one of the first proper programming languages I learnt thanks to the CodeAcademy course mentioned above. With the extreme versitility found within the very flawed JS ecosystem, I find myself using this language the most, as learning Javascript lets you write fully functional webapps, back-end processing via NodeJS and desktop applications via Electron. React is my prefered framework when developing dynamic applications as the functional methodology of React feels very intuitive and easier to organise. However, I am not a programmer masochist. Javascript is infamously weakly-dynamically typed, and has many, many, pitfalls that revisions of Javascript (ES6 onwards) has tried to address, but one thing that is not on the table is static typing. This is why my prefered language is Typescript, which is a statically typed superset of Javascript, meaning any valid javascript is a valid typescript program (provided the compiler settings are at default). I find Typescript a much more pleasant experience, as it features some very nice static typing concepts that are heavily inspired from Microsoft's C# language. The difficulties of trying to write types for an untyped language means the team at Microsoft have been doing a lot of work on fleshing out the typing system, to the point where Typescript's typing system is turing complete (yes really!)

Rust(lang)

Rust is a very popular language by Mozilla which has won StackOverflow's "Most Loved" language 7 years in a row now, and for good reason! I was initially motivated out of a desire to avoid learning C++ (or whatever is the most valid subset of C++), and after trying out Golang and not enjoying it due to lack of Generics and, a no-thrills no-functional approch to structuing code, I stumbled upon Rust, completed "The Book" (the offical tutorial book that can be found on the language's home page) and promptly fell in love with the language. Rust features a very robust language that is modeled more closely to the group-theory inspired type systems of Haskell and related functional languages. One such borrowed concept is the datatype of enum. This is not like the enum you would find in Java or C++ that just act as named numbers (however it can act as one). In Rust, enums can hold values that can be pattern matched in order to extract the value depending on what state the enum is in. This means Rust can easily express both nullable types and error types in a completely predictable and managable way. The null type is infamous for being a major source of headaches for developers around the world. A NullPointerError is one of the most annoying problems to deal with, when any of your variables could have been silently null'd in some line somewhere, acting as a landmind for some later line of code to detonate. Rust solves this problem by just not having nulls (except if you're doing explicitally unsafe operations.) Rust represents its nullable/optional types with just a simple enum.

pub enum Option<T> {
    None,
    Some(T),
}
                    

That's it! If you have a function that might not return a value, you return an Option enum which you can then pattern match on None or Some(e). I love this explicit approch to nullable values and error values, it makes it very easy to deduce the behavior of a function just by its type signature, which is how a good typing system should operate. Another aspect of Rust I love is the functional APIs found in many of the standard library modules. Rust implements a trait system, which is similar to the typeclass of Haskell, basically an interface that different types can implement. The functional APIs allow for very concise and elegent ways of expressing operations, ranging from manipulating lists/sequences/channels with the Iterator API, reading/writing/manipulating values in key-value associative types with the Entry API, and much, much more. There is a good reason why Rust is a community favourite, and I hope to do more with it in the future.

Here is a brief list of the various languages I've worked with, in order of competency. I definitely could not write a real working application in Haskell, as much as I wish I could:

1. Javascript/Typescript
2. Python
3. Rust
4. Ruby
5. Go
6. Java
7. Swift
8. C
9. Haskell