Lush: My favorite small programming language

3 months ago (scottlocklin.wordpress.com)

30 comments

todsacerdoti

Reply
ngriffiths  3 months ago

Makes me curious what state R was at the time, or whatever else could've been useful for deep learning, and the benefits of a new language vs adapting something that exists. Seems like it was a big investment

  • antononcube  3 months ago

    R and its ecosystem have some unbeatable features, but, generally speaking, the "old", base R is too arcane to be widely useful. Also, being "made by statisticians for statisticians" should be a big warning sign.

    • nxobject  3 months ago

      Despite being made by statisticians, I ironically find that munging R packages together for certain classes of analysis such a slog that it prevents me from doing the actual statistical thinking. Sometimes the plots fall behind commercial packages, sometimes the diagnostics, and sometimes you have to combine multiple incompatible packages to get what a commercial package can do.

      (Survival analysis and multilevel modeling comes to mind.)

      1 reply →

    • wdkrnls  3 months ago

      On the contrary, I find base R less arcane than the current de jour python libraries which copied it

  • _Wintermute  3 months ago

    In my opinion R should thought of as an unbeatable graphical calculator, but an awful programming language.

    • williamcotton  3 months ago

      The tinyverse collection of packages makes things a lot more sane, IMO:

        penguins <- read_csv("penguins.csv") |>
    na.omit() |>
    select(species, island, bill_length_mm, body_mass_g) |>
    group_by(species, island) |>
    summarize(
      mean_bill_length = mean(bill_length_mm),
      mean_mass = mean(body_mass_g),
      n = n()
    ) |>
    arrange(species, desc(mean_bill_length))
  
  penguins |>
    ggplot(aes(x = species, y = mean_bill_length, fill = island)) +
    geom_col(position = "dodge") +
    labs(
      title = "Mean Bill Length by Species and Island",
      y = "Mean Bill Length (mm)"
    ) +
    theme_minimal()

      1 reply →

    • currymj  3 months ago

      i would compare base R to basically a shell. meant to be used interactively. okay for small scripts. you can write big programs but it will get weird.

    • wdkrnls  3 months ago

      You must hate lisp/scheme then too, which has similar semantics as R. In that case books such as SICP would be lost on you.

    • perrygeo  3 months ago

      That's how I view it. I still use R for plotting and quick stats analyses but it is painful to do any real work.

      I recommend the article "Evaluating the Design of the R Language" [1] - it reads like a horror story. The memory usage and performance is abysmal, the OO features are a mess, and the semantics are very weird ("best effort semantics" is about as predictable as it sounds!). The lexical scoping is based on Scheme but has so many weird edge cases. It's a dumpster fire of a language, but it somehow works for its intended purpose.

      [1] http://janvitek.org/pubs/ecoop12.pdf

knighthack  3 months ago

What does 'small' really mean?

I would think of a language like Go as small (say, in comparison to Rust or Swift) - the language itself at least, if you discount the standard library.

I find the use of the word 'small' quite confusing.

  • jerf  3 months ago

    The author appears to be defining it in terms of the effort put in to the language, basically, person-hours.

    Go may be a small language by some definitions (and as my phrasing implies, perhaps not by others), but it is certainly one that has had a lot of person-hours put into it.

  • emmanueloga_  3 months ago

    The problem is that there's no universal definition of "small" when it comes to languages.

    An article on the Brown PLT blog [1] suggests analyzing languages by defining a core language and a desugaring function. A small core simplifies reasoning and analysis but can lead to verbose desugaring if features expand into many constructs. The boundary between the core and sugared language is flexible, chosen by designers, and reflects a balance between expressiveness and surface simplicity.

    Feature complexity can be evaluated by desugaring: concise mappings to the core suggest simplicity, while verbose or intricate desugarings indicate complexity.

    So, a possible definition of a "small" language could be one with both a small core and a minimal desugaring function.

    --

    1: https://blog.brownplt.org/2016/01/08/slimming-languages.html