gilmi

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

[0]: https://github.com/soupi/haskell-study-plan

I think one of the cool things about Haskell is that there's quite a high ceiling in terms of solutions you can reach for. On many occasions when one get annoyed by something and thinks "there must be a better way", there is one.

You show how one with more knowledge and command of the language can make it do a lot of things for free, and that is very cool! But I can also see how these solutions can look a bit intimidating for people with less experience, and it's important to take this into account as well.

This is kind of a double edged sword. Gotta find the right balance.

Also, I'll update the text about kinds when GHC will use Type instead of * everywhere:

$ ghci

GHCi, version 9.2.2: https://www.haskell.org/ghc/ :? for help

λ> :k (,)

(,) :: * -> * -> *

[0]: https://rust-lang.github.io/mdBook

In the test suite you write your tests against the library. You can do that at any stage, even before writing a line of library code.

But yes, Haskell also has a REPL that can be used to experiment with code.

  GHCi, version 9.2.1: https://www.haskell.org/ghc/  :? for help
  ghci> 1 + [2, 3]
  
  <interactive>:1:1: error:
      * No instance for (Num [Integer]) arising from a use of `it'
      * In the first argument of `print', namely `it'
        In a stmt of an interactive GHCi command: print it

I don't think it's fair to draw the conclusion that the Haskell community don't care sufficiently about beginners from this, since only selected few of the community has the ability (and time) to work on GHC and improve the state of error messages.