Replacing Turing

[wtd]

We've talked about in a lot of different topics, so let's talk about it in one dedicated place. Many of us have agreed that Turing does not make a terribly good teaching language, and we've made scattered suggestions about what we'd rather see in its place.

Now, I want to approach this from a slightly different direction. Let's lay out exactly what a language seeking to replace Turing should be like, then identify candidates. I'll go first.

Goals

A replacement for Turing should be freely available and cross-platform. One of Turing's big failings, from what I've seen here is that it's not free and it only runs on Windows. This hinders students who want to do homework or experiment at home, especially if they're using Linux. The language's environment should run on Windows (preferably as old as 98), Linux, and Mac OS X. On Windows, it's preferred for an easy installer to be available. The language should also have an open source implementation, to ensure it's availability in the future.

A replacement for Turing should have an interactive interpreter available to allow for quick testing of code. Of course, execution of complete source files should be available as well.

A replacement for Turing should allow students to edit several programs at once. For example, it should be possible for me to be writing a program and open an interactive interpreter to see what a particular line of code does.

A replacement for Turing should make it easy or at least straightforward to demonstrate at least the following concepts:

• Simple Input/Output
  
• Conditionals
  
• Functions
  
• Loops
  
• Recursion
  
• Arrays/Lists
  
• File I/O
  
• Compound Data (Records, Structs)

A replacement for Turing need not be in widespread "commercial" use, but it should have a community to which students can turn for aid when a teacher is not immediately available.

A replacement for Turing should either enforce some kind of naming convention to aid communication, or be case-insensitive.

A replacement for Turing should allow for code to be reused via some mechanism more sophisticated than copy and paste.

Preferably a replacement for Turing should emphasize expressions, rather than statements.

Candidates

Ruby, Haskell, O'Caml and SML all meet the requirements fairly well, in my (somewhat) educated opinion.

One problem with Ruby could be that it is an object-oriented language, and a very nice one. However, if teachers plan not to explain OOP, they will be hard-pressed to explain the method calls that will invariable surface when dealing with Ruby code.

Haskell and SML suffer the opposite problem. They have no facilities for OOP, at least the way we normally think of it. Ifa teacher wanted to teach OOP, Ruby or O'Caml would be better options.

[wtd]

I should add Python to my list of candidates, despite it not being a particular favorite of mine. It has a few caveats, though.

Students cannot use its standard library without some understanding of OOP. Also, significant whitespace can be a problem. An accidentally deleted space shouldn't prevent compilation/execution for students new to programming. Haskell also uses significant whitespace, but does it a bit better, and makes it optional (though preferred).

[wtd]

Before this discussion died a horrible death I think we had identified a few core concerns.

Error identification should, at the very least, be accurate. That is to say, the program should identify exactly where in the program the error occurred. Preferably it should identify as well the root cause of the error.

An editor is needed with support for the language's syntax. Textpad on Windows and various options on Linux and Mac OS X fill this need fairly well for most programming languages

A good module/package system is needed.

Object-orientation should be available, and supported by the language's syntax, but should not be necessary to teach more basic concepts (strings, collections, etc.). As much as I'm a fan of Ruby, this pretty well rules it out. It also rules out a number of other languages: Python, Java, C#, C++, and likely others I'm forgetting now. The lack of support for object-orientation in SML and Haskell rule those out if we accept this as an absolute.

First class functions being available doesn't hurt, but one should be able to interact with the language without understanding them immediately.

[wtd]

But possibly the biggest concern raised was that of publications. Apparently, though I haven't experienced it directly to be able to comment authoritatively, there's quite an infrastructure built around teaching Turing at a beginner level.

I we can decide on a language, perhaps we could work to adapt the most popular of that material. Having the input of those who have learned Turing in an academic environment culd allow us to create a smooth transition.

[[Gandalf]]

I would give some input on this thread, but I lack the neccessary knowledge of other languages to really say much.

The thing is, many people who have learned Turing will not want to switch. I think I speak for the majority of 'programmers', not neccessarily influenced by compsci.ca, that once they learn something like Turing they will either drop out of that field of knowledge, or they will want to switch to college type languages like SQL, C, php, C++, and other variants.

I think something crucial in a beginner language is a simple, productive start where you can actually make something out of your beginner knowledge. Turing does this by having easy to learn commands, simple things like putting text and getting input, but it could be done better.

[wtd]

Well, the purpose of this thread is to discuss a language that could be used instead of Turing, rather than as a supplement after the fact.

And there are many languages that permit for that kind of productive start without too much overhead.

[JackTruong]

wtd wrote:

A replacement for Turing should be freely available and cross-platform. One of Turing's big failings, from what I've seen here is that it's not free and it only runs on Windows.

I've actually tried Turing with WINE on a linux box, it worked. I ran all my school projects perfecly on it, except the parallelput commands.

[wtd]

JackTruong wrote:

wtd wrote:

A replacement for Turing should be freely available and cross-platform. One of Turing's big failings, from what I've seen here is that it's not free and it only runs on Windows.

I've actually tried Turing with WINE on a linux box, it worked. I ran all my school projects perfecly on it, except the parallelput commands.

Yes, but you shouldn't have had to do that.

[wtd]

An observation: regardles sof the language, great stress should be placed on a curriculum with assignments that match the level of knowledge a student has of the language.

For example, students should not be creating even simple RPGs without an understanding of record types (or "structs" if you prefer) for managing the state of any given unit in the game.

[md]

Free pascal meets most of the requirements; except for the interpreted execution; and debugging requires a bit of understanding.