Wisdom and Wonder

I am also interested in finding this out. So far, I've done a lot of teaching/training with Java but I am playing with Common Lisp and would love to see how others use it in education I always find this article[1] interesting that talks about why MIT stopped using Lisp [1] https://www.wisdomandwonder.com/link/2110/why-mit-switched-from-scheme…

> Intellisense means you barely ever need to type more than 2 characters to express your intent. Agreed Intellisense is pretty good. Not excellent - it never suggests using statements as a first option, and in unit tests I have to always type "Asser" to bring up "Assert" (using 2022 expensive version). But it pretty good. From a tooling perspective, this a positive. From a language perspective, well there are other languages that allow flow-of-thought without needing the tooling to autofill [0]. There are tradeoffs, and practically speaking you'll need to eventually look at someone else's flow of thought and expect them to understand yours. [0] https://www.wisdomandwonder.com/article/10231/if-you-like-lisp-then-yo… "...by and large, I find that the language allows me to express myself, in the language, about the things I’m dealing with. I find that a very precious property of a programming language."

MIT was already using Python by 2009[1]; I think it's been one of the "standard" teaching languages for well over a decade at this point. (By most metrics, Python became "big" in the mid-late 2000s, which is why the Python 3 transition was so painful.) [1]: https://www.wisdomandwonder.com/link/2110/why-mit-switched-from-scheme…

Even as early as 15 years ago, MIT switched from scheme to python. The reasons are detailed in an interview[1] (see HN discussion[2]): the educators belived the future of programming would be snapping pre-made libraries together instead of engineering from scratch. 1: https://www.wisdomandwonder.com/link/2110/why-mit-switched-from-scheme… 2: https://news.ycombinator.com/item?id=14167453

That says (some) implementations had macros from the beginning, though those macros were much different than what was eventually standardized in (I think) r5rs. I guess I can believe that. I don't know when Guile got macros. Philip Wadler's paper discussed and linked from here is also interesting: https://www.wisdomandwonder.com/link/1055/why-calculating-is-better-th…

reminds me of what Sussman said re MIT moving from Scheme to Python for 6.0001 > Nowadays you muck around with incomprehensible or nonexistent man pages for software you don’t know who wrote. You have to do basic science on your libraries to see how they work, trying out different inputs and seeing how the code reacts. This is a fundamentally different job, and it needed a different course. https://www.wisdomandwonder.com/link/2110/why-mit-switched-from-scheme…

Would the need for a pure terminal magit be resolved by the fact that Emacs can run in the terminal? [1] seems to have a solution to obtain a fast starting subset of Emacs and start into magit-status directly. emacs -Q -nw --load magit-init.el --eval '(progn (magit-status) (delete-other-windows)' Would this work in IDE consoles? [1] https://www.wisdomandwonder.com/article/10787/emacsorg-mode-personal-m…

If we're willing to extend the discussion to microcomputer Lisps targeting machine language, I'll repost an old comment https://news.ycombinator.com/item?id=20019592 : > There were various Z80 and MOS 6502 microcomputer Lisp implementations written back in the '80s, some commercially released at the time, some readily accessible nowadays. https://www.wisdomandwonder.com/link/3787/how-small-can-a-sc... https://groups.google.com/forum/#!topic/comp.lang.scheme/Z_2... > (There's one that I'm horribly, horribly overdue to get back to the authors about archiving on the Internet, actually. Anyone who's based in North America and happens to have the hardware and the expertise to recover data from both 5.25" and 8" floppies in some CP/M format?)

URL changed from http://www.wisdomandwonder.com/link/3409/a-history-of-bootstrapping-ik… which points to this.

AOP also encompasses techniques you can't find in CLOS/MOP. The analogues to before/after/around methods are the easiest concepts to implement and reason about, so those are what popular language extensions tend to emphasize. But if you look at the original AOP papers describing Reverse Graphics, you'll see an AOP system used to liberally restructure the control flow of the entire base program, not just augment its behavior. It was an early version of what you can see now in something like the Halide language. > I believe MIT first year CS switched to Python in part to deal with this resistance. In part. The full story is a bit more depressing: http://www.wisdomandwonder.com/link/2110/why-mit-switched-from-scheme-… Most of the other top universities that had used SICP also switched shortly after MIT.

"Would anyone happen to know why they dropped the course originally?" http://www.wisdomandwonder.com/link/2110/why-mit-switched-from-scheme-… http://danweinreb.org/blog/why-did-mit-switch-from-scheme-to-python http://mitadmissions.org/blogs/entry/the_end_of_an_era_1 http://news.ycombinator.com/item?id=530605

The termination with extreme prejudice of 6.001 suggests that some people mostly agree (http://www.wisdomandwonder.com/link/2110/why-mit-switched-from-scheme-… Certainly there's an ever increasing role for people pasting together big libraries and frameworks without a deep understanding of what goes on behind the curtains....

You might post it to a Scheme related list: http://www.wisdomandwonder.com/scheme

I've felt exactly the same way in the last few years. A complete understanding of the whole system in every detail is not so necessary for me. I just want to focus on the things I'm trying to accomplish without the need to constantly lookup API documentations and writing glue code. That's why (for my own projects) I always end up making my own tools and coding almost all the stuff I need by myself. But our culture is going in the opposite direction (http://www.wisdomandwonder.com/link/2110/why-mit-switched-from-scheme-…

http://www.wisdomandwonder.com/wordpress/wp-content/uploads/2008/05/do… http://farm1.static.flickr.com/127/321750484_ae443d5483_o.jpg

It's not (just) that python is "easier" to learn than python (which I dispute - lisp is as easy to learn as a first language as any other. Depending on the language it may be a difficult second language though). The world had also changed radically since it was introduced into the curriculum: "Costanza asked Sussman why MIT had switched away from Scheme for their introductory programming course, 6.001. This was a gem. He said that the reason that happened was because engineering in 1980 was not what it was in the mid-90s or in 2000. In 1980, good programmers spent a lot of time thinking, and then produced spare code that they thought should work. Code ran close to the metal, even Scheme — it was understandable all the way down. Like a resistor, where you could read the bands and know the power rating and the tolerance and the resistance and V=IR and that’s all there was to know. 6.001 had been conceived to teach engineers how to take small parts that they understood entirely and use simple techniques to compose them into larger things that do what you want. But programming now isn’t so much like that, said Sussman. Nowadays you muck around with incomprehensible or nonexistent man pages for software you don’t know who wrote. You have to do basic science on your libraries to see how they work, trying out different inputs and seeing how the code reacts. This is a fundamentally different job, and it needed a different course. So the good thing about the new 6.001 was that it…

"The interesting bit is that the original author's no longer feel that SICP is the right way to approach programming any more." I think it's more accurate to say that they didn't see a reason to require engineers to learn CS. The class is now completely different. Why python? Not because it's a good programming language, but because there was a library the students could call to control a robot, which was the new goal of the class, not programming. Here's the quote: You have to do basic science on your libraries to see how they work, trying out different inputs and seeing how the code reacts. This is a fundamentally different job, and it needed a different course. So the good thing about the new 6.001 was that it was robot-centered — you had to program a little robot to move around. And robots are not like resistors, behaving according to ideal functions. Wheels slip, the environment changes, etc — you have to build in robustness to the system, in a different way than the one SICP discusses. And why Python, then? Well, said Sussman, it probably just had a library already implemented for the robotics interface, that was all. https://www.wisdomandwonder.com/link/2110/why-mit-switched-from-scheme…

The impression I get is that many people want to be system designers stringing together pieces to create systems to solve problems (part of the motivation might be that it is easier to extract economic value from such integrated solutions, rather than better functioning pieces). The problem is that in an immature field that's still evolving, the components are not yet well-understood or well-designed, so available abstractions are all leaky. However, modern software engineering is mostly built on the ability to abstract away enormous complexity behind libraries, so that a developer who is plumbing/composing them together can ignore a lot of details [1]. People with that background now expect similarly effective abstractions for machine learning, but the truth is that machine learning is simply NOT at that level of maturity, and might take decades to get there. It is the price you pay for the thrill of working in a nascent field doing something genuinely uncharted. "Math in machine learning" is a bit of a red herring. We hear the same complaints about putting in effort to grok ideas in functional programming, thinking about hardware/physics details, understanding the effects of software on human systems [2], etc. Fundamentally, I think a lot of people have not developed the skill to fluidly move between different levels of abstraction, and a variety of approximately correct models. And to be fair, it seems like most of software engineering is basically blind to this, so one…

> Go began with Robert Griesemer, Rob Pike, and Ken Thompson. “What should a modern programming language look like” (the story goes as they were waiting for some C++ to compile). Cute. Nice to keep a dig[1] going. Since that horse has been kicked quite a few times over the years, how about those in the Go community address these language criticisms: http://yager.io/programming/go.html For specific examples from the aforementioned link: The "correct" way to build generic data structures in Go is to cast things to the top type and then put them in the data structure. This is how Java used to work, circa 2004. And: Go has the null pointer (nil). I consider it a shame whenever a new language, tabula rasa, chooses to re-implement this unnecessary bug-inducing feature. Of which the latter has been regretted by its inventor[2] for years. 1 - "[C++] certainly has its good points. But by and large I think it's a bad language." (source: https://en.wikiquote.org/wiki/Ken_Thompson) 2 - http://www.wisdomandwonder.com/link/2015/tony-hoare-sorry-for-inventin…

I suggest you read the reasons that MIT switched: https://www.wisdomandwonder.com/link/2110/why-mit-switched-from-scheme… and https://www.johndcook.com/blog/2009/03/26/mit-replaces-scheme-with-pyt… and https://vimeo.com/151465912#t=3577s As to being 'near impossible' to teach SICP with Python: https://web.archive.org/web/20210916151732/https://doc-04-5g-docs.goog…

Sugar missed the boat on JavaScript. Python seemed like a good idea at the time, in the days before Python 3, with its rich ecosystem of extension modules and extensible applications and framework integrations and web application servers, especially because it was so widely used educationally (and on the way to replacing Scheme at MIT and other schools); while JavaScript hadn't quite made its ascendency yet. MIT replaces Scheme with Python https://www.johndcook.com/blog/2009/03/26/mit-replaces-scheme-with-pyt… Why MIT Switched from Scheme to Python (2009) (wisdomandwonder.com) https://news.ycombinator.com/item?id=14167453 https://www.wisdomandwonder.com/link/2110/why-mit-switched-from-scheme… Sugar's plan was for Python programs to access web functionality and integrate dynamic html and JavaScript via the xulrunner Python extension. But in the end, the xulrunner Python extension was not well supported, was extremely complex, and had lots of overhead. https://developer.mozilla.org/en-US/docs/Archive/Mozilla/XULRunner/Bui… And xulrunner itself turned out to be poorly supported by Mozilla, and never became popular, feature-rich, and well maintained like Electron. https://developer.mozilla.org/en-US/docs/Archive/Mozilla/XULRunner/Hal… Sugar was build on top of the Cairo graphics library, like xulrunner (Mozilla/Gecko/Firefox) and GTK were, so at least they shared the same 2D rendering library. Cairo (the moral equivalent…