Totally! How’s your experience with Swift so far? I’ve heard the compiler can be super unreliable.
Not sure I’d call it super unreliable but sometimes you have to just restart Xcode
As long as these errors are false-negatives (i.e. builds fail that shouldn’t) I don’t mind too much.
Besides that I think I’ve never been as productive as fast in any other language. I haven’t done anything serious with a typed language before and Xcode really holds your hand in a way that’s nice when you’re new to the language.
Syntax isn’t great and full-on imperative-ness admittedly sucks but it’s really going ok so far.
The app was demoed yesterday and it worked almost perfectly.
I’ve been watching on ReasonML for a long while. Reason 3 was release a few weeks ago, which brings a series of new syntaxes very like ECMAScript. Previously I choose ClojureScript for it’s immutability and expressiveness. And Reason has most of that, plus a type system from OCaml. I can see it’s a really important language for React developers, including me. I think majority of React and ClojureScript users are paying attention as well. Will ReasonML shadow ClojureScript?
I’ve been wanting to look at so much as of late:
- Haskell (because while it’s kind of a meme in some ways, it’s still interesting)
- Rust, pretty much the same thing with Haskell
- Lua, because I think it’d be good to know
- Elixir, I looked into it awhile back and thought it might worth to look into again
- VueJS, not really a language but mainly to see if implementing a ClojureScript VueJS library would be possible/worth it (although there is Glue)
I try hard to adhere to the “Pragmatic Programmer” advice of learning a new language every year – a lofty goal! – and right now I’m trying to learn Kotlin.
Compared to Java, Kotlin is lovely. I read somewhere that it’s tried to “bake in” the recommendations from “Effective Java” (but it’s been so long since I read that book I can’t remember much). So far I’m only working through the website documentation and some tutorials. I’m liking most of Kotlin (
val, type inference, extension methods – adding new functionality to existing classes, a fair bit of support for FP style code) but when I started to get into the interfaces/classes stuff it really seemed to bog down: there’s a lot of syntax and machinery there and I didn’t get a sense, from the official documentation, about any “best practices” so it felt a bit like they’d built a lot of extra stuff on top of Java classes without necessarily improving on Java (i.e., it just has more features rather than being better/more concise overall). Well, there are “data classes” which are better/more concise than Java.
I think part of that is just how comfortable I’ve gotten with raw data and pure functions after using Clojure for 7+ years now. I’m sure I’d find any OOP language frustrating in that area these days: so much incidental complexity!
I can’t imagine any production scenario where I’d use Kotlin in preference to Clojure. Perhaps if I was doing a lot more Java interop, I might use Kotlin to wrap nastier Java APIs? Or perhaps if I needed to write a native Android app? (no chance of that)
I’ve repeatedly tried to learn Haskell over the decades but I tend to hit a frustration point and give up each time. It’s definitely worth learning. You’ll pick up new techniques that you can apply elsewhere or that will help you think about problems in a different way. A few years back I was playing around with Frege which is a dialect of Haskell on the JVM but it’s really just one person’s pet project so it’s neither widely used nor particularly battle-tested. Maybe Eta will fare better?
Rust was my “new language every year” last year (I think?) and I was very impressed with it. At first, appeasing the “borrower” can be an exercise in frustration but the analysis it performs is amazing. I haven’t written anything useful in Rust, just a few toy programs, but if I was doing systems-level programming, then it would be my first choice. I think it’s really well designed (caveat: I spent eight years on the ANSI C++ Committee so my view of language design may not match yours! ). In particular, Rust was what I had hoped Go would be when I tackled that as my “new language every year” a few years back!
If you’re looking for something interesting on the front end to learn, I’d highly recommend Elm. Opinionated, statically typed, architecture-driven, and it manages to avoid the M-word (monads) as part of its overall culture, so it is much more beginner-friendly (or at least non-FP friendly) than many other FP languages.
ATM I think I’m going to stick to Elixir and Clojure.
I think Elixir would help me learn how to better use Clojure’s stabby/thread macro (
->>), and Clojure will help me learn how to right simpler and more concise functions in Elixir.
Honestly Clojure has helped me learn more about programming than any other language. It’s simplicity in how you write functions really helps one understand how to write methods/function (hell even classes) in other languages.
I struggled with Elixir at first because I had 0 clue how functional programming worked, or how the hell to properly pipe functions into one another, or how to write programs without classes or inheiritance. And Clojure has definitely helped me improve upon that greatly. That’s why I like it so much and hope I can use it professionally. (FYI on all of this, I’ve only been seriously learning programming for roughly a year now, so that might elaborate on some of the stuff I just said.)
If I ever get around to it, I’d like to give Pony a go. I did a small bit of Erlang ages ago and the actor model had a big influence on how I design software. Would be nice to re-visit an actor language, and to see capabilities in action.
I went the other way - did all the FP stuff with Elixir, and I’m now discovering Clojure. Elixir and Clojure are very very similar in many cases.
I’ve been trying to get into OCaml lately (once again). Currently in the process of writing a script that parses my bank’s CSV files and imports them into ledger-cli. In the last week I have made some slow progress parsing the CSV and creating some basic mechanism to map transactions to ledger “accounts” so now I will continue to improve that mechanism and maybe try with CSVs of other banks.
I’m not really sure what I’m hoping to get out of OCaml but it seems like a pragmatic functional typed language that is gaining some traction lately (mostly due to ReasonML). So being able to use it on multiple platforms is nice and it feels like a good complementary language to Clojure (fast startup, static binaries). Also there is interesting stuff like Mirage etc. but I don’t really understand anything of that
After many failed attempts to learn Haskell, I’ve found the (very good) book Type-Driven Development with Idris. Idris looks like Haskell on steroids. At least the book doesn’t confuse me from the start with category theory concepts, just real code of small programs.
So far (Chapter 5), I find the language accessible and clean, just lacking some polish (still haven’t managed to import code from a module I wrote) and a good editor integration (the proposed Atom plugin is okay-ish).
I tried to learn F#, Elixir, Scala, Haskell and other functional programming languages. None of them give me the same power and the same joy as Clojure. Still, I like to “borrow” the best ideas from these languages and apply them when I can. The nice thing with Clojure is that you can naturally implement these ideas, and the community does a great job in this regard.
At some point, I would love to learn more about Racket and use it to teach programming. Some aspects of Racket are seems cleaner than Clojure, and the standard lib is also richer.
I’m a big fan of the How to Code course which uses a subset of Racket called Basic Student Language to teach a design recipe for solving problems.
I’ve done a MOOC on OCaml, apart from the final project. Maybe it reopens soon. I found it very well prepared and somewhat demanding.
It depends on what one wants, but probably better yet is to learn a new language of a different paradigm. For example: J for array programming, Forth for concatenative, Prolog for logic and probably also, natural programming with Red.
I went from Ruby -> Crystal, which has ruby-inspired syntax, and otherwise inspired by C#/Go/Python.
However it’s compiled and statically type checked, working with LLVM.
It approaches concurrency similar to Go with channels and fibers.
Otherwise I use Swift for playing around with iphone apps, and I want to learn Rust. Someday…
I myself have learned the basic of J and quite like the language as well as its Qt IDE, but can’t level up for a while. I’m looking forward to practice linear algebra with it.
Anyone tried Chris Granger’s Eve?