CS is responsible for educating students in the basics of computer science whether or not said students are intending to progress along the main CS sequence, or have other plans, such as in biology or psychology, or some other liberal art (mathematics?).
All these walks of life stand to gain through exposure to CS, is the departmental party line. But if we manage to recruit a few good geeks in the process, for longer haul commitments, e.g. to serve as degreed and/or certified faculty in university or K-12 contexts, so much the better.
Now we all know that CS often starts off with some computer language or other, sometimes pseudo-code, i.e. a language that doesn't actually execute. The latter genre (pseudo-code) tends to be unsatisfying however, has that "rubber bone" flavor. Eager beaver students, even at the CS0 level, didn't enroll merely to *pretend* to program, they want something meaty to sink their teeth into, want to sample the real deal.
So a real, executable language tends to get phased in, be that FORTRAN, Algol, Pascal, C, C++, Lisp, Scheme, Java, C# or Python (or... -- the list shows no signs of being finite, although it may be slowing/converging on some fronts, i.e. in these so-called "paradigms" (functional versus object-oriented) or "levels" (lower-level systemic versus the higher level dynamic -- the latter often being written in the former)).
Usually we go for the more exotic languages in courses later in the sequence e.g. 'Concrete Mathematics with J' (CS403) or maybe 'Ocaml on Steroids' (CS523). However, there's a lot to be said for *sampling* some exotic languages in CS0, just to give a heads up as to how vastly different these languages may be.
In my own case, I was fortunate enough to start out with APL @ Princeton (that HP-65 in the Philippines having whet my appetite), running on a dumb terminal in the basement of Princeton Inn (freshman dorm) and on another at Firestone Library. By the time I got to FORTRAN on punched cards at the E-Quad, I'd already seen the future. At an interactive command line was the place to be. Small wonder I put in several years in Xbase (one of the best interpreted environments for getting real work done in the real world -- Visual FoxPro especially ).
So, starting with some actual language or other (not pseudo-code), we generally write 'Hello World' as a first introductory program -- which used to be something of a challenge, in Assembler especially (the whole tradition got started with glorified assember, i.e. in C). Since then, writing 'Hello World' has become exceedingly trivial, like in Python it's "print 'Hello World'"; hardly much fun in that. How shall we transform something that specialized and trivial, into something more engaging, while maintaining continuity in terms of lore and tradition?
One possible solution (the one my colleagues and I favor these days) is to turn 'Hello World' into this exercise in dizzying ourselves with the sheer complexity of it all. We throw the 'real world' at 'em, high bandwidth, to impress upon all what we're up against, in terms of trying to wrap our models, views, controllers around a twisting, warping reality that never really holds still for the cameras (writing cogent simulations sometimes takes every ounce of creativity a test-driven XP team might muster).
And we're doing pretty well with our modeling, at least in some venues. Like, check out Google Earth. Zoom in on your school (if feasible). Talk about GIS/GPS and the need to share global data in formats more than just a few humans know how to deal with. Yes, we're talking Unicode and XML, right off the bat, in the first few minutes. In the very first lecture we'll mention about moving from HTML to XHTML, what that's all about (the reasoning is partly selfish: these students are likely to create web sites, and we'll have an easier time parsing 'em if they adhere to XML standards).
Let's talk about the Internet, hosts with IP numbers, DNS, registrars, RFCs, routers, subnets, TCP/IP and packet switching ('Warriors of the Net' is good -- HPD liked it, when I did that Saturday Academy training with Jerritt). Give a sense of the whole.
So that's the new 'Hello World' (using Google Earth or some similar service, we start with a model of the literal planet, and say 'Hello', get ourselves oriented). This approach is the very antithesis of something so micro and specialized as just writing 'Hello World' in some dittohead language and calling it a day. Now it's The Whole Enchilada, the Big Kahuna, that we go for. We shoot for the moon. CS0 is nothing if not aimed at would-be generalists. And liberal arts students appreciate this approach. CS isn't trying to dumb it all down for their benefit. We're acknowledging the difficulty, not trivializing it. And that's a good segue into another CS teaching: programming is pretty difficult a lot of time, but we like to think not impossibly so. We're into "tough fun" over here. But no one who really knows will tell you it's all cushy. Mistakes may be serious.
I just thought I'd pass this along to my colleagues down the hall, the math teachers with their TIs and graphs of polynomial equations. Your potential math majors will be coming over to us per usual, given we teach a lot of the tools they'll be needing (e.g. Mathematica, maybe along with some new kind of science), maybe a Python in C# on Mono/.NET, maybe a Lisp (I like the way MIT taught it to HP ) or a SmallTalk (Squeak?), plus whatever math goes with this territory (quite a lot, including some Bucky stuff, although that's really more philo ).
These students will be returning to your fold, dizzy, giddy, blown away by what CS is doing, even at the zero/entry level.