AngelList | ONSITE (San Francisco) | Full Time | Product Engineering (Full Stack, Rails, React)
AngelList is hiring full stack software engineers who want to make technical _and_ business decisions. This role will work on software products used by companies to raise capital and manage their investors (https://www.angellist.com/startups/equity)
AngelList is the nexus of venture capital and the startup community. We support over $16B in assets under administration. We’ve driven capital to over 22,000 startups. 57% of top-tier U.S. VC deals involve investors on AngelList
I lived in the building for a while and there is a bit of subtle ramp into the building but it's not quite a 1.5 foot drop because the direction (Try looking at Google Street View from before 2020 at 350 Mission St and 399 Mission St)
I used to spend a lot of time thinking about this while helping build software & TA'ing for Berkeley's introductory course (which uses Python & Scheme) and I largely agree with the author. If you're wondering why the author ignores large schools, it's because they have the resources to invest in this. Here's a sample of the things the efforts that Berkeley did for their introductory course [1]
* Online tools to run & visualize code execution directly from the online textbook (ex: https://composingprograms.com/pages/16-higher-order-function...)
* Easy submission for students (no git in CS1, no scp, no printing)
* Instructor autograding for all assignments so the course staff could focus on reviewing code for style/other components.
* Automatically backing up student code
* In some assignments, there were automated hints for syntax, styling, and even correctness [2, 3]
* Online collaborative editing for partner assignments [4]
* Full time staff allocated to building teaching infrastructure to "reduce accidental complexities when using code to solve problems"
* Completely hosted environments (via Jupyter Notebooks or Scratch) for courses with a lot of non-majors.
I still prefer to setup ngrok because it allows me to view and replay requests. If the stripe cli supported that, then I'd move to use the cli entirely
Yeah that's true, another upside to ngrok is it works for not just Stripe. Sometimes you need to link up with multiple payment gateways and listen for webhooks from 1 of them at a time.
This is the textbook used for the introductory CS course (CS61A) at UC Berkeley. The course material is available at http://cs61a.org/fa18 (The course uses Python 3, Scheme, and SQL).
There are some neat projects (students build a Scheme interpreter and implement game logic as part of the projects)
Previous Hacker News Discussions (from which I’ve copied my comment)
Thanks for linking this, I'm currently working on designing an introductory python course. What background are students expected to have for CS61A? Is it expected to be students first introduction to python?
This is the textbook used for the introductory CS course (CS61A) at Berkeley. The course material is available at http://cs61a.org (The course uses Python 3, Scheme, and SQL). There are some neat projects (students are working on building a Scheme interpreter now)
Given Python's limited lambda implementation and Guido's distaste for FP I find it odd that Python should be chosen to teach SICP let alone replace Scheme as a teaching language.
There's a lot of pressure to teach languages that are widely used in industry, which is why so many students come out of university knowing mostly Java. There's also a lot of bias against "old" languages, and for newer, trendy languages.
Teaching SICP in Python is just a further development of that trend.
Software engineering is a very trend-following, path of least resistance, bandwagon-jumping profession. If "everyone" is using language X, that's where most engineers (and managers) want to be. Universities are just satisfying that need.
It's a wonder that Scheme lasted in universities as long as it did. It'll be interesting to see how long Python lasts.
There's always Clojure. Best of both worlds, i.e. Scheme-ish with Java host. We had a SICP Clojure group here in London last year and I think someone has written an adaptation of SICP in Clojure. If it was any other text I'd have nothing to say but SICP without the Scheme/Lisp doesn't make sense. If universities choosing Python or Java as their teaching language they should also switch to texts based on OOP.
Why doesn't it make sense without any LISP? I read only the first chapters and found the concept of composition immediately applicable in C and as a C programmer I would write the same way in python, probably.
Remember, all of those "old" languages, when they became notable or influential, were younger than Python is now.
Scheme, when SICP was written, was only 15 years old. It was young and trendy at the time.
C was less than 20 years old when I learned is as part of a required course for my CS degree. I've no doubt that part of the reason was that it was widely used in industry.
C++ was the trendy thing by the time I left school. It was less than 10 years old.
Perl was 10-15 years old when it was used as the "Swiss Army chainsaw" for a lot of the first era of web development.
While this appears to solidify your observation that software engineering is very trend-following, I listed them to point out that Python seems to be the oldest language when it made the jump. It's surely older than most of the students and even TAs for the course.
Python has been a common teaching language for at least a decade now, it's just that this particular course has now switched to it as well. Still took 15 years for it to get that momentum, though.
You won't see a CS course taught in Go or Rust anytime soon.
Lambdas are anonymous functions so an inner def is not the same thing. The fact that you have to "adapt" Python to get non-crippled lambdas suggests it should have been the last choice for teaching a text like SICP.
The reason lambdas are powerful -- one of the only reasons -- is because it's a closure. The fact that you can reference variables outside of the function is the power, not whether it has a name. A label is just a convenience. (Or in this case, an inconvenience.)
If my understanding is flawed, I'd like it to be corrected, though.
Higher-order functions (funargs) do not equal first-class functions (lambdas). It happens to be that any language which supports first-class function must also support higher-order functions, but the reverse is not necessarily true.
That does not match my understanding of first class functions, nor Wikipedia's.[1] Python's inner defs are not anonymous functions (which is what people usually mean by lambdas) but they are definitely first class - they can be returned from a function, stored in a data structure and so on. I agree with the grandparent that the need to label the closure is just an inconvenience, not a disqualification.
You can't have anonymous lambdas that aren't first class (how would you reference them?) but you can have first class functions that are not technically anonymous.
From TFWikipedia: "Some programming language theorists require support for anonymous functions (function literals) as well."
I suppose I wasn't aware that that wasn't a universal requirement, but count me in with that group. I think it's useful to make a distinction between "higher-order" and "first-class" for this very reason (i.e., we can talk about languages that do make a distinction without resorting to overloaded terms).
I mean, consider a language where this is the case:
> "hello," .. " world"
==> "hello, world"
> 2 + 2
==> SYNTAX ERROR
> def a = 2
==> #<number "a">
> a + a
==> 4
Would you consider such a language to have first-class integers?
Sort of on a tangent, but while I'm reminded of it: as far as Python's "lambdas" go, they're brutally gimped compared to Python's notion of a function, since what is allowed (and even required) of a function body in Python is much different than what is allowed of a "lambda" body.
> Would you consider such a language to have first-class integers?
Yes, I still would, because integers can be bound to variables, passed to and returned from functions, and stored in fields of objects.
I would think that the language had a silly syntactic restriction -- which is the same thing I think about Python -- but it wouldn't materially change how I would write programs. It's just that, before any expression using an integer literal, I would have to name the literal.
Well, same here. If you want to use a function too complicated to fit in Python's restricted lambda expression syntax, you have to use a named local function. I agree that it's silly, and I'd never design a language like that myself, but again it wouldn't materially change how I write programs -- it just means that what would have fit in one expression would now, in some cases, require multiple statements.
Trying to draw a fine distinction between "higher-order" and "supporting first-class functions" doesn't appeal to me; I think of the latter as the definition of the former. (I'm sure I would have trouble remembering which was supposed to be which.)
But again, I have no problem with criticizing the design decision -- just not using these terms :-)
Here's the thing, though: when some element of a language is subject to silly restrictions that other first-class elements of the language are not subject to, that element is, by definition, second-class. The reason being that you can't treat it the way you'd treat any other first-class element.
I see where you're coming from, but still, after the function value is created, there's no restriction on its use. Contrast what some call second-class continuations, which can be invoked only once -- a much more severe restriction.
I could see saying something like, Python functions are semantically first-class but syntactically second-class. Or maybe we should just call them "business-class" :-)
(BTW your comment downthread about referential transparency is spot-on.)
And I also see (now) where you're coming from. But it's hard for me to accept the "once the value has been created" exception, because in my mind the construction of a value is as important as any other operation on that value.
Anyway, I'm not going to argue this any further -- I think we understand each other's perspective and we can pretty much resolve to chalk this one up to the (rather unfortunate, imo) lack of precision that's so common to terminology in computation science (see also: any debate whatsoever about types ;) ).
It's no secret that Guido has a little bit of a distaste for functional paradigms. From the man himself:
"About 12 years ago, Python aquired lambda, reduce(), filter() and map(), courtesy of (I believe) a Lisp hacker who missed them and submitted working patches. But, despite of the PR value, I think these features should be cut from Python 3000."
> This is the textbook used for the introductory CS course (CS61A) at Berkeley. The course material is available at http://cs61a.org (The course uses Python 3, Scheme, and SQL). There are some neat projects (students are working on building a Scheme interpreter now)
I'm a seasoned programmer, who after years in the industry really enjoyed SICP once I discovered it. I found it very nicely put together in the sense that it managed to teach a simple LISP and handle programming in a deeper and more academical/sciency way, and not just the regular "here's how you make a blog with whateverDB".
I'm currently looking into expanding my very basic Python knowledge, and are looking for books/courses on the subject.
Would you say this course here is good for learning Python, or would you rather recommend something else to experienced programmers?
Picking up the language, vs picking up what is idiomatic code, what is where in the standard library, which third party tools/libraries are common to use, etc are widely different things though.
This is a general programming intro course that happens to just use Python, I don't know from where do you get idea that it will make emphasis about the python ecosystem. Will it make you a better Python programmer? probably, but you won't gain much if you already really did SICP. And since you are "seasoned" programmer you will have to deal with all the what is a variable, what is function etc.. all over again.
If you are interested in the technical details of CPython, the author posted a mini course on technical details about CPython here:
http://pgbovine.net/cpython-internals.htm
i should do a much better job consolidating and advertising all of these resources, but time is never on my side :) so i figure that i'll just keep putting more stuff up and let google figure it out for now.
Yes, recursion is an extremely challenging topic for novices. Beware of the expert blind spot, in which experts such as yourself drastically underestimate how difficult concepts are for novices to learn:
reply