Slashdot Mirror

Good suggestion! I would supplement it with the following as well:
1. Episodic Learner Model/An online Lisp tutorial
2. Common Lisp: A Gentle Introduction to Symbolic Computation
3. How to Design Programs
4. Practical Common Lisp
5a. The book - Structure and Interpretation of Computer Programs
5b. The movies - Structure and Interpretation of Computer Programs
6. Loving Lisp - the Savvy Programmer's Secret Weapon
7. Common Lisp the Language, 2nd Edition
8. On Lisp
9. common lisp: a web application tutorial for beginners
10. JavaScript: The World's Most Misunderstood Programming Language
11. Free JavaScript Learning Center
12. JavaScript for Scared People
13. JavaScript Closures
14. Why's (Poignant) Guide to Ruby

= 9J =

Design Patterns: Elements of Reusable Object-Oriented Software
Data Structures and Their Algorithms
Operating System Concepts
Joe Celko's Data and Databases: Concepts in Practice
How to Design Programs: An Introduction to Computing and Programming
Programming Ruby (2nd. Ed.)
Agile Web Development with Rails

+ some book on data communications and networking

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.

While not magazines, I've found these resources to be useful in becoming a better programmer:

CLiki, a programming language blog. Contains lots of stuff on programming languages and paradigms, including debates on merits and disadvantages.

ll-discuss, a mailing list related to programming language concepts. Perhaps most interesting if you're into language implementation, but it's the closest thing to a magazine that I can recommend.

Bugtraq, a (the?) security list. This will teach you what things to avoid; at least, the 3 most common errors.

Practical Common Lisp, a book that basically provides a crash course on Common Lisp. It shows you how things are done in Common Lisp, why they are done that way, and occasionally draws comparisons with other languages, everything including practical examples. It is said that, even if you don't program in Lisp, knowing it makes you a better programmer.

How to Design Programs, a fairly extensive book on program design. I haven't read the whole book, but it seems to both solidly and concisely cover many fundamentals. It uses Scheme for explaining things, but the material applies to other languages just as well.

As others have said, the problem is not languages. However, rather than offering vague suggestions about "motivation" or "picking a goal", I have some concrete advice: try taking a look at How to Design Programs. It's textbook by some of the best minds in CS education, and its goal is to teach you how to break down and structure problems, and create programs which solve those problems - not just to teach you a language. It'll teach you to think like a programmer. Which, quite frankly, sounds like what you need. Better yet, it's freely available online (so you can easily give it a testdrive), although I'd recommend picking up the print version if you decide you like what they have to say (for the sake of readability if nothing else).

I program since about 20 years, and have programmed in several different languages, but I found How to Design Programs very interesting to read and study. It really gives a nice methodology, which has influenced quite my programming, even in Perl.

Have her take a look at How to Design Programs -- there is a complete introductory course which uses the DrScheme programming environment.

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

Take a look at this, and the very elegant Scheme dialect that was designed to go along with it.
How To Design Programs
One semi-unique feature is that it asks you what your skill level is when you launch the environment, and tailors the feature-set accordingly.
Novices see a simple subset of the language, and experts get the full power inherent in a real-deal Lisp dialect.

The Little Schemer is indeed not available
on-line. You should be able, however, to
find a used copy for very little money at
the various internet sites or even at a college
bookstore near you. It's still heavily used as
a crash course on functional programming
(which is the only place where algebraic
variables really exist).

Think of How to Design Programs as an expanded
version of TLL/TLS.

-- Matthias Felleisen (author)

Eric Raymond:

LISP [or Scheme] is worth learning for a different
reason -- the profound enlightenment experience
you will have when you finally get it.

How to Design Programs

OK, I know I'm late to this party, but hopefully you're still reading reponses.

My evolution has been a bit different than yours (Atari 800/Apple ][ instead of TRS-80, never became an exec), but the net effect is the same: I used to program, and even was considered good, but now I'm barely a dabbler in it and I want to re-learn.

I found a really good tutorial called How to Design Programs. I've looked at/tried a lot of tutorials over the years, and I believe this is one of the best. The language it teaches is Scheme, buit that's almost irrelevent, as it's not getting into the nitty-gritty of the language, just using it as a tool to teach programming and design concepts. I'm going though it right now, and really enjoying it. Most other tutorials on programming I've run into to seem to be more interested in showing little details of their chosen language, and assuming a knowledge (or at least saving for later the lessons on) basic programming concepts.

Anyways, take a look - I hope it works out for you!

"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 =

My Book if you want to start at the bottom and work up.

How to Design Programs or Simply Scheme if you want to start at the top and work down.

I think there's also some good introductory Python books.

the only degree you get if you don't pay attention
is a degree of stultification and culture too poor to mention!

mod me up down or sideways, it doesn't really matter;
better get your RSI on, baby, and indulge in mindless chatter!

As an aside, I've always thought that the addition of another course or subject would have benefited the liberal arts study. As strange as this may sound, I believe that most students who enter college would benefit from a very practical four year course of how to study. A series of courses that would help students to the gain most from the other courses. Perhaps, the course could even focus on the much neglected skill of memorization. Stranger is that this is a subject not taught in public elementary or high-schools (they may be taught in private prepatory schools, though I wouldn't know). This is all fantasy of course, as people generally think they don't require assistance in learning. Sadly, most grades reflect the opposite.

I recently found a free online book from MIT Press which mentions some of your concerns in the book's preface. I thought you, and others with similar concerns would be interested in reading How to Design Programs: An Introduction to Computing and Programming.

Here's an excerpt from the Preface:

" Many professions require some form of computer programming. Accountants program spreadsheets and word processors; photographers program photo editors; musicians program synthesizers; and professional programmers instruct plain computers. Programming has become a required skill.

Yet programming is more than just a vocational skill. Indeed, good programming is a fun activity, a creative outlet, and a way to express abstract ideas in a tangible form. And designing programs teaches a variety of skills that are important in all kinds of professions: critical reading, analytical thinking, creative synthesis, and attention to detail.

We therefore believe that the study of program design deserves the same central role in general education as mathematics and English. Or, put more succinctly, everyone should learn how to design programs.

On one hand, program design teaches the same analytical skills as mathematics. But, unlike mathematics, working with programs is an active approach to learning. Interacting with software provides immediate feedback and thus leads to exploration, experimentation, and self-evaluation. Furthermore, designing programs produces useful and fun things, which vastly increases the sense of accomplishment when compared to drill exercises in mathematics. On the other hand, program design teaches the same analytical reading and writing skills as English. Even the smallest programming tasks are formulated as word problems. Without critical reading skills, a student cannot design programs that match the specification. Conversely, good program design methods force a student to articulate thoughts about programs in proper English.

This book is the first book on programming as the core subject of a liberal arts education. Its main focus is the design process tha

Great post.

I think I'll link to How To Design Programs. It's a book from MIT aiming to teach computing as a liberal art. The preface has a nice discussion about why everyone should learn how to program - much nicer, IMHO, than the Guardian's article.

• The programmer's stone, a *must* for anyone who is into programmation
• How to design programs
• Books by Bruce Eckel

Create a simple learning language... This already exists. It is pivotal part of the philosphy of How to Design Programs

Squeak is a cross-platform implementation of smalltalk that has developed quite the little community of educators and students around it. It allows budding programmers to start on a very basic level - something reminiscent of hypercard - but underneath it all is a real language that allows all the power and syntax you might want. As soon as you're ready, the power is there.

The scheme environment bundled with How To Design Programs has a similar goal of allowing the student to gradually ramp up the complexity of the language, but I find their rigid levels confining. Also, the programs a beginning programmer is able to put together are nowhere near as satisfying visually as what a new squeak user can build. (These kids today - in my day, we had either text or 40 by 40 graphics and we liked it.) That said, the htdp scheme environment may be more appropriate for a structured classroom environment with a series of lessons.

My only complaint about squeak is the license (despite claims on squeak.org, it's not really an open source license because of the fonts it includes); however, it is free-as-in-beer and has been already been used in elementary and middle school classrooms for both teacher- and student-created projects. (See squeakland)

Second, once they've got the basics down, get them something a bit more practical. Cygwin is free, and comes with gcc/gc++ and friends. Or even break down and spend a few bucks on Visual Basic (or, if they're really bright, a second hard drive with Linux/*BSD/whatever, so they can pick up GTK+ or QT or whichever widget set is trendy these days).

Most of the advogato article's suggestions are at best silly. I think he's promoting the return of LOGO, or whatever that language was where you did everything with a "turtle". Except that e apparently expects Microsoft, Sony, Nintendo, and everyone else to agree on a single standard, which is at best laughable. None of those game consoles even come with a keyboard any more, and I don't think you can even get keyboards for the GameCube...

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.

SICP is fantastic, but tough going for many. Here's one that's being used even at the high school level, with some success: How To Design Programs (HTDP).

The quotes were just accessible examples of why this book is inappropriate as an introduction to conceptual computing fundamentals. There are other papers highlighting problems with the GoF book in its own terms, if that's what you're interested in. LISP and Dylan aren't perfect models either, and I certainly wouldn't base a course entirely on them.

I'm sure you are aware of established books on computing fundamentals, such as How to Design Programs, so it must be fairly obvious that the GoF is not remotely comparable to these.

Lucky you. Some poor recommendations so far IMHO, with the honourable exception of SICP.

The key thing is to keep a sense of proportion - anyone referring to UML or the GoF design patterns book has failed to understand what the fundamentals of IT are, and is certainly overestimating the relevance of their own preferred language or paradigm.

Scheme/LISP, logic and some database theory is a good way to approach the fundamentals, as it was 15 years ago when I went through it. They won't thank you to begin with, but its what college is for! I'm not totally sold on SICP, students might think it's a bit pedantic, you might like to look at How to Design Programs as an alternative. I don't have a good reference for database and logic texts - I use Joe Celko's Data and Databases book, but this isn't suitable as an introduction.

The best introductory computer science textbook is "Structure and Interpretation of Computer Programs", also known as the wizard book because of the wizard on the cover. I've also heard good things about "How to Design Programs." Both of these books avoid the pitfall of focusing on syntax by using Scheme, which has very little syntax. I haven't read HTDP, but SICP is the best introductory computer science textbook I've read, and many computer science educators agree.

You may be looking for the book How To Design Programs. I haven't read (all) of this book but I've learned a lot from the guys who wrote it. The complete text is online so take a look.

The Teach Scheme Project and the "How to Design Programs" web sites have some very good arguments in favor of using Scheme as a first computer language.

I agree with "How to Design Programs" (MIT Press, available online with a great Scheme environment usable by beginners) as well as experts) that Scheme is a great first language.

Scheme does not have any construct called "loop" defined in the standard, nor do any implementations I know of define one. R5RS (the scheme standard) does specify that scheme implementations should define in their standard libraries (!) two iteration constructs, one called "do" and the other a variant of "let" (in practice often called "let loop," which might be what you're thinking of). The standard explicitly says that these should be in the library, not primitive Scheme syntax. In practice, neither iteration construct is used all that often by experienced Schemers (I've been programming in Scheme for 5 years and I actually didn't know about the "do" macro until I looked it up just now).

So you might be wondering: How the heck do experienced Schemers loop over things if they don't use those loop constructs? And anyway, how are they implemented in the library if there are no more primitive loop constructs around?

The answer is recursion -- functions that call themselves. Scheme is all about recursion; the specification even forces implementations to make certain efficiency guarantees about it so that Schemers can recur to their hearts' content without incurring runtime penalties over looping. For instance, in C, you'd probably count the size of a list like so:


int list_size(List* l) {
int count = 0;
while (l != NULL) {
count++;
l = l->next;
}
return count;
}


In scheme, you could define it the same way:

(define (list-count lst)
(let ((count 0))
(let loop ((r lst))
(if (null? lst)
count
(begin
(set! count (add1 count))
(loop (cdr r)))))))

... but that would be awful scheme. More advanced schemers would write

(define (list-count lst)
(cond
((null? lst) 0)
(else (add1 (list-count (cdr lst))))))

or even:

(define (list-count lst) (foldr add1 0 lst))

So, you might be thinking: 'That's nice. So it's just a funny way of saying "for" that I don't understand very well and doesn't seem to have any advantages.' A lot of people have that impression and get turned off to Scheme because of it. But it's not true: for one thing, see how much prettier my second Scheme definition is than my first? It's more compact, and once you get used to it, easier to write, read, and debug. Furthermore, it's more directly applicable to many programming situations, particularly when they involve complex data. Read all about it in How to Design Programs , an excellent introductory textbook on Scheme and programming.

And nope, the Scheme standard defines no record or structure type. Look through the standard yourself, you won't find it there. This is in fact pretty frustrating to the Scheme community.

As for assembly, first of all, remember that every processor has its own assembly language and they're not all the same. That said, jump is not the same as a loop. Jump means "go straight to some other point in my program and keep going," which is more general than loop (but can be used to implement loop).

• Structure and Interpretation of Computer Programs
• Common Lisp HyperSpec
• Common Lisp the Language, 2. ed
• Common Lisp - A gentle Introduction to symbolic computation
• The Scheme Programming language, 2. ed
• Reflections on trusting trust
• Lisp: Good News, Bad News. How to Win Big
• John McCarthy's homepage
• Dennis Ritchie's homepage
• Various classic papers it's a shame ACM never bothered to continue adding to
• Another list of classic papers (this time related mostly to programming language design)
• GTK-Gnome Application Development (not a classic, though, as the field is too young)
• KDE 2.0 Development (not a classic though, as the field is too young)
• Eric Weissteins Mathworld
• Compilers and compiler generators - an introduction with C++ (although I'm not too sure if it deserves being called a classic...)
• Parsing techniques - A practical guide
• Art of assembly language programming (never was a dead tree, but good anyway)
• Paul Carters 386 assembly book (same comment as above)
• An Introduction to Scheme and its Implementation (see comment above)
• How to design programs - An introduction to programming and computing (not a classic, yet!)
• The Gutenberg archives contains much non-copyrighted classic fiction in ASCII format
• Sacred texts has copies of or links to many religious text for various major (or minor) religions

This book is an introduction to computer programming that uses Scheme to teach computer programming. You can find it at www.htdp.org.

You may want to give "How to Design Programs" a look (http://www.htdp.org) a try.

htdp.org (how to do programming) is an excellent guide put by MIT. It is aimed at high school students, but is a very good guide for non-programmers. It uses Dr.scheme, a special version of scheme prepared bye MIT & is also available for all platforms. And also, it's aim ( as speciefied on the site) is to teach fundamentals, you can use anywhere & it does acheive it. And it's free too.

Keep your goal and your audience in mind. MIT is out to produce computer scientists, not programmers. SICP might not be the best textbook for everybody. However, Scheme's advantages apply to other introductory courses as well, e.g. How To Design Programs.

Your difficulty in the AI course was probably due to the material covered, not the language used. How To Design Programs is even taught to high-school students.

I would disagree with the statement that AP Computer Science should teach students about low-level workings of a computer. Instead, the AP has always been about teaching a kind of rigorous thinking that can be honed through programming. To that end, I think that the work of Felleisen, et al (see http://www.htdp.org/) to bring Scheme to young students is wonderful. Though personally, I think that a static-typing approach is more useful. I say, teach AP CS in a language like SML or OCaml.

• "Teach Yourself Scheme in Fixnum Days": A comprehensive tutorial
• "The Scheme Language": a shorter tutorial
• "Invitation to Scheme": yet another tutorial
• The Scheme Language Standard, "R5RS", is actually surprisingly readable, at about 50 pages. Here's a PDF of R5RS, which is useful to have around if you're actually using the language.
• The Structure and Interpretation of Computer Programs (SICP) - a.k.a. the wizard book, a very worthwhile and enlightening book, used as an introductory text at MIT. It's available on the web, but it's not a light or quick read.
• How to Design Programs (HTDP) - a book that teach program design techniques, using Scheme.