Why MIT switched from Scheme to Python

Post by tlb » Tue, Mar 24, 2009, 11:09 PM UTC

palish wrote: post #36

tlb wrote: post #28

Earlier quoted context omitted.

Yes, I use PyOpenGL in GTK (with GTKGLExt). People have said good things about Gazebo, but I haven't used it. Most of the 3D stuff is performance-critical, so I typically prototype in Python and then convert to C++, which for graphics code isn't too painful. The Boost.Python interface makes it pretty easy. Also, the Cairo graphics interface is wonderful for drawing charts, animated robot stick figures, and many other…

Nice. Yeah, the GL graphics code is pretty easy to convert to C++ when performance matters. It's wonderful to quickly prototype graphics code in Python with full error checking. Also, if you haven't used it yet, check out Py++. It takes a lot of the pain out of hand-authoring a Boost.Python code file. I'm using Py++ to automatically generate Boost.Python bindings for the C++ library FCollada. (FCollada is a library f…

Post by irrelative » Tue, Mar 24, 2009, 11:27 PM UTC

bk wrote: post #24

abstractbill wrote: post #21

Earlier quoted context omitted.

Yeah, I think I actually agree with the overall point. I got my first experience of programming using BASIC to get various Sinclair computers to paint stuff on the screen and make funny beeping noises. I'm all for instant gratification. On the other hand that was when I was 9. By 12 I was learning Lisp, and by college age I'd written my own little Lisp compiler. I've always had this image of MIT students that doesn't…

> I've always had this image of MIT students that doesn't quite mesh with them needing a gentle introduction to programming, but maybe that's not really the case? If it leads to more (non-CS) students taking a programming class, I'd call it a big win. Other fields can benefit greatly from programming skills. I'd almost go as far as calling it a new form of literacy.

Post by mattjones » Tue, Mar 24, 2009, 11:32 PM UTC

tlb wrote: post #19

stcredzero wrote: post #14

Earlier quoted context omitted.

My concern is that "practicality" is often just a code word for "resembles Java or whatever else I was comfortable with so I can continue on doing what I've always done before." (With the result that the student learns less than if they were required to do something truly different.) Reminds me of this post that came up on HN not too long ago: http://funcall.blogspot.com/2009/03/not-lisp-again.html

I think here, "practicality" means "has a library for controlling robots". Also a good numeric library, a good matlab-like graphing library, good 3D graphics, good real-time performance, easy C++ embedding, etc. Rather than complaining about how everyone else is a bonehead for not using Lisp, write some libraries to make it useful for more things in the real world. Also, Python does pretty well for real-time control.…

  h = {}
  h[:foo] = "hi"
  h[:foo] #=> "hi"
  h[:bar] #=> nil

  (define h (make-hash-table))
  (hash-table-set! h 'foo "hi")
  (hash-table-ref h 'foo) ;; "hi"
  (hash-table-ref/default h 'bar #f) ;; #f

Post by newt0311 » Tue, Mar 24, 2009, 11:45 PM UTC

jules wrote: post #10

trjordan wrote: post #3

I think there's something else here, implicit in Sussman's comment, that's important. MIT was founded on a philosophy of practicality, and everything else is secondary. If you couple that with the belief that fundamental computer science is the most efficient way to enhance practical software engineering, Scheme was a wonderful choice. Java and C++ may have been more directly practical to software engineers, but they…

> If you can convey 95% of the basic ideas in Python But you cannot. Some of the ideas in SICP can nearly be conveyed in Python (like lexical scoping, closures, data types, streams). You'll use built-in language features in Python (classes, generators) instead of implementing the functionality. I think that implementing these things is important if you want to really understand them. An example, cons, car and cdr fro…

    >>> def cons(a, b):
    ...  def lm(f):
    ...   return f(a, b)
    ...  return lm
    ... 
    >>> def car(cns):
    ...  return cns(lambda a, b: a)
    ... 
    >>> def cdr(cns):
    ...  return cns(lambda a, b: b)
    ... 
    >>> x = cons(1, 2)
    >>> car(x)
    1
    >>> cdr(x)
    2

Post by jerf » Tue, Mar 24, 2009, 11:57 PM UTC

silentbicycle wrote: post #38

jerf wrote: post #7

Earlier quoted context omitted.

Python may not be a scheme, but it does have what they used to call functional programming, low-grade continuations with the generators, and some other stuff like that. Python may not stuff its academic credentials in your face, but I think it has one of the better balances between what you can use it to teach, and what you must teach to use it. (Referencing the common and IMHO justified complaint that the simplest p…

Python has some issues that can really interfere with doing Scheme-style FP in in it (no tail-call optimization, single-expression-only lambdas, closure/scope problems, general hostility from Guido), but IMHO it's a great general-purpose language, and well suited to teaching, particularly for introducing higher-order functions. Lua has much more Scheme influence than Python does (while being otherwise pretty similar)…