Bye the way, about the main problem. Scala has a nice (but not very
recommended) workaround:
object Main extends Application {
println("Hello World!")
}
By extending Application the code inside the class curly brackets is
activated automatically.
It hides all the details and boiler-plating of the main method.
I find it kind of nit and keeps the students focused at the main point
of activating the code they write.
On Dec 31 2010, 1:05 am, Nick Brown <[email protected]> wrote:
> First, a disclaimer, this may end up as a bit of a rant.
> I was listening to the listener feedback episode on my drive home from
> the holidays the other day, and the discussion on computer science
> education interested me. I'd like to share a conversation I had with
> several CS professors a few years back.
> As a Virginia Tech alum, I was asked by my employer (IBM) to represent
> the company at an ACM programming conference we were co-sponsoring, at
> which VT and a number of smaller schools in the region were
> competing. I was talking with a few professors from some of those
> smaller schools about how they went about teaching the discipline and
> the topic of what programming language should be taught was brought
> up. One professor mentioned that he would really like to teach his
> intro classes using Lisp (I think it was Stallman who said even if you
> never use Lisp, it's still useful to learn it because it will teach
> you a lot about computer science in general), but couldn't because it
> would be impossible to get students to take it then. I (in the
> position as a programmer in a corporate setting) mentioned that
> wouldn't be such a bad thing, as it would help filter out students who
> probably should major in something else. Well, the professors were
> all horrified at that notion. Enrollment was already dangerously low,
> they told me, so doing something like that would ensure they would be
> out of a job in no time. Maybe a large, well known CS program could
> take a risk like that, but these were all professors at small private
> schools. The lesson I got from that was that in order for a CS
> program to be successful, unless you are MIT, it has to be very
> accessible. It can't just target those who will eventually be the
> über-programmers we want to be our co-workers.
> At first I thought this was the wrong way to go about it as this
> targets quantity over quality of our future software engineers, but I
> suppose they do have a point. Not everyone taking intro to comp sci
> is going to be a software engineer, just as not everyone taking intro
> to biology is going to be a biologist. In fact, it is becoming more
> and more important for members of other disciplines (especially,
> though not limited to, engineering and the sciences) to learn at least
> some CS. They won't have to write huge, multi-layer applications, but
> they may well need to write a short script to accomplish something on
> a computer.
> So as Bio 101 doesn't usually start out with teaching the complicated
> organic chemistry that is the heart of all biology, CS 101 also needs
> to start out at a much higher level of abstraction. And what is the
> most natural abstraction of CS? Well, depending on who you talk to,
> either objects or functions. I would personally side with functions,
> but much of that is tainted by how many problems arise with the common
> modern implementations of OOP. Functions are familiar, not just to
> mathematicians, but to anyone who as taken an algebra class. And the
> use of functional programming is not just useful to those who are
> working on massively distributed programming, but also to a scientist
> who needs to write a script to perform some computation of their data,
> or an engineer who needs to run calculations to test their design. In
> fact, anyone who has used grep should have no problem defending the
> utility of functional programming.
> Of course those students who (most likely well after taking CS 101)
> decide to specialize in it and become software engineers will need to
> learn a lot more, such as the internals of how all this "magic" stuff
> they used in their beginning classes really work. But I don't think
> that would be any more difficult than learning cellular biology or
> organic chem after having a high level overview of biology.
> So I suppose this is just a long-winded message about how whoever it
> was (I think Tor) who was arguing that you need to start at the bottom
> and learn up was wrong
>
> Oh, and regarding the original listener feedback about using JUnit to
> launch programs for beginning students, I guess I have mixed feelings
> about it. One one hand, I worry that if students first see JUnit as
> just a way to launch "Hello World", they may have difficulty switching
> over to using it for real unit tests (I suppose I don't have an
> argument for that, its just more of a gut feeling more than anything
> else). On the other hand, I think using JUnit as it is intended would
> be very useful. If they write a program to compute the nth Fibonacci
> number, instead of exercising it in int main(...), write a JUnit for
> it.
--
You received this message because you are subscribed to the Google Groups "The
Java Posse" group.
To post to this group, send email to [email protected].
To unsubscribe from this group, send email to
[email protected].
For more options, visit this group at
http://groups.google.com/group/javaposse?hl=en.
