Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

classic Classic list List threaded Threaded
67 messages Options
1234
Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

Chris Seberino
Instead of learning only Scheme or only Python for a one semester intro
course, what about learning BOTH?  Maybe that could somehow
get the benefits of both?

I'm thinking that for the VERY beginning, Scheme is the fastest language
to get beginners up and running writing code due to the extremely minimal simple syntax.

I'm thinking half way into the semester, instead of moving into intermediate Scheme, perhaps that is a good time to switch to Python?

Would a little strong intro to 2 nice languages in one semester be
same/good/worse/better than just 1?

cs


Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

mwilson
On Sun, 10 May 2015 13:43:03 -0700, Chris Seberino wrote:

> Instead of learning only Scheme or only Python for a one semester intro
> course, what about learning BOTH?  Maybe that could somehow get the
> benefits of both?
>
> I'm thinking that for the VERY beginning, Scheme is the fastest language
> to get beginners up and running writing code due to the extremely
> minimal simple syntax.
>
> I'm thinking half way into the semester, instead of moving into
> intermediate Scheme, perhaps that is a good time to switch to Python?
>
> Would a little strong intro to 2 nice languages in one semester be
> same/good/worse/better than just 1?

The first course I took, we learned Algol-60, then when we couldn't get
computer time for compiles, we were asked to pick up FORTRAN-IV on the
side.  So we "published" our solutions to the class problems in Algol and
re-wrote them to be run in FORTRAN.  It was a fine first-hand look at
what the "general purpose" in General Purpose Computer really meant.  
There was no confusing the machine and the language after that.  Scheme/
Python would be even more radical, I think.  If you can put them across
effectively, I say go for it.

        Mel.
>
> cs



Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

Marko Rauhamaa
In reply to this post by Chris Seberino
Chris Seberino <cseberino at gmail.com>:

> Instead of learning only Scheme or only Python for a one semester
> intro course, what about learning BOTH? Maybe that could somehow get
> the benefits of both?
>
> I'm thinking that for the VERY beginning, Scheme is the fastest
> language to get beginners up and running writing code due to the
> extremely minimal simple syntax.

Scheme is my favorite language. I think, however, it is a pretty
advanced language and requires a pretty solid basis in programming and
computer science.

Python, in contrast, is a great introductory programming language. Sure,
you *can* get quite advanced with it, too, but you can get quite a bit
of fun stuff done with just the basics.

Of course, you could introduce Scheme with similar simplifications.
However, such simplifications (say, iterative constructs) are
nonidiomatic in Scheme. The students should not get into bad habits
that they need to be weaned off of later.

> I'm thinking half way into the semester, instead of moving into
> intermediate Scheme, perhaps that is a good time to switch to Python?

What are you teaching? If you are teaching computer science, you should
use languages to illustrate abstract ideas. Thus, Python can be used to
introduce basic control and data structures, I/O, OOP etc. Scheme should
be used to teach functional programming and maybe combinatory logic and
computability. Prolog could be used to demonstrate logic programming and
automated theorem proving. C could be used to understand the
nitty-gritties under the hood and fear of SIGSEGV.


Marko


Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

zipher
In reply to this post by Chris Seberino
On Sunday, May 10, 2015 at 3:43:25 PM UTC-5, Chris Seberino wrote:

> Instead of learning only Scheme or only Python for a one semester intro
> course, what about learning BOTH?  Maybe that could somehow
> get the benefits of both?
>
> I'm thinking that for the VERY beginning, Scheme is the fastest language
> to get beginners up and running writing code due to the extremely minimal simple syntax.
>
> I'm thinking half way into the semester, instead of moving into intermediate Scheme, perhaps that is a good time to switch to Python?
>
> Would a little strong intro to 2 nice languages in one semester be
> same/good/worse/better than just 1?

No.  LISP-like languages are very different beasts, requiring different mind-sets.  It's like going from geometry to arithmetic.

Or trying to teach OS/2 (which had great abstract ideas) and switching to Linux without covering the architecture and engineering underneath them.

mark


Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

zipher
> > Instead of learning only Scheme or only Python for a one semester intro
> > course, what about learning BOTH?  Maybe that could somehow
> > get the benefits of both?
>
> No.  LISP-like languages are very different beasts, requiring different mind-sets.  It's like going from geometry to arithmetic.
>
> Or trying to teach OS/2 (which had great abstract ideas) and switching to Linux without covering the architecture and engineering underneath them.

Another point.  You're allowing Church`s Thesis to misinform you.  While, in theory, every programming language could be made into any other, the architecture in which to do so is completely different, so it misleads the programmer.

To fit LISP into a Turing Machine architecture (what most every procedural programming language and most every computer sold is/utilizes) requires a very obscene translation table in the TM.  I'm not even sure that it's been analyzed, because the TM has no concept of a stack.

Any PhD's know of who's actually make a stack on the TM?  Usually the tape itself holds the stack, but with LISP architecture, this isn't the natural fit.

Mark


Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

Ian Kelly-2
In reply to this post by Marko Rauhamaa
On Sun, May 10, 2015 at 3:16 PM, Marko Rauhamaa <marko at pacujo.net> wrote:
> Scheme is my favorite language. I think, however, it is a pretty
> advanced language and requires a pretty solid basis in programming and
> computer science.
>
> Python, in contrast, is a great introductory programming language. Sure,
> you *can* get quite advanced with it, too, but you can get quite a bit
> of fun stuff done with just the basics.

MIT famously used Scheme in their introductory course for more than
two decades. Although they switched to Python a few years ago, I don't
think they did so because there was anything wrong with Scheme.
Wikipedia informs me that Yale and Grinnell are still using Scheme for
their introductory courses.

> Of course, you could introduce Scheme with similar simplifications.
> However, such simplifications (say, iterative constructs) are
> nonidiomatic in Scheme. The students should not get into bad habits
> that they need to be weaned off of later.

You don't need iterative constructs to teach an introductory course.
The full text of SICP (the "wizard book") is available on the web for
anyone to read at https://mitpress.mit.edu/sicp/. I don't think it
ever even *mentions* "iterative constructs". Where it distinguishes
recursive algorithms from iterative ones, recursive syntax is used in
both cases.

>> I'm thinking half way into the semester, instead of moving into
>> intermediate Scheme, perhaps that is a good time to switch to Python?

No, stick with one language for at least the first course. Needing to
learn the syntax and semantics of *two* programming languages,
especially two such different ones, is just going to distract students
from the fundamental concepts that the introductory class is intended
to teach.


Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

Chris Angelico
In reply to this post by Chris Seberino
On Mon, May 11, 2015 at 6:43 AM, Chris Seberino <cseberino at gmail.com> wrote:

> Instead of learning only Scheme or only Python for a one semester intro
> course, what about learning BOTH?  Maybe that could somehow
> get the benefits of both?
>
> I'm thinking that for the VERY beginning, Scheme is the fastest language
> to get beginners up and running writing code due to the extremely minimal simple syntax.
>
> I'm thinking half way into the semester, instead of moving into intermediate Scheme, perhaps that is a good time to switch to Python?
>
> Would a little strong intro to 2 nice languages in one semester be
> same/good/worse/better than just 1?

I strongly recommend learning multiple languages, but not at the cost
of proper comprehension of one of them. Pick one and get started with
it, and once you have some basic competence, pick up another; you'll
gain a better appreciation for both that way.

As to which one first... I always recommend Python as a first
language, due to the lack of boilerplate and the simple layout. But if
you have a background that makes LISPy languages a better fit for you,
then by all means, take Scheme first. For most people I work with, an
imperative language makes a better first fit; most people understand
the concept of giving someone a series of instructions and expecting
them to be performed in sequence down the page, but functional
languages take more getting used to. But if you're already accustomed
to a functional style - maybe a heavy mathematical background - then
LISP-family languages will be a logical extension from that.

Eric Raymond recommends [1] learning five languages with distinctly
different styles: Python, C/C++, Java, Perl, and LISP. Of the five, I
would recommend leaving C and Perl for later, as neither is
particularly friendly to a new programmer; the other three you could
pick up in any order, and there are commercial courses using all of
them. (I personally don't think Java offers much that other languages
don't, and haven't used it for anything since the days when Java
applets were the only decent way to embed executable code in web
browsers; these days, I'd much rather do everything in Python or Pike.
But that doesn't mean Java isn't worth learning.) The more languages
you learn, the better you'll be as a programmer - but don't skimp on
one to pick up another.

ChrisA

[1] http://www.catb.org/esr/faqs/hacker-howto.html#skills1


Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

Rustom Mody
In reply to this post by Marko Rauhamaa
On Monday, May 11, 2015 at 2:46:38 AM UTC+5:30, Marko Rauhamaa wrote:

> Chris Seberino :
>
> > Instead of learning only Scheme or only Python for a one semester
> > intro course, what about learning BOTH? Maybe that could somehow get
> > the benefits of both?
> >
> > I'm thinking that for the VERY beginning, Scheme is the fastest
> > language to get beginners up and running writing code due to the
> > extremely minimal simple syntax.
>
> Scheme is my favorite language. I think, however, it is a pretty
> advanced language and requires a pretty solid basis in programming and
> computer science.

Have you seen this?
http://www-inst.eecs.berkeley.edu/~cs61a/sp12/book/

Yeah from a certain pov scheme is so advanced that even Abelson and Sussman dont
quite get it: http://blog.languager.org/2013/08/applying-si-on-sicp.html
So (from that pov) how reasonable is it to expect students to get it?

Also good to see:
http://www.cs.kent.ac.uk/people/staff/dat/miranda/wadler87.pdf


Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

Steven D'Aprano-11
In reply to this post by Chris Seberino
On Mon, 11 May 2015 06:43 am, Chris Seberino wrote:

> I'm thinking that for the VERY beginning, Scheme is the fastest language
> to get beginners up and running writing code due to the extremely minimal
> simple syntax.

Do you believe that learning syntax is the hardest part for beginners to get
past?

If so, then perhaps you should start by teaching beginners machine code,
since the syntax is very simple: any sequence of hexadecimal digits is
syntactically valid machine code. If you can teach people to use
0123...9ABCDEF then you have just taught them everything they need to know
about the syntax.

*wink*

The point is, syntax can be *too* minimal, as well as too heavyweight.


--
Steven



Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

Rustom Mody
On Monday, May 11, 2015 at 9:29:31 AM UTC+5:30, Steven D'Aprano wrote:
> On Mon, 11 May 2015 06:43 am, Chris Seberino wrote:
>
> > I'm thinking that for the VERY beginning, Scheme is the fastest language
> > to get beginners up and running writing code due to the extremely minimal
> > simple syntax.
>
> Do you believe that learning syntax is the hardest part for beginners to get
> past?

You seem to be asking a rhetorical question.

I regard it as a basic koan in CS
http://blog.languager.org/2015/04/poverty-universality-structure-0.html#fundamentalKoan


Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

Skip Montanaro
Don't CS departments still have a computer languages survey class? When I
was a graduate student at Iowa in the early 80s, we had one. (It was, as I
recall, an upper level undergrad course. I didn't get into CS until
graduate school, so went back to filled in some missing stuff.) I don't
recall all the languages we touched on, but ISTR there were five or six. I
know we hit Lisp (today, it would likely be Scheme), and probably APL
(today it would probably be Python+Pandas, MATLAB, R, or something similar).

Skip
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/python-list/attachments/20150511/2d2a5798/attachment.html>

Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

Grant Edwards-7
In reply to this post by Rustom Mody
On 2015-05-11, Skip Montanaro <skip.montanaro at gmail.com> wrote:

> Don't CS departments still have a computer languages survey class? When I
> was a graduate student at Iowa in the early 80s, we had one. (It was, as I
> recall, an upper level undergrad course. I didn't get into CS until
> graduate school, so went back to filled in some missing stuff.) I don't
> recall all the languages we touched on, but ISTR there were five or six. I
> know we hit Lisp (today, it would likely be Scheme), and probably APL
> (today it would probably be Python+Pandas, MATLAB, R, or something similar).

There was a similar class at both Iowa State and University of MN. You
learned a half-dozen languages in a single quarter.  IIRC, at ISU we
did Lisp, Prolog, APL, Snobol and a couple others.  The main
pedagogical language at the time was Pascal, but we also learned
FORTRAN, COBOL, BASIC, and a couple three assembly languages (PDP-11,
VAX, Z80, 6502).  If you were a computer enineering major instead of
computer science, you also leared a hardware description language.  At
the time it was AHPL.

More recent gruaduates only seem to know one language (Java or C++)
and are completely baffled by anything else.

And don't get me started on that damned noise they call music...

--
Grant Edwards               grant.b.edwards        Yow! !  Now I understand
                                  at               advanced MICROBIOLOGY and
                              gmail.com            th' new TAX REFORM laws!!


Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

Rustom Mody
On Monday, May 11, 2015 at 8:05:56 PM UTC+5:30, Grant Edwards wrote:

> On 2015-05-11, Skip Montanaro  wrote:
>
> > Don't CS departments still have a computer languages survey class? When I
> > was a graduate student at Iowa in the early 80s, we had one. (It was, as I
> > recall, an upper level undergrad course. I didn't get into CS until
> > graduate school, so went back to filled in some missing stuff.) I don't
> > recall all the languages we touched on, but ISTR there were five or six. I
> > know we hit Lisp (today, it would likely be Scheme), and probably APL
> > (today it would probably be Python+Pandas, MATLAB, R, or something similar).
>
> There was a similar class at both Iowa State and University of MN. You
> learned a half-dozen languages in a single quarter.  IIRC, at ISU we
> did Lisp, Prolog, APL, Snobol and a couple others.  The main
> pedagogical language at the time was Pascal, but we also learned
> FORTRAN, COBOL, BASIC, and a couple three assembly languages (PDP-11,
> VAX, Z80, 6502).  If you were a computer enineering major instead of
> computer science, you also leared a hardware description language.  At
> the time it was AHPL.

These survey of PLs courses are a travesty.
At best students learn nothing
At worst they imagine they learnt something.
IMHO if you dont get some feel for the language, something about its 'zen',
you should not be allowed to say you know anything about it.
Getting a grade for it ensures the exact opposite.

[I recently heard of a course whose exam papers had questions like:
"Name 7 keywords in C++
]


Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

beliavsky
In reply to this post by Marko Rauhamaa
On Sunday, May 10, 2015 at 9:38:38 PM UTC-4, Ian wrote:

> On Sun, May 10, 2015 at 3:16 PM, Marko Rauhamaa <marko at pacujo.net> wrote:
> > Scheme is my favorite language. I think, however, it is a pretty
> > advanced language and requires a pretty solid basis in programming and
> > computer science.
> >
> > Python, in contrast, is a great introductory programming language. Sure,
> > you *can* get quite advanced with it, too, but you can get quite a bit
> > of fun stuff done with just the basics.
>
> MIT famously used Scheme in their introductory course for more than
> two decades. Although they switched to Python a few years ago, I don't
> think they did so because there was anything wrong with Scheme.
> Wikipedia informs me that Yale and Grinnell are still using Scheme for
> their introductory courses.

Yale has taken the unusual step of outsourcing its introductory CS class to Harvard, which uses C as the main language in its CS50 class.

http://yaledailynews.com/blog/2014/11/07/faculty-approve-cs50-for-yale/
Faculty approve CS50 for Yale

"Just under a month after announcing that Yale's computer science department was considering importing Harvard's most popular course, faculty voted to bring CS50 to Yale.

Following what Yale College Dean Jonathan Holloway described as a "long, healthy discussion," faculty at Thursday's monthly meeting voted overwhelmingly to approve CS50 as a class to be taught at Yale. Computer science department chair Joan Feigenbaum said that the next step for CS50 will be for Harvard to approve the sharing of CS50 with Yale. If the course earns approval, she noted, Yale will formally introduce the class in Fall 2015."



Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

Steven D'Aprano-11
On Tue, 12 May 2015 05:01 am, beliavsky at aol.com wrote:

> Yale has taken the unusual step of outsourcing its introductory CS class
> to Harvard, which uses C as the main language in its CS50 class.

And another generation of new programmers will be irreversibly damaged by
exposure to C...


--
Steven



Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

Michael Torrie
On 05/11/2015 08:04 PM, Steven D'Aprano wrote:
> On Tue, 12 May 2015 05:01 am, beliavsky at aol.com wrote:
>
>> Yale has taken the unusual step of outsourcing its introductory CS class
>> to Harvard, which uses C as the main language in its CS50 class.
>
> And another generation of new programmers will be irreversibly damaged by
> exposure to C...

How so?  Surely starting at first principles of a computer's operation
can't be all that bad.  In my program at uni, one of the very first
level courses was actually to build a simulated CPU from logic gates and
then program it in assembly.  C is just a step up from there.  I should
note they also had Java in the first year, and that certainly caused
irreversible damage.

The wonderfulness of LISP and Python can be appreciated just fine with a
solid background in how Von Neumann architecture actually functions. In
fact I appreciate the layers of abstraction even more after I understand
them.



Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

Rustom Mody
In reply to this post by Steven D'Aprano-11
On Tuesday, May 12, 2015 at 10:34:32 AM UTC+5:30, Michael Torrie wrote:

> On 05/11/2015 08:04 PM, Steven D'Aprano wrote:
> > On Tue, 12 May 2015 05:01 am, beliavsky wrote:
> >
> >> Yale has taken the unusual step of outsourcing its introductory CS class
> >> to Harvard, which uses C as the main language in its CS50 class.
> >
> > And another generation of new programmers will be irreversibly damaged by
> > exposure to C...
>
> How so?  Surely starting at first principles of a computer's operation
> can't be all that bad.  In my program at uni, one of the very first
> level courses was actually to build a simulated CPU from logic gates and
> then program it in assembly.

Thats true.
The intro to programming course needs to convey something beyond syntax
and minor details -- something like the 'Zen'

The difference between C/Lisp (I club them together) and python is that
the former are more heroic.

Like mountain climbing you can get a high, a thrill, even 'see God'? but
you can also break your back or worse.

Python is by contrast like a walk in the park.  If you find it interesting
(for reasons outside of python) you can get the job done. No epiphanies here

> C is just a step up from there.

which may be a step too much.
And I think its much more than one step. [How many links in the gcc toolchain?]

> I should note they also had Java in the first year, and that certainly caused
> irreversible damage.

A different question altogether.
What Joel Spolsky describes? is simply the fact that Java slides its
practitioners down the DIKW pyramid?

[My own record of the hell let lose by teaching too early C.??
The first written in 91 and rather widely cited at that time including
first edition of 'Code Complete'. Second is a toning down as I grow older!
]

To some extent good teaching can ameliorate.
Only to some extent since the whole purpose of such languages is to dumb down
programming.

[And lest pythonistas feel pleased with that, do consider whether what
Spolsky applies to Java in 2005 in 2015 applies to python]
>
> The wonderfulness of LISP and Python can be appreciated just fine with a
> solid background in how Von Neumann architecture actually functions. In
> fact I appreciate the layers of abstraction even more after I understand
> them.

modulo the law of primacy

----------------------------------------
? Eric Raymond almost literally says this:
| Lisp is worth learning for the profound enlightenment experience you will
| have when you finally get it; that experience will make you a better
| programmer for the rest of your days, even if you never actually use Lisp

? http://www.joelonsoftware.com/articles/ThePerilsofJavaSchools.html

? http://en.wikipedia.org/wiki/DIKW_Pyramid

? http://www.the-magus.in/Publications/chor.pdf
? http://blog.languager.org/2013/02/c-in-education-and-software-engineering.html


Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

Rustom Mody
On Tuesday, May 12, 2015 at 11:09:01 AM UTC+5:30, Rustom Mody wrote:

> The difference between C/Lisp (I club them together) and python is that
> the former are more heroic.
>
> Like mountain climbing you can get a high, a thrill, even 'see God'? but
> you can also break your back or worse.
>
> Python is by contrast like a walk in the park.  If you find it interesting
> (for reasons outside of python) you can get the job done. No epiphanies here

Just to be clear the "No epiphanies" is entirely positive.
Around 2002 I started teaching python.
Around the same time I started using an open editor rather than blackboard
to teach.
And for the most part python has been a trusted friend -- even if I dont
know the code I will write beforehand and the bugs and the debugging and so on.
[I remember one time getting completely screwed by regular expressions
And more recently some confusion re dunder methods. but these are the exception
 to the rule that mostly python is quite reliable.
]

The reason I am saying this (to OP):
Which language you choose may not matter too much.
But choose one you are sufficiently friendly with to start hacking with an
open editor in front of the class

Scheme?? I used scheme in the 80s -- ie before the age of projectable editor
So while *in principle* it may seem as reliable as python
In practice when I read racket today I find it far more forbidding than the PC
scheme manuals I read in the 80s

The other suggestion I would make: Use an interactive interpreter.

Even if I were using C today, I'd find a C interpreter.
And never mind that it messes up 10% of 'official' C semantics.
You'll breeze through the remaining 90% at 3? the rate

And related to that (and one reason a pure functional language is good for
pedagogy): NO PRINT statement
It may seem trivial but beginning students have a real hard writing clean
structured code.  Tabooing prints helps get there faster
And working in the interpreter makes a print-taboo a viable option


Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

Chris Angelico
On Tue, May 12, 2015 at 4:42 PM, Rustom Mody <rustompmody at gmail.com> wrote:
> And related to that (and one reason a pure functional language is good for
> pedagogy): NO PRINT statement
> It may seem trivial but beginning students have a real hard writing clean
> structured code.  Tabooing prints helps get there faster
> And working in the interpreter makes a print-taboo a viable option

I firmly disagree. Interactive work is well and good, but print (or
equivalent - console.log, log.info, werror, etc etc) is extremely
useful for learning about a larger application. You can play with
things at the terminal, but how can you find out exactly what happens
when you click this button? Ensuring that your application can be
imported, executed, and manipulated interactively, all without
breaking its primary purpose, is a LOT of extra work, and not
something I'd recommend to beginners. So learn about print, learn
about how to get info out of a running program. You'll be the better
programmer for it.

ChrisA


Reply | Threaded
Open this post in threaded view
|

Instead of deciding between Python or Lisp for a programming intro course...What about an intro course that uses *BOTH*? Good idea?

Rustom Mody
In reply to this post by Rustom Mody
On Tuesday, May 12, 2015 at 12:27:44 PM UTC+5:30, Chris Angelico wrote:
> On Tue, May 12, 2015 at 4:42 PM, Rustom Mody  wrote:
> > And related to that (and one reason a pure functional language is good for
> > pedagogy): NO PRINT statement
> > It may seem trivial but beginning students have a real hard writing clean
> > structured code.  Tabooing prints helps get there faster
> > And working in the interpreter makes a print-taboo a viable option
>
> I firmly disagree.

Yes we know that!

As it happens you also disagree with ACM's latest CS curriculum:
https://www.acm.org/education/CS2013-final-report.pdf [pg 158]
Absolute basics of CS include functional programming; among which first point
is 'effect-free programming'
[Note there is no mention or commitment to fancy functional programming
*languages*, just the principles]

> Interactive work is well and good, but print (or
> equivalent - console.log, log.info, werror, etc etc) is extremely
> useful for learning about a larger application.

You are talking phd level (or maybe graduate level)
I am talking kindergarten

> You can play with things at the terminal,

Very important to play before you grow up

> but how can you find out exactly what happens
> when you click this button? Ensuring that your application can be
> imported, executed, and manipulated interactively, all without
> breaking its primary purpose, is a LOT of extra work, and not
> something I'd recommend to beginners. So learn about print, learn
> about how to get info out of a running program. You'll be the better
> programmer for it.

Maybe you should read up on Bloom's taxonomy
[ACM curriculum follows this but simplified from 5 to 3 levels -- familiarity,
usage, assessment]

In particular wrt print: You are not distinguishing
- learning the 'what' of print (familiarity)
from
- learning the how (usage)
and most important the "when not" (assessment)



1234