Hacker News new | comments | show | ask | jobs | submit login

As much as I love racket/scheme/lisp, I truly believe that the 61A (sans-s) where python is taught, helped me much more for my career/future just because it was taught in python. For programming fundamentals, either works great, but I think working with python is more helpful for future environments.

One example of this is when a classmate of mine was taking an artificial intelligence class at Berkeley (Cog Sci 131) and was at a loss because she was taking 61as which was taught in strictly scheme, and the artificial intelligence class was taught in strictly python.

Both classes are wonderful and I can proudly say that it has made me a better computer scientist. http://cs61a.org/

I don't understand this mindset. You only have 4 years to learn whatever they teach in college, compared with 40+ years if you go into industry. To me, the value of my CS degree was the exposure to a breadth of important ideas across the entire field of computing—thing that I would never have the luxury of exploring while under a deadline. None of the particular tools and workflows I used in college were of any meaningful value after 6 months in industry where the workflows are invariably more sophisticated to cope with the messy nature of long-lived real-world projects.

My CS program was taught in Scheme (the version that's now Racket), and I think I kind of understand it. Shortly after graduation I felt like I had this gap in my resume due to spending all this time learning a language that nobody uses in industry instead of something marketable like Java.

Nowadays, though, I feel like my time spent getting used to functional programming in school has given me a secret weapon. It's something much more subtle than the ability to bandy about obscure words that probably start with M. I really do think I'm just fundamentally better at dealing with abstraction, both using it and creating it, than my peers who haven't had such an experience. And that's not small beans considering that, to an approximation, working with abstractions is what I do all day every day.

I've done the exact opposite having learned industry standard languages my entire career and only after many years finally gaining a much deeper understanding of computer science (and especially functional programming).

I can say without a doubt that having functional programming knowledge first would have been a phenomenal advantage.

I think the grass is always greener on the other side. I started with SICP in Scheme (Racket) in high school (our teacher had taught at Berkeley over the summer, I think). I don't feel any special reverence for Scheme, and don't particularly feel either way about functional programming. It's just another tool in the toolbox and I don't feel like my smart peers who started with Python are at any disadvantage whatsoever.

I do think that another major advantage for Python is the fact that you can do cooler things with it, faster. CS has a serious funnel problem and the quicker we can get students to do cool things with CS (GUI stuff, web stuff), the better CS education will be.

> do cool things with CS (GUI stuff, web stuff), the better CS education will be

The issue is these skills don't solve serious or interesting problems. GUI and web programming have become easier than ever and requires less programmers on staff to perform. My company can't find enough qualified engineers with a good depth of knowledge in CS.

I've found functional concepts have been incredibly important in shipping maintainable code on the JVM using both Java 8 and Scala.

We're discussing what freshmen in CS should be learning, not what sophomores/juniors/seniors should be learning. Getting people hooked on cool, albeit superficial, things they can build is the right way to get a broader range of people interested in CS (as opposed to just people who started programming before coming to college).

I too took CS61AS in scheme and AI in python, but my experience was different than that of your friend. I didn't find it difficult to pick up python, and learning it after scheme made me appreciate python all the more.

Unless one plans on developing mostly in python during his or her career, I think its beneficial to be forced to learn multiple languages.

I've found that each incremental language I've learned typically improves my ability to write code in the languages I already 'knew'

It is definitely beneficial to learn multiple languages. I felt bad for my friend because she had taken the two concurrently.

> As much as I love racket/scheme/lisp, I truly believe that the 61A (sans-s) where python is taught, helped me much more for my career/future just because it was taught in python.

It's not what you learned that's the problem, it's what you didn't. You almost certainly missed out on things that you could very well never see again, or even know the existence of (at least for a very long time) unless you were motivated enough to go discovering stuff by yourself.

Did you ever learn about macros in Python? I doubt it, because they don't exist. Did you get introduced to metaprogramming -- the idea that you can write programs that generate more powerful programs? I doubt it, because it's hard to do that in Python. But The old 61A, which used Scheme, did just that. They added an OOP system --- yes, that's classes, inheritance, methods, constructors, etc. --- to a language that never had one, and they even taught you the basics of how it was done. [1]

This is something you can't even dream of doing in most (all?) languages that aren't dialects of LISP. You won't even realize it's a possibility, unless someone teaches it to you or unless you're lucky enough to stumble across it and realize its importance.

i.e., you won't know what you're missing out on.

Whereas with Python, there's not much you're missing out on: there are a ton of languages like it that you're bound to see them later in industry, if not Python itself, and learn what you would have learned anyway.

[1] http://www-inst.eecs.berkeley.edu/~cs61a/reader/belowline.pd...

2 cents from someone who took CS61A in scheme and had a hand in creating the new python version of the course and subsequently was a TA for the class for a few semesters on this debate:

In any class of reasonable difficulty/usefulness, there will be students who do great, ones that do okay, and ones that struggle. What we should aim to do as the very first intro course is to help as many of those people from all of those groups to do as well as possible in their future classes/careers.

For the great students, I actually believe we did them a disservice. CS61A in scheme was truly beautiful. It was amazing, given how simple the language was, how much you could achieve. All pieces of the puzzle fit together perfectly. Trying to do the course in python, on the other hand, we had to compromise a little bit. We didn't want to just teach the exact same content in a different language. We wanted to teach the "Pythononic" way of doing things. To give a few examples: - The first 1/3 of CS61A in scheme had no mutation. That is almost impossible in Python to do, and is not the way the language is used in industry. I personally believe functional programming and immutability is The-Way to program, so I see this as a huge loss. - We teach recursive lists (linked lists) in order to teach recursion, but I feel like having both the default Python mutable lists (which are array lists) and linked lists is confusing to students, since we do not teach their performance tradeoffs (that is in 61B). - Mutual recursion was almost useless to teach. Where it was most commonly used in Scheme, you achieve the similar thing using list comprehensions in Python (the language feature essentially took away your need to construct the list in a recursive fashion). - The very interesting bits of the old class about metacircular evaluators, we simply could not do in Python. - Python also has tons of quirks (magic methods, for instance) and lost some of the elegance we saw in scheme.

But for the okay and struggling students - 70-80 percentile and below, the students who understand most of the material, but perhaps fail to grasp some of the more complex concepts - I think Python was the correct way to go for a few reasons: - It is a much more commonly used language. It sets you up to go for internships, research, hackathons, whatever you please, straight from what you learned in class. - The language is way more similar to Java, which allows students to translate what they learned easier to the next course in the series, CS61B. - 80% of the material hasn't changed but you've gained the above benefits. Remember, we are talking about students who probably would have struggled to grasp those last 20% anyway (maybe they are completely new to programming and they already have their hands full with the 80% to begin with).

I think therein lies the difference in opinion. If you took CS61A in scheme and understood it very well, then you don't understand the change. If you understood the intricacies of what was taught in CS61A, you will find it very easy to generalize those concepts to new languages - and new concepts. In fact, you will find that much of what you learn in the rest of your undergrad career will be "CS61A review". However, for students who may not have had the CS maturity or time to grasp all the concepts, they find that the Python course is much more useful.

How is it that python is less amenable to functional programing? (Functional in the sense of referential transparency and immutable data-structures, rather than map-filter-fold). Through my limited exposure to python, I agree that immutability isn't idiomatic python, but I don't think there's anything stopping you from implementing those ideas in any language.

(A Berkeley student who went to Aki's sections -- Hi!)

One thing I've seen is that when you're first learning a langauge and pick up bad habits, they can be really hard to break. I've heard lots of students talk about the problem this causes when interviewing, especially early on. Additionally, for languages like Python, where there is loads of (often excellent) support online it can be confusing/frustrating to have a class teach one method and find answers which are mostly unrelated.

That said, I agree with what was said. Scheme is pretty amazing :)

The question you should have asked is "how is it that [idiomatic] python is less amenable to functional programming?", which you basically answer yourself. Otherwise, I can't see how amatsukawa implied Python itself was less amenable.

What is stopping you from implementing those ideas in Python during a first-semester course in CS is that you will not serve your students, as amatsukawa described.

"The first 1/3 of CS61A in scheme had no mutation. That is almost impossible in Python to do..."

Pretty unambiguous to me. GP had a very thoughtful reply to be clear.

If the desire was to teach idiomatic python, that's totally legitimate. But the decision to whether or not teach FP concepts is in no way constrained by the choice of language.

I took 61A in python and loved it too. I do a lot of personal projects in django/flask now too, something I probably wouldn't really have thought of before.

Applications are open for YC Winter 2018

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | DMCA | Apply to YC | Contact