Slashdot Mirror

Have a look at the book How to Design Programs, which was written with a pedagogical focus and is a great way to teach the fundamentals of programming and problem solving. It uses an excellent free programming environment which should make it easy for students to get started.

I must say that by far the biggest problem is the lack of standards, reasonable documentation, and software maintenance in combination with ad-hoc languages and implementations. If researchers stopped reinventing the wheel all the time, AI research would be in a much better state than it is now.

I teach introductory Java programming to students who have had about one semester of basic programming already (loops, basic arrays, stdout). In the previous course they use Textpad and compile "by hand". I start with a simple IDE that was designed specifically for teaching, it is DrJava, see http://www.drjava.org/ . It's open source and was developed at Rice University. There is also its cousin DrScheme, see http://www.drscheme.org/ , for teaching scheme. The main features of DrJava are: simple editor, "compile all" button, a simple debugger, and (very useful for teaching) a java "command line". The command line is cool because it allows interactive work. I don't have to recompile every little thing just to show them how simple things work. Later on in the course we switch to Eclipse.

Speaking as one who currently teaches computer science in high school classrooms, I can offer my own anecdotal evidence to the contrary: students do still program computers. That said, I agree with much of what others have said here. These days there are usually several different courses that tend to be lumped together as 'computing', although some of them have nothing to do with one another save that they involve a computer:
- keyboarding, aka typing
- computer literacy, aka word processing, productivity applications, etc.
- introductory programming,
- intermediate programming,
- AP computer science

The first two in the list have little if any programming component. I say little, though the second course may cover a number of use of spreadsheets and through that the use of formulae, conditional expressions, etc. [ I should note that there is a online journal dedicated to documenting the various ways in which spreadsheets can be used to teach various concepts - see http://www.sie.bond.edu.au/ for more details. ]

The introductory and intermediate courses may have widely differing names depending upon when they were introduced into the school system; a local public system calls the second course "Data Structures", most likely because it was introduced during the Pascal heyday. Even though these two course sound like a close-knit progression of coursework, they actually may be quite different. Two of the local systems teach a different language (Java) in the second course than is used in the first course (VB.Net). The reasons for this choice are not entirely clear. Pascal was introduced into high school classrooms largely via the Apple II series; even the emergence of the IBM PC and its clone still gave access to Turbo Pascal. Not to imply that VB.Net is a step backwards, but the return in the high school classroom to QBasic, VB 6, and then VB.Net seems driven more by the availability of textbooks than other factors. I welcome a more informed explanation.

Originally Pascal was chosen as the AP Computer Science language of choice. { Here A.P. means Advanced Placement, high school courses with an associated standardized exam; many colleges and universities recognize exam scores and award credit towards degree programs. } For whatever reason, though, that choice was relatively short lived - perhaps driven by a 'pragmatic' crowd that wanted a 'real programming language' to be taught in the high school? At any rate, Java is now the language used in the the AP Computer Science exam. There is talk of changing the exams again to use a more language agnostic format.

A great many other tools and languages are taught in addition to or besides these, obviously. A smattering of ones that I know of or have used:

- The TeachScheme project http://www.teach-scheme.org/ exists to provide resources for those who wish to use Scheme in introductory high school and college courses. { And DrScheme rocks.... } I personally know one high school instructor who went through their workshop and adopted their approach and who had good things to say about it. { In fairness, though, he is currently teaching Java due to his participation in an NSF-funded grant. } For those looking for a natural follow-on to Java or more 'traditional' OOP programming, might I suggest having a look at Proulx and Gray's work in
How To Design Classes and ProfessorJ
http://www.ccs.neu.edu/home/vkp/HtDCH/ http://www.drscheme.org/.

- Alice http://www.alice.org/ is getting a lot of well deserved buzz, especially in light of the recent announcement that EA will be funding the development of their next major version (3.0), which will include features from the popular Sims game series. Caitlin Kelleher's work in extending Alice into a storytelling environment has also produced good results, esp

Without much effort on your part you could grab DrScheme (its packaged as part of some Linux distros, otherwise go to here. That's your graphical coding environment. It runs on Windows, Mac and Linux.

For material to accompany it, "How to Design Programs" is a good book available online in its entirety here.

If you're more hardcore, then you might prefer "The Structure and Interpretation of Computer Programs", another book online here. SICP also has about 20 hour-long downloadable lecture videos, but be prepared for 70/80s fashions in the audience...

I think HTDP is a great way to learn to program in general, and DrScheme is a good environment in which to learn.

Downsides: scheme isn't widely used outside of education. It is also not obviously closely related to mainstream languages (C++/Java/C#/Perl/Python/Ruby) in appearance.

Upsides: scheme is fairly easy to learn, so you can focus on picking up concepts and discovering if you enjoy programming. Scheme is a also a very close relative to lisp, which is a (slightly :-) more pragmatic language to learn to deploy applications in.

Give DrScheme a look. Nice graphical IDE, libraries, dead simple syntax. Free. Different language levels to cater to the learning process. And pleanty of introductory texts.

Maybe you want Dr Scheme?

"My father sent me to work programming in basic from textbooks when I was 4. I found this a wonderful thing, as I could make the computer do what I wanted. I learned syntax and other important elements of programming, and now as I write this, the computer has stuck with me ever since. This is why I'm a computer science major."

DrScheme. Yes, young people can pick it up easily.

Oh for those who like LaTex? Try the Scheme version

The authors of HTDP have a Scheme distribution that includes a GUI IDE Called Dr Scheme:

http://www.drscheme.org/

It runs under Mac OS X, Linux and Windows. It has an on-line help system. It is also used in conjunction with the book How to Design Programs (available from MIT on-line: http://www.htdp.org/) , and Structure and Interpretation of Computer Programs http://mitpress.mit.edu/sicp/.

Basic Scheme is very easy to learn. It even makes for easy tranlation from HS Algebra/Geometry/Trig formulas into code. It will quickly teach concepts without having to learn specifics about operating systems or applications.

If you're looking for a job as a programmer (coder), your best bet is to stick with what's popular - Java or one of the .NET languages. If you're looking to learn practice, network with friends/family and find a professional developer that knows some kind of SDLC inside and out and ask them to be a mentor. There is more to software development than writing code (analysis [talking to users], requirements development [talking with users], functional specifications, design, source configuration management [version control, issue tracking, unit, component, system and regression testing, etc.], software metrics [profiling, logging, debugging], QA analysis).

It depends on what your goals are. The simpler the environment is to get started with, the faster your kid will be able to determine if they're even interested. If they eventualy outgrow the environment and there is enough passion, then transitioning to the new environment will be a possibility (not to mention invalueable experience).

- mortis

First of all, you could start with Lego Mindstorms (which is a little humorous as it's so close to LOGO [by name, at least]). This seems like a good hands-on way for kinds to learn some programming with tangible effect.

There is also a teaching version of Scheme (somewhat like lisp). See the FAQ for the "Teach Scheme" project here.

There is also a list of softwrae to use in teaching programming here, but I've not looked it over and am not sure how useful it is.

What SuperKenall said is correct. However, some languages have more differences than others.

All the .NET languages MS ships are all about the same; the only difference is syntax. .NET requires all compatible languages to adhere to the same capabilities so they can be 100% compatible with each other. Unfortunately, it also requires all the languages it supports to be dumbed down to the lowest common denominator. There is a very long list of things that had to be removed from ISO C++ to create Managed C++, because including them would make it incompatible with VB and C# (and .NET), such as multiple inheritance, templates (non-type params too), pointers, member pointers, etc.

Functionally, VB.NET, C#, J#, and Managed C++ all have exactly the same capibilities. They are all sequential, procedural, imperative, object-oriented languages that support single inheritance, interfaces, events, exceptions, type generics(they will in v2.0), reflection and share a common runtime library and work in a sandboxed VM. The ONLY differences between them are in syntax. So, it doesn't really matter which of these languages are used unless someone in the group doesn't know the syntax for a language in a source file they need to work on. The interfaces between them will be equivalent regardless of language.

Compare this to a functional language such as Common LISP or Scheme, or a declaritive rule-baed language like Prolog or Mercury. Mercury can compile to .NET (it normally compiles to C), but you can forget about a runtime system like Prolog being compatible with .NET. .NET doesn't understand functions that don't have an implementation until you've decided the direction the argumets are flowing (a very big part of declaritive languages), .NET doesn't understand state tracking and backtracking or multiple modes based on detirminism, .NET doesn't understand multiple possible results for a single variable (a list is the closest you can get; it isn't the same because you have to do all the handling yourself which defeats the purpose).
Haskell has to jump through hoops to get the needed multiple inheritance to work.
OTOH, there are some interesting projects like F#, an OCaml like functional language. It has some serious issues to be compatible with .NET, though.

It's like Microsoft offers you several languages, but they are all the same. The illusion of choices without really having any. They should just be like Java and admit that there might as well be one language-- seriously, Java could have all the multi-language support of .NET if there were bytecode compilers for other languages. .NET and Java are so alike in function anyways.

As for what languages should be used when, where and by whom: I don't know. I'm still trying to figure that out. I know that some are good and bad for certain things, but I also know that personal preference is important, too.

</rant>

You laugh, but Dr. Scheme sounds like a close fit to Visual Lisp.

There are. Several big commercial Common Lisp packages (eg.), and for Scheme (a Lisp variant), a nice little free download from Rice University. I've been playing with the latter since reading Graham's latest, and it's sweet...auto-indenting, highlighting to show matching parens, source-level step-by-step debugging, unit-testing support....then there's Emacs support of lisp code editing (again with the parens matching), and the Bigloo package for well-optimized code that compiles to native or JVM (with full access to Java libraries)...google and you'll find plenty.

The misanthropes that took over comp.lang.lisp are pathetic. I've never seen a techical discussion group that hostile and defensive.

Common Lisp fossilized sometime back in the Reagan Administration and has since lost almost all ability to improve.

As a result, the vast majority of former users have abandoned it and those who remain almost have to take a position that there is no further NEED for improvement except in trivial ways (more libraries, more "complete" implementations, etc.) that, if you think about it, are merely restatements of the "nothing needs to be improved" notion.

Arc is announcementware. It has shown no signs of life since its first few weeks.

There are several dozen different Schemes, all incompatible, with an average of maybe 1.1 implementers each.

Of course, if you really want a one-implementation, brand-spanking-new (no compatibilities here, sir!) Lisp, then by all means check out newLISP.

If she's interested in programming as an intellectual challenge, I think PLT-Scheme's DrScheme is your tool of choice. I've never used HtDP, but just following the built-in tutorials that come with DrScheme is very instructive. This is especially true if you are willing to set aside the goal of building some particular program. When I get bored, I will occasionally do a problem or two from the DrScheme tutorial. It's much more fun than dumb desktop games like Solitare. Personally, I think of it more as solving puzzles than as "coding." (It's also a Debian package, so life is good.)

If she wants something to tinker with, I suggest getting a little colo box (a UML box isn't too expensive) and hacking around a little with apache, perl, python, shell and web-ish stuff. It's not always strictly programming, but it's a lot of fun and results can be seen without a huge amount of time/knowledge/effort, and she'll have something tangible for her efforts. Well, as tangible as anything in computing can be, anyway.

The brief summary is that there are currently two problems, that I know of offhand, with lambda in Python:

• Statements are not allowed, only expressions.
• Modifying the value of a variable in an enclosing scope is not allowed.

In languages that implement lambda correctly, lambda and functions are equivalent: you can do anything inside a lambda that you can do inside any other function. In fact, in Scheme, Lisp, Javascript and Perl, lambdas *are* functions and vice versa - there's no significant distinction (other than how a function is associated with its name, if any).

Significantly restricting what you can do inside a lambda makes about as much sense as restricting what you can do inside a function: it cripples the construct. You can't get a real sense for what lambda can do, using Python, because in Python, lambda can't do what it can do in other languages.

A good language to learn to get a better understanding of lambda is Scheme. You can try this tutorial, and download PLT's DrScheme to play with it.

"Learn Scheme. Download "DrScheme" and use it while you go through "How to Design Programs," a free online book for learning to program with Scheme. After that, go to half.com and buy "The Structure and Interpretation of Computer Programs" for around $10 (it'll be an old edition, but that's alright) and read through it, doing all the exercises it suggests.

If you do that, you'll not only know how to program, but you'll be a better programmer than probably 97% of the people on this board. Which doesn't say much, to be sure, but you'll find that the solid basis in programming that you've developed will allow you to learn any language you want easily. And you'll be able to program well in those languages."

Dr. Scheme
How to Design Programs (Uses Scheme to teach programming)
The Structure and Interpretation of Computer Programs (also uses Scheme to teach programming)

For those who're interested in Ruby, I've found a tutorial on that as well.

= 9J =

[Lisp] has a really steep learning curve, and there are no good free (as in software) development environments, as far as I know. (IANALisp Expert, though). Just you, Emacs and the Lisp interpreter.

Lisp is as powerful as mathematics, but there is more to a language than its semantics. It has to be accessible, too.

First off, Lisp isn't hard. It's like othelllo. Takes a day to learn and a lifetime to master. (gag)

My brief look at Oz seems to illustrate some similarities, but I'd have to check it out more to understand. Both have a core language set that everything else is reduced to. In lisp these are cons, car, cdr, cond, quote, apply, eval.

I'll take a look at Oz but what makes Lisp very powerful is that it has no syntax. The text is literally the parse tree which means that macros are very easy to define and use. The entire idea of programming using Lisp is to develop a language on top of Lisp. If you are writing an image editor you define an embedded language in Lisp for image manipulation. An because things can be compiled at runtime and macros can hide computation at compile time you can get good performance as well.

There is also a misconception that a language needs to explicit in what is efficient and inefficient. What is misunderstood is that it is very often not obvious where the bottlenecks are. The way to make a Lisp program fast is the same way you make a C program fast. 1) Profile 2) Find hot spots 3) Optimize 4) Rinse and repeat.

Also, concerning free development environment check out Dr. Scheme which is a nice UI and comes with a bunch of packages. I was working on some encryption problems and had a graphical histogram implemented in about 2 minutes. Try doing that in Java.

Lisp isn't designed for the average programmer. The best programmers use Lisp (if they are allowed to by their bosses) because it is the most powerful.

The How to Design Programs book and DrScheme environment make for a good start. DrScheme has settable "language levels" that turn off advanced features. This lets you get more intelligible error messages when you're just starting out. Without this feature, programmer newbies get strange error messages when a typo unintentionally invokes advanced language features.

I see alot of people getting upset at Mathhew without having read the article. For them, and for those who are reading in diagonal, I'll summarise the important point here.

At LL2 Matthew Flat posed that, while OS's and programming languages both support application development, by providing libraries of function calls, their difference in focus fundamentaly sets them appart. OS's focus on isolation of code, for security and for stability. Programming languages focus on cooperation, and try to maximize code reuse and efficiency.

Basicaly, OS hacker and the PL hacker have alot to learn from each each other. They would win at from cross-pollination between the two fields. Matthew then proceeded to show his implementation of what operating system concepts would look like in a programming language, by demoing DrScheme, a programming environment which can run (and debug) itself recursively.

While we're discussing Java IDEs, you might want to look at DrJava, a graphical IDE in development at Rice University. It's the only Java IDE I've ever heard of that has a read-eval-print loop built in (that is, a little prompt where you can type in Java expressions and see the results immediately), and it looks like it's modelled after another Rice software product, DrScheme. Though it's limited now, it looks like DrJava aims to be for Java what DrScheme is for Scheme, which would be cool.