https://gilmi.me/blog/tags/type%20inference

If you find that helpful, I've made more content on compilers (including live coding a compiler, without narration) which should be easily reachable from my website.

I think one way to simplify language creation is to use an existing language with somewhat similar operational semantics as a compilation target. This simplifies the backend a lot and leaves more time to explore what the language (frontend) should look like. The backend can always be rewritten at a later time. My personal choice is usually JavaScript[1].

Regarding type checkers/type inference, I've also ran into difficulties with this topic, and I've written several articles trying to make it more approachable[2].

[1]: https://gilmi.me/blog/post/2023/07/08/js-as-a-target

[2]: https://gilmi.me/blog/tags/type%20inference

Referential transparency means that when we bind an expression to a name (e.g. `y = f x`), the two are interchangeable, and whenever we use `y` we could just as well use `f x` and vice versa, and the meaning of the code will stay the same.

Enforcing referential transparency in a programming language means that:

- We need to have more control over effects (purity)

- We can use substitution and equational reasoning

The value of referential transparency for me is that I can trust code to not surprise me with unexpected effects, I can use substitution to understand what a piece of code is doing, and I can always refactor by converting a piece of code to a new value or function because referential transparency guarantees that they are equivalent.

Because of that I feel like I can always understand how something works because I have a simple process to figure things out that doesn't require me keeping a lot of context in my head. I never feel like something is "magic" that I cannot understand. And I can easily change code to understand it better without changing its meaning.

Referential transparency is freeing, and makes me worry less when working with code!

---

The other part that is very notable about Haskell is one of its approaches to concurrency - Software Transactional Memory. Which is enabled by limiting the kind of effects we can perform in a transaction block:

https://www.oreilly.com/library/view/parallel-and-concurrent...

31 posts. I write mostly about Haskell, compilers, webdev, and my hobby projects.

- https://gilmi.me/blog/post/2016/10/14/lisp-to-js - Compiling a lisp to JavaScript from scratch in 350 LOC

- https://gilmi.me/blog/post/2022/04/24/learn-twain-bulletin-a... - Build a bulletin board using Twain, Haskell, and friends

- https://gilmi.me/blog/post/2021/04/06/giml-type-inference - Giml's type inference engine

- https://gilmi.me/blog/post/2022/12/13/learned-from-haskell - 7 things I learned from Haskell

- https://gilmi.me/blog/post/2023/07/01/why-i-use-twain - Why I use the Twain web framework

1. It's super easy to install. If you have a rust toolchain, just `cargo install mdbook`

2. One command to initialize: `mdbook init my-book`

3. One command to get immediate continuous feedback: `mdbook serve`

4. It allowed me to keep writing in my preferred environment (emacs)

5. It looked good by default. I could focus on the content.

6. Setting up auto deploy ci on github is about 30 lines for yaml

Though one point of improvement would be better support for other export formats such as pdf and epub.

tl;dr mdbook allowed me to use the path of least resistence to complete my project, and I highly recommend it.

Also it is possible other platforms can do the same or better but I haven't tried them.

- Consider Haskell - https://gilmi.me/blog/post/2020/04/28/consider-haskell

- Learn Haskell by building a blog generator - https://lhbg-book.link

- https://marcosampellegrini.com/simple-haskell-book

- https://leanpub.com/production-haskell

https://www.youtube.com/watch?v=nY1BCv3xn24

- https://course.ccs.neu.edu/cs4410sp21

- https://ucsd-cse131-f19.github.io

These two articles for garbage collection:

- http://www.more-magic.net/posts/internals-gc.html

- http://journal.stuffwithstuff.com/2013/12/08/babys-first-gar...

This desire is usually expressed with sentiments like "let's make this easier to learn" and "Let's fix this so it's not a footgun", and not "success at all cost".

- Simple Haskell Handbook[1]

- Haskell (Almost) Standard Libraries[2]

- [0]: https://lhbg-book.link

- [1]: https://marcosampellegrini.com/simple-haskell-book

- [2]: https://leanpub.com/haskell-stdlibs/

https://gilmi.me/blog/post/2020/04/28/consider-haskell