An Open Challenge

[Cervantes]

[Gandalf] wrote:

3. CompSci.ca

4. Ignore it, see 3.

This would be great, except very few people come to CompSci.ca. In the time that I've been here (2 years), we've grown by about 2500 users. Of all the schools in ontario that teach Turing, and all the students that pass through the CS courses at these schools, we reach a very small percentage of our target audience.

Let's face it: Holtsoft has a very strong grip on the Ontario high school cs system. If we're going to be teaching CS with Turing, it needs to be taught as well as possible. For that, Ontario needs more of its CS students coming to this site. Perhaps not as individuals, but as a class. Entire classes using CompSci.ca.

[rizzix]

Thanks for the input guys. Very helpful. Although I'd appreciate you add to wtd's list instead of providing solutions. =)

Also as far as possible don't comment on the language's syntax/semantics. Schools chose turing most likely because it closely resembles BASIC (with a slight Pascal twist), yet it isin't just as ugly.

[wtd]

Sadly it seems "new" technologies can only be accepted if they come in a familiar syntactic wrapping. Pascal was the standard, and Turing mostly resembles it, so it was a safe bet.

Since then progress in languages that both syntactically and semantically resemble Pascal has been relatively stagnant. Oberon never caught on and Ada and Eiffel are both semantic departures to a large extent.

Only overwhelming industry pressure and C curmudgeons who think they can teach anything that vaguely resembles C have pushed the likes of Java and C# into the limelight. Unfortunately if we are to judge progress by the evolution of C-syntax-ish languages, then the world must seem bleak indeed.

My conclusion: functional programming really needs a push. O'Caml is but one functional programming language among several but I believe it has the best chance at widespread acceptance.

[rizzix]

Pascal-like languages are a great teaching tool.

I guess one could safely introduce functional programming langauges in later grades (gr 12?). They are not so easy to learn.

[wtd]

How are they not easy to learn, in your estimation?

[rizzix]

Well I was thinking Haskell, but as you say O'caml is easier?

[wtd]

"Easy" is a dangerous word to use. I will say that I believe it's more accessible.

[rizzix]

Not good enough, not for the schools anyway.. They want something stupid easy, so they can teach everything from the basics all the way to complex stuff without much hassle.

I'm just saying that the functional programming classes could have higher drop-out rates.. And not comp-tech department whats that to happen.

[wtd]

O'Caml can do that. I just dislike "easy" because it's way too much like "intuitive" and there's no such thing as an intuitive programming language.

[Cervantes]

It's difficult for us learnéd to say which approach is easier, for we cannot go back and test each route. Any statement we make is speculation.

I may not be able to say which is easier from the beginning, but I can say this: learning O'Caml was tough -- and I'm just talking about the functional aspect, for there's plenty I haven't done.

That said, we have to ask, "Why is it tough?" It's tough because it is a different way of looking at things. A lot of the concepts learned from other languages are not valid in a functional environment. This could explain why learning O'Caml was tough: because it goes against the grain. But what is it like for a student learning programming from the very beginning, whose grain has not been directed?

Some would argue that learning procedural programming is easier than learning functional languages because learning Turing is easier than learning O'Caml. However, Turing is designed for teaching, while O'Caml is not. It would be much more fair to compare a student with no previous programming experience learning C++ to one learning O'Caml.

Which bird will be the first to fly, now? That's a tough question, and would require a comprehensive study to answer. One point in favour of O'Caml is the interactive interpreter. Also, graphics seem to be necessary to hook a good portion of the young would-be programmers, these days. O'Caml has its own graphics library, so we don't have to go to OpenGL or SDL or others. (I haven't used O'Caml's graphics, myself, so I could be wrong about this.)

Which bird will fly better, in the end? The O'Caml bird, because O'Caml is non-standard. Consider the two new-born birds. Both develop their own approach to flying, but only one of them is widely accepted by others. The bird who learned this accepted style uses it for the rest of his life, unquestioningly. The bird who learned the other style will eventually also learn the accepted style. Now, with two styles known, this bird has a choice. This bird can raise important questions about one style, which is only possible given the knowledge of the other style. A student who learns O'Caml will, eventually, come to learn more "mainstream" languages like C++. The student who begins with C++ may be content with C++ and never learn anything else. Versatility and a wide-knowledge base is important, and beginning with a less "mainstream" language helps to ensure this is attained. Of course, Turing is also not a mainstream language, but it doesn't differ enough from the mainstream languages in ways other than just lacking things to be on the same grounds as O'Caml.

Which bird will fly faster, in the end? Certainly the O'Caml bird, for O'Caml is completely functional functionaly, but at the same time includes other programming paradigms, such as Object-Oriented Programming, and imperative programming (we have mutable variables). It is broad. After O'Caml, one is very prepared for what the rest of the programming world can throw at one; one can learn other languages, such as C++, faster.

[wtd]

I've often wondered, and I might as well ask it here...

Turing is widely accepted among those here as a good teaching language. What makes it especially well-suited to that task? What fundamental concepts does it convey particularly well?

[Cervantes]

That's a difficult question to answer. Logically, I'd think Ruby or O'Caml or Io would make a better teaching language, and yet Turing is entrenched in the Ontario Computer Science classroom. With regard to Turing's ability as a teaching language, the main reason Holtsoft pushes is an easy to use syntax. But it's not the syntax that makes a language hard or easy to learn. It's something else.

My answer is the learning curve. Turing offers a very slow learning curve. I'm in my third year of high school computer science classes, and I've yet to leave Turing. My class is going to learn the fundamentals of OOP in Turing in several weeks. Turing's slow learning curve allows the less than bright students in the class to keep up.

Why does Turing have a slow learning curve? Does any other language, if taught in the classroom, have an equally slow learning curve? Maybe. However, one possible explanation for the slow curve is graphics. Since Turing makes it easy to use graphics, students make games. They get involved in the development of their game, and less involved with the development of their programming ability. Rather than advancing and learning higher programming concepts, they are content to use their current knowledge, often times struggling, to wade through a sea of graphics to produce a game. They will create a monstrosity of variables, rather than using an array, because they are more involved in the development of their game than the development of their programming ability. They will use types pseudo-objects and procedures to manipulate entire arrays of these pseudo-objects, rather than learning object-oriented programming. Perhaps it is the graphics, the detachment from programming, that makes Turing such a popular programming language.

Another possible explanation for the slow learning curve: Turing does not push you forward. In some languages, you have to learn the next concept to understand the last. For example, in Ruby, you have to understand OOP to understand "Hello World".length. You have to understand yield to understand blocks. In Java, you begin with a class, and the simplest Hello World program requires a knowledge of OOP and how Java fundamentally works to understand. These languages have some "magical" parts to them that are only explained once higher concepts have been learned. Turing does not push its users forward, for it is built from the ground up. Unlike Ruby, for example, Turing's OOP is tacked on at the end. We can go all the way from if structures and variables to types and functions and modules and collections and linked lists without ever seeing OOP. There's no incentive to learn OOP. If a student learns OOP ahead of the class, that student is exceptional. The majority of students will not.

[rizzix]

Hmm, I don't know, but that's still a whole lot of speculation. O'Caml could very much be like Turing in the end. It is just an intermediary step to the real programming or computer science. The full blown attack evetually comes to you in the end, in university or college -- where you are unfortunately forced to learn C, C++ or Java.

Then again, functional programming closely relates to math. Not all students who program are comfortable with math. I don't believe you should _need_ to know math just to program (or think like a mathematician for that matter). Eventually yea you need to use math to do some useful stuff, but think of it this way: invite the student to learn math because he wants to program and not that he should know math to program.

When creating games, you eventually do need to use a whole lot of simple or complex math. Since creating games is one nice and simple way to grab the attention of most young programmers, it sort of does the trick here. (once again you don't need to enforce this, they will pick it up on their own)


Now if you are teaching a functional programming language, heck, I think the drop out rates would be pretty high. (That is a major concern with most schools).
It's just like when they make math optional in highschool, hardly anyone takes the course. =/

I think _universities and colleges_ should use functional programming languages as their preferred language for teaching programming and other computer science concepts, while high schools use an imperative Pascal-like language such as Turing.

The moment a student gets the hang of a well-defined imperative language he is intrigued and curious about the mechanics of the language. He wants to know more. This is a very healthy sign. Languages which are not properly defined make this impossible. In that regard I think Turing is a bad choice. Turing has too many exceptions to the rule. There shouldn't be any.

[rizzix]

Cervantes wrote:

Why does Turing have a slow learning curve? Does any other language, if taught in the classroom, have an equally slow learning curve? Maybe. However, one possible explanation for the slow curve is graphics. Since Turing makes it easy to use graphics, students make games. They get involved in the development of their game, and less involved with the development of their programming ability. Rather than advancing and learning higher programming concepts, they are content to use their current knowledge, often times struggling, to wade through a sea of graphics to produce a game. They will create a monstrosity of variables, rather than using an array, because they are more involved in the development of their game than the development of their programming ability. They will use types pseudo-objects and procedures to manipulate entire arrays of these pseudo-objects, rather than learning object-oriented programming. Perhaps it is the graphics, the detachment from programming, that makes Turing such a popular programming language.

This depends on the teacher really. If the teacher penalizes on poor use of programming constructs whether or not the game was very creative, then the student would be forced to program the correct way. Make it clear, that although creativity is a great thing, it is not everything when it comes to programming.

Cervantes wrote:

Another possible explanation for the slow learning curve: Turing does not push you forward. In some languages, you have to learn the next concept to understand the last. For example, in Ruby, you have to understand OOP to understand "Hello World".length. You have to understand yield to understand blocks. In Java, you begin with a class, and the simplest Hello World program requires a knowledge of OOP and how Java fundamentally works to understand. These languages have some "magical" parts to them that are only explained once higher concepts have been learned. Turing does not push its users forward, for it is built from the ground up. Unlike Ruby, for example, Turing's OOP is tacked on at the end. We can go all the way from if structures and variables to types and functions and modules and collections and linked lists without ever seeing OOP. There's no incentive to learn OOP. If a student learns OOP ahead of the class, that student is exceptional. The majority of students will not.

Acutally this is a Very Bad Thing IMHO. The best language would be one where the student didin't even know there's was a whole new side to language untill he reaches a higher level, grade etc. Keeping things hidden from the student (while he's aware of it) leaves him in the dark. This should not be the case.

[wtd]

Of course, I think if we're to identify a language especially well-suited to education, then we should first identify what we want from such a language, then find a language which best fits those goals.

As opposed to having a favorite language and then trying to justify its use in education. I probably won't seem flexible as I've done this analysis in detail and arrived at O'Caml.