jmct

Looks like you found them, and yes. :D

They weren't made with the thought of being generally consumed, but I do plan on making videos for the wider CS/programming community in the future.

Apologies for causing a spike in your impostor syndrome!

330 is 'required' in the sense that you're not allowed to take 430 at UMD without having taken 330.

Perhaps a better way of phrasing it would have been to list the things we assume students have retained from 330. One of which is OCaml :D

I hope these videos provide some value to you! Always feel free to reach out if there's anything you think I could do better.

Wonderful bit of history!

I'm one of the faculty that teach the current version of this course.

Would you mind getting in contact with us? We would love to learn more about PL/UM. It would mean a lot: {jmct|dvanhorn}@umd.edu

Those are my videos!

That's true in one direction, but not the other.

The other angle is that concurrent programs are still concurrent on a uni-processor. Parallel programs are not.

Just to add on to this:

The languages people use at Galois lean towards functional programming languages: Haskell, Coq, etc. and systems languages: C, Rust (increasingly).

The reason GHC won't infer the definition of Applicative is because there can be multiple valid `Applicative` instances for a type (unlike `Functor` where there is a unique (non-trivial) instance).

The canonical example of this is lists, with 2 valid instances of `Applicative`.

The author of the post seems to have this realization, but I wanted to call it out, just in case.

Galois does not work on financial products. It is a research services company (i.e. R&D for hire) that focuses on high-assurance software.

Haskell does not do this. Haskell is lazy (computed results are shared), but Haskell does not memoize by default. To illustrate:

    func y = let z = y + y
             in (add 1 z) * (add 1 z)

in `func` the result of computing `y + y` is shared because it has been given a name: `z`. However, the result of `add 1 z` is _not_ given a name and therefore has to be computed twice. Because Haskell is pure, they will result return the same result, however the result is not saved.

This avoids needing to save the results of _all_ function calls.

Do you live in a big (or bigger than average) city?

I live in the UK in a small town and can not imagine having kids but no car. Most of my friends find having a car is essential even without kids (though I prefer to not have a car unless 100% necessary).

On my own I am fine with public transport, but anything between walking around the village or going to a big city isn't really covered by public transport.