It depends on the purpose of learning said language. Are you learning to broaden your horizons to explore new paradigms and such? Or are you learning a language because you're part (or planning to be part) of X group who happens to be developing in Y and you just need to be productive/marketable?
I see. There definitely seems to be a connection between coming to Ruby and coming to Python, so this is a fair argument for their association.
I think that them being listed together does however muddle the value of the poll because you cannot tell how many Python and how many Ruby votes there are.
But again, I understand the logic behind their their association as I was someone who was first drawn to Ruby and then later to Python because of its proximity - I have since stuck with Python...
Clojure, people! If you haven't yet checked out Rich Hickey's new functional lisp for concurrent programming on the JVM, then you're missing out on something really, really, mind-blowingly cool! I'm a Lispnik at heart, and I do most of my personal development in Common Lisp on SBCL, but I have to program a lot of Java code for my day job. Clojure has definitely caught my eye and is #1 on my list of next languages to learn.
+1 for Clojure. S-expression based language with macros, runs efficiently on the JVM with type hints, all the Java libraries available. Callable from Java. Cleans up side effects nicely, while still allowing them when needed. Strong support for easy threading. Escape Java's high-ceremony hell without having to quit the job. Highly recommended.
Haskell. I tried three times so far, and stalled each time once I reached monad transformers. Scratch that: I consistently stalled at understanding monads. I understand the Maybe monad, but I couldn't wrap my head around the implementation of the State monad. Then I looked at monad transformers, and they made my eyes cross. (If Haskell's syntax was just a tiny bit less jarring to my Lisp-addled eyes, maybe I'd try more often than once a year...)
I think I had the most fun and frustration at the same time programming with Lua.
I love the syntax and minimalism, yet I would have loved some more support for OO.
Also, there is a lack of tools and libraries, which definitely hamper productivity.
unfortunately. Mixing Objective-C and C and your code looks a little bit frankestein-ly, and it is impossible to avoid. The messaging pass part of Object-C is no near as elegant as erlang.
The actor model is a very powerful conecpt. It will become more and more revelant as multiple cores, concurrency, and scalability become more and more important.
I think that Facebook successfully used Erlang for their chat system.
I have no plans to learn new languages for the time being. I've been exposed to most of the big concepts, so I feel a creeping sense of diminishing returns as I have to invest time in increasingly different syntaxes to learn anything really different.
That is time I could spend building out more productive libraries and architecture for my real goals.
I know dynamic languages are all the rage these days, and that Haskell is on the rise, but Scala is really sexy to me right now.
All of my large-ish projects have been in either Java or Python (I've done smaller things in Ruby, Haskell, CL, Erlang, C, C++ - I enjoy playing around with different languages). I love the conciseness of Python, but I always find myself either spending way too much time writing tests or hunting down bugs after simple refactorings. Java, on the other hand, is, as a language, misery incarnate, but there's something intensely satisfying about being able to just delete large chunks of code and have the compiler tell me exactly where the functionality those chunks provided needs to be replaced.
I had looked at Scala in the past, but always from the POV of learning functional programming. For the last week, though, I've just been treating it as a Java replacement, and I'm in love. It has the same feeling of liberation as the first time I really dug into Python (and is actually more expressive than Python in several cases I've come across), but I can use my slash-and-burn refactoring style without any hiccups.
It inherits the huge number of Java libraries out there, and it has a fantastic web framework (liftweb), an Erlang-style concurrency library that feels like a built-in part of the language, pattern-matching, etc. etc. People evaluating languages for new projects should really take a serious look into this one.
Ouch, zero points for Arc. Even MPI has one (prospective) devotee!
I voted Haskell, because their libraries are finally getting the language to a point where it is competitive. There's even a story about this on the front page today!
What is the obsession with learning loads of programming languages? If you pick well, you only need a couple and you can spend your time and mental energy building new things.
Note: This is not to say I do not appreciate the value of learning different languages. It just seems to be an obsession to tally up as many different languages as possible instead of building new stuff with the languages you know.
Why just read the book? Download Squeak - a bit far from the mainstream expectations, but it's free in the best sense. Or you can get VisualWorks Non-Commercial. (There's a very under-appreciated ASP-like web app framework in VisualWorks!)
I actually found Squeak to be a bit non-intuitive and lurid, but I have played with VisualWorks and Dolphin, to try & get a feel for Smalltalk, but I never really got my head round how things worked.
Having a book handy means I have something to turn to the next time I give it a go.
True, Squeak has bad UI color choices. Also, it's a "Burn The Diskpacks" environment. They aren't going to kowtow to any conventions -- they just want to innovate. If you can go with the spirit of that, there's some brilliant stuff in there!
Smalltalk is radically different in a fundamental way when it comes to your relationship to source code and the dev environment. All your source code changes are in something like a transaction log. When you're programming, you're just manipulating the meta-level more or less directly. When you do get it, there's a "whoa!" experience. Better yet, persevere and "get it" then go back to something like iPython. You'll get a real perspective shift!
Yeah, I actually think I really like Smalltalk-the-Language - it's a really tight set of primitives which interact in a powerful way - it reminds me of Scheme or Forth.
But being born and raised on the commandline, it's Smalltalk-the-Environment which causes me trouble. I often find myself wishing that I could just play with it like you would with, say, Ruby's irb. I find the conventions (having to highlight code and hit Ctrl-I to get it to run, and so on) quite off-putting. If I can get over that, I'm sure it'll be worth it, but it's a bit of a struggle.
The Smalltalk Workspace with the debugger, the inspectors and the whole image at your beck and call is irb/iPhython an order of magnitude more powerful!
If you want something like a command line, you can write it fairly easily. You could probably subclass it from the Workspace.
But why would you want to? Most Smalltalks have lots of context-aware goodness! If you are browsing on the class side, highlighting code and executing does it in the context of the class. If you are looking at an instance in the inspector, it does it in the context of that object instance! If you are in the debugger, writing and executing code does it in the context of that stack frame!
Those last two bits of context-awareness have been the environment where I have done some of my best debugging and coding in the past decade!
Command-line or highlight/right-click is only the medium. The message is the thing! Think of it as like adjusting to the controls of a new video game.
I'd say yes, because Scheme is a Lisp and I don't know any specific language that's called just Lisp except perhaps the original one by McCarthy. As far as I know Common Lisp and Scheme are the two Lisp languages in usage today.
All of the above to various degrees? I'd want to at least get a vague feel for what each of them is good for, how it interacts with the system, and the general thought processes that accompany it for each one of them, so that I could say that "I could write something in it with some research".
It's more about expanding my mind than about picking up a tool, with a number of exceptions for my workhorse languages (which are constantly changing)
My "to-learn" list has three items on it, and I'm torn about which to pursue first...
* Lisp (Interesting, recently bought pg's ACL)
* C (Would be useful at work, recently bought K&R)
* Obj-C (Have both an iPhone and a MBPro that would be neat to develop for)
C precedes C++ (and uses the same basic syntax) and C++ changes the paradigm to object oriented (but like C is statically typed and compiled). Ruby and Python are part of the same paradigm of dynamic, object oriented languages.
At some point I intend to learn Arc, Python and Erlang, but I have no immediate plans to do so. Knowing them isn't going to do me much good until I can finish a reasonable-sized project.
PHP
I'm an embedded systems programmer not a web guy, although I have done some simple CGI stuff.
Under my belt: C, C++, C#, a number of assemblers, Python, Lisp, Prolog, Java, BASIC
I started learning OCaml to beef up for a class I'm taking in the fall, so I guess that's next. But, I'm also a student of the Scheme way of life and am always learning it.
Robert Virding's Lisp Flavored Erlang, which, among other things, does away with records, neatens up the syntax, and enabled Lisp style macros, but is still built on Erlang, and still contains it's high quality pattern matching.
Virding is one of the original contributors of Erlang.
I have finally released LFE, Lisp Flavoured Erlang, which is a lisp syntax front-end to the Erlang compiler. Code produced with it is compatible with "normal" Erlang code. The is an LFE-mode for Emacs and the lfe-mode.el file is include in the distribution. Most things seem to work but some things have not been done yet:
- The interpreter does handle recursive letrecs, binaries, receive or try.
- There is no lisp shell.
- Documentation!
Yet. The system will be updated as new features are added. This is the 1st release so there is much left to do.
I have include the existing documentation lfe_guide.txt in this mail. There are a number of LFE test files and a version of the LFE interpreter written in LFE as examples of code. There are also a number of issues which need to be decided for the next version and I have included a file lfe_issues.txt which describe them in this mail. Both files are in the distribution.
Note that while this this lisp has been inspired by Scheme (one of the issues) it is a NOT Scheme, it is Erlang with a lisp syntax and many nice lisp features. Not for that matter is it Common Lisp. In fact features of the Erlang engine mean that it is actually impossible to implement full Scheme of CL. No, they shouldn't be changed or added.
It was quite writing Erlang code in lisp and I could easily consider using a lisp syntax for Erlang. I suppose it depends where your preferences lye. It was also easy to get into the traditional lisp habit of using long names for everything which I personally think is not a Good Thing. Perhaps we should do AFE, Arc Flavoured Erlang, instead? Although I think they have gone too far and missed what makes programs easy to read.
Macros are very nice, and it is easy to generate LFE code, which is one of the benefits of lisp syntax.
LFE also shows that it would probably be possible to write other front-ends inspired by other languages, though why anyone should want to I don't know. Perhaps back to a real Prolog syntax again.
We're doing real time control for vehicles, which has to handle, among other things, valve timing, fuel flow, the transmission, suspension adjustments, braking. We can't afford to have the system break, and Erlang is built for mission critical systems, giving us quality primitives for handling concurrency and software breakage.
But in Erlang records and math are kinda broken, and we needed both. Hence, LFE.
Creates separate choices