Online REPs and REPLs

Today there’s 61 different languages on that list. That many, there’s gotta be at least one that strikes your fancy.

Best batch execution site: ideone.com with 50 unique languages.

Best interactive REPL site: repl.it with 16 unique languages.

• Vim PocketMod draft 1 (new)
• Python PocketMod draft 1 (new)
• Scheme PocketMod draft 3 (updated)

I don’t really need the qr for Python, but I thought it might be good to have ready should a friend a coworker wish to start learning Python.

As for Vim, the reference is certainly terrible – I’ve barely used it at all. The qr is just a list of commands that looked useful. I’ll edit the qr as I go, perhaps using the last pages for notes.

The Go Programming Language Blog: Defer, Panic, and Recover.

Don’t get me wrong, I think the’ve got something here.  Defer gives you the equivalent of C#’s finally/using; or a nice subset of C++’s destructors; or Lisp’s unwind-protect.  Panic = throw / raise.  Recover = catch.

The blog post gives the impression that you can’t programmatically access the value passed to panic — “recover returns nil” — but before judging that behavior I should try to confirm it in the Go documentation.

All in all, I’m giving this design a thumbs up. No element of it is new, but they seem to have brought exception handling in without compromising their mantra of practical and simple.

So, I wrote my list of some unique programming texts. But on the more practical side, there’s this:

Best and Free Programming Ebooks.

Free full texts, covering: Bash, C, C++, C#, Common Lisp, Haskell Java, JavaScript, Lua, Objective-C, Perl, PHP, PowerShell, Prolog, Python, Ruby, SQL, x86 assembly, algorithms, version control, and a couple other topics.  I’ll still be putting together my own preferred lists, but half of what I’ve got is already on this list.

Every programming language is designed to restrict trouble programmers can get into. The key is that they all have different ideas of trouble.

via Hacker News

It’s a good question. I don’t know if there’s one answer, but I’ve found mine.

Learning Lisp, Haskell, Python, and others has given me a greater appreciation for computer science, for the theory and universe of knowledge that lies underneath the surface of programming. Now when I code, I don’t just solve the problem at hand. I see different ways to solve it. I see other remote problems its related to. I appreciate the aesthetic of it all.

It’s not for everyone, but I find the mathematics underlying it all very beautiful.

And as for my day job in old-school-C++? Well, I hack together a prototype in Python in a couple hours, then spend a week translating it to C++ (adding verbosity, manual error handling, unfolding metaprogramming, etc). My boss doesn’t necessarily understand the whole languages thing, but he’s happy when I get a 2 wk job done in one. I’m happy too; having gotten through the icky bits of the problem in Python, I spend less time working on the boring bits in C++, and can move on to the next project sooner.

There is one last question, that I’m not sure I really have a good answer to. “Won’t you be tempted to use features that don’t exist in a normal language?” I’m hoping this will evaporate. Templates have existed in C++ since ’88 (pdf), various people have hacked lambdas in, and VC10 has added them for real. Short those facilities, it’s not like I have forgotten how to write imperative code. It’s still an option – I just now realize the development expenses of that option.

~

I’m curious, other answers do you choose for these question?

For better or worse, it’s accepted in our industry to be fluent in only a single programming language or technology. It’s lame, but there are plenty of excuses for this. “Turing equivalence” right? Finding quality tools is hard. And worse yet, to learn a new language you have to spend days and weeks reading some lame introductory text, right? Wrong!

There are tons of good intro guides out there that can get you up and running quickly, if only you know where to look. I’ve accumulated a bunch of these, and would like to spread the good wealth:

Learn You a Haskell for Great Good — Terribly fun illustrations, and fast moving. See the little chick to the right for example. Sticks mostly to the REPL and teaches by example. Best of all, elides all those lectures on “how Monads changed my life” stuff. Just the facts.

Teach Yourself Scheme in Fixnum Days — A little more down to earth, faster paced. Again, REPL focused; every section includes short illustrative snippets, although many of them refering to fictitious functions.

There’s also a Scheme for C programmers that runs even quicker. It includes special considerations for C programmers, but knowledge of C is not a prerequisite.

Oh, and lastly, the makers of Chez Scheme also offer the full text of The Scheme Programming Language (vendor neutral) on their site.

Why’s (Poignant) Guide to Ruby — This one is just… unique. Why’s guide is a bit rich on illustrative dialog for my tastes, but I can say I’ve never seen anything else like it. If you just want to learn the language, skip ahead to chapter 3, but come back to chapter 1&2 later when you have time for a unique experience.

Practical Common Lisp — Full text online. Excellent format, interspersing chapters on the language with case study chapters that examine working programs, giving context for the reader. If this is your 3rd or 4th language, you may find the pace a little slow (a common challenge in programming language instruction). However, this is not to a fault, and 2nd language readers will definitely appreciate the effort made to elaborate the potentially confusing corners of the language.

Casting SPELs in LISP — Like Why’s (poignant) guide, this one is also out there. Learns you Lisp through programming a simple text adventure game.

Finally, you’ll want a reference manual for Common Lisp. This isn’t just any reference manual though, this one is unique. The Common Lisp Hyperspec is just about the most gosh-darned-hyperlinked manual I’ve ever seen. Particularly helpful is the permuted symbol index. An excerpt:

                   values-list
                          list*
                          list-all-packages
           pprint-exit-if-list-exhausted

Yeah, that’s cool.

So there are some resources to get you started. But what, you say, you don’t still don’t have time to install anything? Then don’t – there are a bunch of REPLs you can play with before committing any time to setting up tools:

• SISC Scheme — requires Java. A very complete r5rs Scheme implementation.
• WeScheme — JavaScript. Scheme ide, with repl.
• Try Ruby — JavaScript + server-side execution.
• Try Python — Silverlight. Supports all the core python 2.x language constructs.
• You can’t swing a cat without hitting a JavaScript repl or two, or an interactive lesson.
• Try Haskell — (upd, 07/18) Looks like it’s going through updates. Since I first saw this a few months ago, it looks like they’ve added lessons and tweaked it to run smoother. It seems every (worthwhile) language is gonna have one of these sooner or later.

These are my favorite fun and easy starting points, but there’s more out there. Try a couple out, find one that seems interesting to you. When you’ve found a new language that looks promising, stick with it for a while. It will give you more perspective, and additional tool to use in your programming arsenal.

Update (7/18/2010):

First, Mozilla has a re-introduction to JavaScript, especially for its opening sentences:

Why a re-introduction? Because JavaScript has a reasonable claim to being the world’s most misunderstood programming language. While often derided as a toy, beneath its deceptive simplicity lie some powerful language features.

Also, added Haskell to the list of online REPLs available.

Anyway, he also posted a his personal history of programming language study, and it got me thinking about my own personal programming languages history.

It all started with Logo…

1992: Logo/LogoWriter.  After a basic intro class (4th grade) of moving a turtle around, I would occasionally try out various programming exercise cards, where I learned about variables, loops, and functions.  Unfortunately, the advanced exercises required a version of the software the school didn’t have.

1995: VB for dummies, and a cloned copy of a Visual Basic 3 floppy diskette.  Remember floppy disks?  Yeah, me neither.  First real introduction to arrays, graphics and UI controls.  Wanted to make a clock app, so I learned trig early from my dad with sketches of triangles on a post-it note.  Some time later got to enjoy VB 6, GDI, and BitBlt for bitmapped graphics.  I remember hating BitBlt, it seemed to have a really annoying set of params; I wished it was written in a real programming language, like VB for instance.

1999: C, Java.  I don’t remember the exact order, but I made the jump from VB to C (with thanks to K&R), and mode 13h graphics.  That was the simple mode right?  First introduction to algorithms, wrote a 2d ‘Doom’-style raytracer after reading about it in one of those so-so game programming in 21 days books.  I say ‘so-so’ because to even have a hope of learning anything about a programming topic in only 21-days, it either has to have very narrow focus or, in this case, absolutely no depth. Also spent a little time in C++, but found it very complicated and confusing; I only got as far as I did because the AP test for Computer Science was in C++ the year I was taking it. Finally finished up this period hacking around in Java, made a bunch of browser Applets, as was the style at the time.

2000: VHDL, Perl, Java – Skipped intro CS courses.  Learning VHDL for digital logic course, and Java for algorithms courses.  Picked up a book on Perl for the fun of it, used it to parse and process Counter-Strike logs and generate webpages of stats.

2001: back to Basics – Spent the summer working at a computer camp for kids, instructing in robotics kits programmed in Parallax Basic.  Later that year, switched back to Visual Basic; the .Net version, which now rivaled Java in functionality.  This ended up being my language of choice for some time, marrying true OO semantics like Java with the wonderful Basic syntax.

2003: honed my programming and design skills finishing my CS degree.  Touched Prolog and Lisp briefly in one of those programming languages survey courses, but didn’t have a particularly good instructor.  Senior year I interned at Microsoft where I got to dig back into C for a while.

2004: C# – Started fulltime at Microsoft, where I was to be working in C#, so I learned C#.  “Oh, this is basically VB.Net with a Java-like syntax.”  Heh, yeah, sounds funny now maybe, but only because (statistically) you don’t know anyone who uses VB.Net.  I still say, for CLR 1.0 languages, it had the better syntax.  Learned C# 2.0 generics while it was fresh off the line, and learned a bunch of stuff about the difference between the CLR’s programming model and that of C.

2006: C++ – Was told I was to be working in C++, so I learned C++.  C++ Pocket Reference for syntax on the go, Stroustrup’s TC++PL 2nd ed for semantics (make sure you get special edition though), Meyers’ Effective C++ 3rd ed for learning a huge selection of gotchas and design issues, and Alexandrescu’s Modern C++ Design for teaching me an exciting selection of generic and generative programming techniques using templates.

2008: Python, JavaScript – Sparked by a conversation with a co-worker, started learning Python.  Was really surprised about how much easier many programming problems became.  I realized I didn’t really have a good idea what was out there.  Tinkered with JavaScript.  Started looking into programming language origins.

2009: Lisp, Scheme, Haskell, ML – Inevitably a pass through Lisp.  It seems a lot of programmers go through this phase at one point, and it makes sense; McCarthy created Lisp precisely to describe computing, and that clarity is refreshing.  Scheme, and the book SICP, introduced me to different computing models including first class continuations, streams (aka lazy lists), and the amb operator.  Haskell led to more exploration of lazy evaluation, better understanding and insights in generics, and its supremely practical typeclasses.

Currently tinkering with Standard ML, as a simplified alternative to Haskell; hacking together small tasks in Python; and whatever my new day job brings in.

~~~

Oh, and somewhere in school I briefly tried “eMbedded Visual Basic”.  That’s where I first learned it’s possible to start with a good programming language and cut it down to something similar but that *really* sucks.  For those who never heard of it, they removed a variety of language features including user defined types, the compiler error messages were inscrutable, and it was slow.

If you were a developer on that project, I’m really sorry, but better languages have been implemented over a weekend.  I don’t blame you.  Maybe you didn’t have a whole weekend.  Or were held hostage.  That would explain it I think.

Comparison of Google’s new language “Go” to mysterious “Brand X”, and the shocking reveal of Brand X’s true identity.

As found through http://www.foldl.org/, a digest blog on various programming language topics.

• LangPop.com – statistics on greping search queries on various web properties — usage in open source projects, books published on Amazon.com, etc.
• TIOBE index – similar listing, of search engine results exclusively.  Longer tail listing, and shows trending.
• Happiest users – this one is just a static blog post, but takes the additional dimension of not just frequency of posts, but the satisfaction level being expressed.  The data set is absymally small — I hope eventually another group will follow up with a more comprehensive analysis of more languages, and more satisfaction dimensions.

Usage data might be more interesting or ‘scientific’ (number of statements executing, new applications/modules shipped, etc).  However, ‘mindshare’ is itself an interesting dimension, as the technical merits of programming languages are typical less considered than social pressures and perception.