1. 21

What novel or fringe language(s) do you find interesting and would like to learn at some point, either more thoroughly or for the first time? For me, the answer is Rust (high-level systems programming with a dash of Ruby—not so new anymore, I know), Idris (an early look at dependent types), and J (pith). Do respond even if you have your own rationale for an existing answer.

  1.  

  2. 16

    Rust also.

    1. 11

      Idris (because I think it’s the future of software development - I think provably correct software will become more and more necessary as attacks become easier, and Idris seems to be the best effort at a system for producing provably correct software that does things), and Noether (seems to be even further in the same direction, and the model is interesting).

      1. 3

        provably correct software will become more and more necessary as attacks become easier

        Does provably correct imply provably secure? I’m not sure, but don’t know.

        1. 3

          Valid proofs of the wrong correctness criterion are a real thing. “Correct” and “secure” are both informal notions that need to be formalized as part of this, and they are easy to get wrong.

          But I still think this approach moves in a useful direction.

          1. 2

            I’m not sure either but I would not be surprised if provably correct is not at least a prerequisite of a provably secure system.

            1. 2

              It certainly makes making a more secure system more possible.

            2. 1

              Not necessarily, thanks to hardware bugs. Might still be vulnerable to things like rowhammer.

              1. 1

                Of course those issues still affect any other language too.

                1. 1

                  Beware of bugs in the above code; I have only proved it correct, not tried it.

                  –Donald Knuth

                  1. 3

                    That quote is still funny, but I think only partly applicable. Knuth proved code correct in a less direct way than systems like Idris or ACL2 do, because the proof isn’t directly connected to the source code in a machine-checkable way, making it much more likely the code doesn’t match the proof (either for substantive reasons, or simple typos).

                    1. 1

                      Yes I agree. To say “Oh but it still has this problem that other languages do” is an unreasonable distraction from the premise that it is still a LOT better. No one is claiming unshakable code, but they are claiming as good as (currently) possible assuming the proofs are in line with the requirements.

              2. 1

                If the spec is secure then yes. It should generally imply no RCE at least, simply because RCE is likely never correct behaviour. Things like provable confidentiality would require more work.

            3. 7
              • Go: moving away from C entirely instead of building on top of the legacy like everyone else
              • Rust: for when compatibility with C is required or there’s nothing to support a runtime
              • Elixir/Erlang: their usual sales pitch
              • Pony: an interesting blend
              1. 6

                o Rust for writing system code. o Haskell, for writing applications, and learning more about programming itself. o Idris really sounds interesting, but I’d tackle it only after Haskell. o Racket also sounds very interesting :)

                1. 6

                  Oz, a multi-paradigm programming language, strong in constraint programming and distributed programming.

                  1. 2

                    Oz is a great language. I hope Mozart 2.0 makes progress towards a release. I still use Mozart 1.3.2 for exploring problems.

                    1. 1

                      Any resource that you recommend to get into the language?

                  2. 6

                    Forth

                    1. 2

                      Which variant? Factor perhaps? It’s the most like a modern FORTH dialect that I’ve found in recent times.

                    2. 6

                      F-Star. Basically F-Sharp with some more features and can be compiled into ocaml or fsharp. “Its type system includes polymorphism, dependent types, monadic effects, refinement types, and a weakest precondition calculus. ”

                      1. 2

                        Neat stuff. Here’s a link for anyone else who is interested: https://fstar-lang.org/tutorial/

                      2. 6

                        Haskell and ocaml. I am really interested in functional languages for the last 10 years. I have been dabbling on and off and reading papers here and there. Never have I had the chance to program a large professional app in it. I also don’t have any desire to “hobby program” anymore since settling down.

                        I mainly program C++ (python too, but I have no love for oopy python) and I dabbled in go a bit. Rust doesn’t actually interest me. I haven’t seen enough novelty to actually drive me away from c++. Maybe 15 years ago, everyone was talking about D and then half that many years ago they were all talking about go. I’m sure there was a new hotness language before my time that never came to be. As C++ evolves, it’s going to start addressing enough of the big concerns that moving to a new ecosystem might have more downsides than up.

                        1. 4

                          Haskell is definitely worth the effort. It’s not easy but I’ve learned so much about FP and programming in general from it. Plus I love Quickcheck for testing functions.

                          It also exposed me to PureScript. Which is great, although still in the early stages. High learning curve will probably scare away most JS devs though.

                          1. 2

                            Yeah. From what I’ve seen, PureScript is more for Haskell devs moving to the web than it is for JavaScript devs moving to FP.

                          2. 3

                            D has completely changed in those 15 years. What is now called D really is a new language that was briefly called D2. You should check it out again! I really am enjoying it. It feels like a completely modern and sane C++.

                          3. 6

                            Idris. My experience with ATS is that dependent types and proofs help a lot in preventing large classes of errors. Pony, because I like the actor model and it’s getting a class of dependent types that will be interesting to experiment with. I still tinker with Oz and Self because I’m drawn to dynamic and distributed systems and pine for their extensibility and hackability whenever I use a modern typed language.

                            1. 4

                              Rust: learning right now. Elixir/Erlang: my industry sector needs Erlang’s resiliency, and needs it desperately. Haskell: the relation to category theory is something I find intriguing.

                              1. 2

                                out of curiosity, which sector?

                                1. 2

                                  Smart grid.

                              2. 4

                                (Chez) Scheme

                                Datalog

                                I want to learn, but do not consider fringe:

                                Lua

                                OCaml

                                Erlang/Elixir

                                1. 3

                                  I’d enjoy learning Lua at some point too. I appreciate that it has a C-like syntax but packs a bunch of power into a fairly small footprint.

                                  1. 1

                                    What attracts you to Chez specifically?

                                    1. 1

                                      I was trying to find my notes/bookmarks on where I came across Chez originally and I couldn’t. I know it was something network related as I came across it about a year before Cisco open sourced it (or perhaps a year before they bought the research group that created it?)

                                      I read many research papers on applied networking…things…and iirc a few things that interested me greatly are something that fit Scheme well.

                                  2. 4

                                    Clojure. I’ve run through some tutorials and learned the basics but I’d love to build a real project with it. I love the way its atomic data structures work, making concurrency a no brainer, and the fact that it’s not an object oriented language yet you can model all sorts of interesting structures and patterns with it.

                                    1. 4

                                      Arabic, Russian, and Mandarin.

                                      PLs? I “know” them but I’d like to do more Rust and SML just for something different from my day to day Haskell.

                                      1. 3

                                        The classical three languages every good secret agent knows.

                                        1. 1

                                          I’ve seen more requests for Farsi than those three lately, for several years now.

                                      2. 6

                                        Unlambda with the INTERCAL FFI for accelerated functions:

                                        http://www.madore.org/~david/programs/unlambda/#intro

                                        I plan to embed it into either the Coq or Isabelle/HOL provers. There will be a verified extraction mechanism from Coq/HOL to Unlambda and Bedrock/Simpl to INTERCAL. Any safety properties that hold in former will hold in latter. I’ll do the design in the provers the normal way with proofs of correctness and termination. Then do the extraction to get the Unlambda/INTERCAL equivalent. That’s what I’ll distribute to the my customers.

                                        They’ve been interested in such techniques after a presentation I did on how lock-in helps businesses' bottom lines. They wanted to see more of that. I promised to deliver. Next, I’ll work on a hardware implementation of Unlambda to reduce risk of vulnerabilities coming from so-called abstraction gaps between Unlambda and x86. Although, I think it’s ridiculous Intel wasn’t wise enough to implement sound architecture in first place.

                                        1. 3

                                          Novel and fringe are subjective terms, but here are two I want to learn that are not so popular right now. (Haskell gets a lot of publicity, though)

                                          • LISP
                                          • Haskell
                                          1. 3

                                            I want to learn Go or Rust next. I’ve always enjoyed lower level programming and both of these seem to have interesting features that I’ve not come into contact with before. I’m certainty going to write my next side project in one of these.

                                            1. 3

                                              Rust, probably, but I don’t have a good use for it at the moment, so it’ll be a while before I get around to that. I’d also like to get around to really learning Haskell at some point, after several abortive attempts over the last few years.

                                              1. 2

                                                Ohhhh, it’s so hard to narrow down the list.

                                                • Rust: Affine types, that bare-metal feeling.

                                                • Common Lisp: “Acting patriarch of the Lisp family”

                                                • Erlang: Oddball yet practical.

                                                • Idris: I’d like to give dependent types a shot.

                                                • Elm: Functional GUI programming sounds fun. And a time-traveling debugger!

                                                • Shen: A powerful Lisp with static type checking.

                                                • ATS: This is a tough cookie. The performance of C, plus incredibly strong type guarantees, but it’s a pain and a half to write. Also the author has very poor programming style in my opinion. The wiki page has the best overview. Read the examples to see what I mean about style. What’s with the empty // comments? Who thought t@ype was a good keyword? But the language has very interesting properties regardless

                                                1. 2

                                                  I tend not to learn new languages much these days unless I’ve got a good excuse to. I miss doing so (I used to do it quite regularly) but not quite enough to put in the effort.

                                                  That being said, I’m more or less actively looking for an excuse to learn Rust and Elm.

                                                  Elm, mostly to see what they did right and learn a bit more about their good type error messages. Rust simply because I’ve got a general interest in being able to write efficient low-level code in a safer language than C.

                                                  I’ve also got a long-running unfulfilled desire to write something non-trivial in a forth, but I’m unlikely to ever get around to it.

                                                  1. 2

                                                    I’m currently not learning any new languages (still bound by http://skade.me/blog/2015/extending-my-new-years-resolution.html), but if I had to pick one, it would be Idris.

                                                    My main reason not being dependent types, but the focus on interactive and gradual development with typed holes.

                                                    I’m more into learning programming techniques and algorithms currently.

                                                    1. 2

                                                      Rust.

                                                      1. 2
                                                        • OCaml
                                                        • Erlang (and Elixir)
                                                        • Idris
                                                        • Pony
                                                        1. 2

                                                          I don’t have a language I’d like to learn, but techniques. I’d like to be better at programming with proofs. You can get pretty far doing this with GADTs, so I can learn that in Ocaml. But if I get more sophisticated, Idris is probably on my short list. I’ll probably end up using Rust at some point because I think it’ll be at the intersection of language snobs like myself and low-level hacker types coming from C.

                                                          1. 2
                                                            • FORTRAN
                                                            • Lisp
                                                            • Ruby
                                                            1. 2

                                                              I’m quite happy with Haskell and JavaScript for the type of dev I do, so I would want to get deeper skills in languages with different strengths, such as Rust. I also want to write more software for BEAM, which means going further with Erlang or picking up Elixir or LFE. Go doesn’t really interest me but a lot of recent software is being written in it, so I should go beyond the skills I have there too so I can hack on some of the dist-sys stuff coming out.

                                                              1. 2

                                                                Taking the question from a different angle, I think the two currently most interesting ideas in languages are memory safety and correctness proof. Between Pony and Rust for the memory safety angle, I prefer Pony; and although no language is designed for/ready for industrial use on the proof side, Agda/Idris are probably good jumping off points for whatever comes next.

                                                                1. 2

                                                                  From my outside standpoint Haskell’s type system seems like powerful alien space-magic, and I’d like to learn enough of the language and the tools to be able to understand properly how it works.

                                                                  1. 1

                                                                    Elm.

                                                                    1. 1
                                                                      • Erlang
                                                                      • Golang
                                                                      • Assembly
                                                                      1. 1

                                                                        Arc.