You got that right, if you cache your fibonacci procedure, the additional "cost" of recursion vs iteration is very low. Just the cost of the recursive function calls, and additional lookups in the dictionary (instead of swapping a couple of variables). So iteration is still slightly better in this case, but cached recursion would be far from timing out on fibonacci (36).

Generally, I find it more "natural" to use recursion, so for the sake of readability (understanding), and as long as bleeding-edge performance is of no concern, recursion does it for me.

I've found that recursion is good for understanding and solving problems but generally do not use it in production code. The cost of recursion can be high as shown in the Fibonacci example and will tend to make your code more brittle. By brittle I mean that small changes to your code may cause unexpected results (e.g. due to a larger input loop value being passed to a recursive routine.) Of course YMMV.

That is a question, also, of readability vs. speed. Particularily when you get into tree structures and divide-and-conquer algorithms (Of wich quicksort is one), there are a lot of algorithms and ideas that are very naturally expressed as a recursive process, easily written and read that way. They can be converted to an iterative format, but that means you have to twist it a bit inside out. That makes for more complex and non-intuitive code - Bigger chance of bugs. In that case, the iterative code might reasonably be called more brittle :-)

But that is the eternal tradeoff - Readability vs Clever code, and also Time vs. Space, as we do in the memoize thingy. There, we win speed by sacrificing space (we build a honkin' great dictionary).

Production code? That is a process - It would not be unheard of to write a working prototype in an as clear and straightforward style as possible, and then go rewriting particular functions that are deemed critical unteil the whole thing is good enough.

We answered this question in office hours.

There are no plans to share the code externally. Homework 6 will tell you the input you failed on. Homework 6 Starred questions (which will be more visibly separate) will tell you how many test cases you pass. The plan is to eventually use the output format from the starred questions for every unit quiz/homework.

Awesome upgrade! Will the result (how many/which test cases were passed/not passed) be immediate or only visible after due date? For multiple coice I understand it makes no sense to give away any clues. But for more and more complex code, it would be of great help to know right away, to fix code for those cases; I don't think that's giving too much away.

Only after the due date. To do it before the due date requires a fundamental change in how all the backend elements communicate, i.e. a lot of work. This is something I've put together on my own without support from engineering.

You're da man! It still helps, though. Good job.

To add to this, also, will we be given more time than a week to complete the final exam? As, I guess many of us may be university and school students and might have their semester/final exams coming up during April!
It would be great if you could give us some more time to complete the final exam if possible! Thank You!

P.S.: I have 5 final exams in my university during the final week of this course! I have no idea how I will write the final exam of this course! Its close to impossible! :(

The way I see it, we're learning basics of computer science here, not fancy-pantsy aspects of a particular programming language. For those basics, differences in Python version shouldn't matter at all. Like, we're not going to build a search engine that can really compete with Google & co., but as a means to an end, it can help understand possible applications of the basics of CS. Else it would be too abstract for many, probably including myself! =)

The differences aren't that big, but do break compatibility. What you learn applies very well to Python 3 and most other programming languages.

Probably the single biggest one is that many of the statements were turned into functions. So "print" isn't special anymore and you have to say print('hi') and not print 'hi'.

Going forward more and more people will use Python 3, but the fact of the matter is that most of industry uses Python 2.x and that will be true for a while.

Guido Von Rossum (the creator of Python) said that Python 3 is the future, but he encourages to learn Python 2.x because, like Peter said, most of the industry uses it. One of the reasons of this, is that most libraries were written in Python 2.x; although they have a while now making the transition to Python 3.

Almost 8: http://bit.ly/HhZzI1

Technically undergrad, but soon to be grad: http://www.cs.virginia.edu/~pmc8p/

Yeah, and good luck with that!

good luck... you look like a high school kid thats why was asking.. @peterudacity take that as a complement...:)

It's probably part of his plans for world domination, to look..."innocent!" =)

I'm used to it. During the grad school visits I got the high school confusion a couple times.

Good job, Peter! Keep up the good work, man. Looks to me like you have a bright future.

(just don't let your changes to the autograder bork my HW ;)

good job young man.. keep it it up.. I see you are already accomplished in your own rights...:)

Back when it was still relevant, I'd always say, "It's not the years, but the miles..."

We talked about this for a bit in office hours.

Python is only partially programmed in Python itself. Many core functions are programmed in the "C" language, for matters of speed. Therefore an "inspect" for core functions would be very difficult to realise. And it would only help you if you also were fluent in C...

You can view the disassembly of functions by importing dis and then calling dis.dis(funcname). However, the result isn't Python -- it's Python bytecode (and may very well consist of just a call to C). However, it's still fascinating to look at and you could learn to read it just like any other language.

At the Python website you can download the source code for Python. It's a bit difficult to look through but it's doable. I've done it for a few quizzes and homeworks to adapt some more complex code for the grading.

Peter, that is hardcore. I bow.

Whilst debugging some Python (using the interpreter's debugger) a while back I accidentally 'entered' a random.randint call and found myself inside the 'random' library, looking at the code for randint, choice, etc. Felt weird, like I'd seen the Wizard of Oz behind the curtain, but kinda powerful too!

We talked about this in office hours.

We answered this in office hours.