sgeisenh

If you're starting from scratch, it is important to strongly consider which language and platform best suits your needs. Anecdotally, a lot of companies have found success using newer languages because they tend to attract a better proportion of talented people.

You can apply the same intuition and things mostly work, but there can be a few surprises.

These theorems are a huge part of the "if it compiles it must be correct" feeling that functional programming often provides.

There has also been a good amount of discussion generated by organizations such as Jane Street concerning the benefits of static typing and type inference in practice. Notably, the free documentation (that is completely coupled with the code) that you get when you design software that takes advantage of the type system.

When you practice something, you usually don't practice it in order to impress others who practice the same thing. Unfortunately, this ends up happening in many cases (usually with abstract things such as pure mathematics or classical music, where appreciation is difficult without context). But in most cases, you produce things that can be appreciated by others, regardless of their interest in the process. If you knit your friend or loved one a cool scarf, they don't necessarily need to be interested in knitting to enjoy wearing it. And if you're a great baker, someone doesn't need to know anything about baking to enjoy your creations.

All the same, ordinary people can have valid negative opinions of things that they aren't proficient in. When a scarf has numerous dropped stitches or a pie doesn't taste quite right, many people can make observations and express their distaste. Just because they aren't knitters or bakers doesn't mean that their critique doesn't "count for anything." They might not be able to pinpoint the part of the process where something went wrong, but that still doesn't invalidate their opinion.

In this case, the intended audience of The Phantom Menace was not film makers, it was ordinary people (in contrast to say Birdman, which may be easier to appreciate if you have some insight into the dramatic world). Maybe it was meant to appeal to a younger crowd (I enjoyed it when I first saw it). Maybe it was meant to appeal to fans of the original trilogy. But the fact remains that aaronbrethorst is entitled to his opinion and his opinion is perfectly valid.

P.S. I also don't like The Phantom Menace, but that doesn't really matter.

The lecture notes are simple and excellent, though at a very high level of abstraction. Though most of the notes are full of references to the original material, which is super nice.

Was a nice read. Thanks for posting!

Obviously these are generalizations, but that's what I have seen in my experience.

The basic premise behind subtypes is that an object of a subtype can be used anywhere that an object of its supertype can be used. Just as an example, if you replace f1 : Animal -> Animal with f2 : Cat -> Thing, there might be some animals that aren't cats, so f2 can't replace f1 everywhere. This is the reason that functions are contravariant on their input.

The industry tends to lag behind academia by at least a couple decades. In the 90's, lots of research was being devoted to functional programming and the various applications of type systems. Now we see various companies starting to use languages like Haskell and ocaml. Nowadays, it seems like dependent types and program verification are popular in academia, so maybe we'll see some of that by 2030.

  type 'a tree =
    | Node of 'a tree * 'a * 'a tree
    | Leaf
  
  let rec reverse = function
    | Node (L, x, R) -> Node (reverse R, x, reverse L)
    | Leaf           -> Leaf
  

It isn't a difficult problem, even having never seen it before. This is one of those warmup problems to test how comfortable a candidate is with basic concepts such as recursion.

By nature, a language which is type safe and strictly typed must be burdened by the limitations of a "particular type checker." This is weak type safety at best. And it looks like there are runtime class checks, so you have all of the traditional drawbacks of dynamic languages.

That's why Ivy League schools aren't well represented. And also why places like CMU or University of California don't appear. Additionally, salaries aren't adjusted for cost of living. Most of the universities here are located in areas with a high cost of living, so salaries will typically be higher.

I'd actually argue the opposite. MLton is one of the best whole program optimizing compilers I have ever used. There are virtually no penalties for abstraction. OCaml has a bit of trouble here, from what I've heard, but I've never personally run into serious performance problems as a result of abstraction.

When an employee isn't motivated, both the employee and employer lose.

If it wasn't for poor library support, I would prefer using SML to OCaml. SML is syntactically simpler and both SML/NJ and MLton have a lot to offer that I haven't yet found with OCaml.

I think one of the biggest mistakes in the life cycle of SML was premature specification. As a result of the language definition, SML has stagnated for almost 20 years. There is now some notion of "Successor ML" (see: http://sml-family.org/), but I honestly don't see it catching on outside of an academic space.

As an academic language, SML is great. It is a great tool for learning functional programming since the learning curve isn't especially steep. It is easy to reason about performance since evaluation order is explicit. And immutability is the default but with mutable types that are easy to use.

The problem becomes much more interesting when you consider optimal parallel performance. The best span you can do is log^2 n. I believe the problem can be reduced to sorting, though it is not required to explicitly sort the sequence of buildings in order to achieve the desired asymptotic performance.

One of the main gripes that people mention with functional languages is that it can be difficult to find developers. Several good universities are pouring out competent programmers.

What I am saying is that a sizable portion of academia uses a variant of ML. Maybe it hasn't caught on in industry, but that doesn't mean that there isn't a community that uses it.

> That right there should tell you something.

A lot of development of core tools for mainstream languages comes from the companies that use them. Clang and LLVM, for example, received support from Intel, Google and Apple just to name a few.

Jane Street has reimplemented much of the OCaml standard library for their own purposes. Facebook has already started implementing tools in Haskell. Once functional languages gain more traction, I suspect that the tools will improve substantially.

While most OCaml implementations have poor standard libraries, Jane Street Capital has released several open source libraries that make it easy to implement high quality, performant applications.