Matthias Felleisen

I'd also check out HtDP [0] or the similar two-book set on problem solving and program design by Marco T. Morazán [1]. They both come from the Racket school of pedagogy and focus on systematic program design [2]. The first resource is free and excellent, but the second goes into more detail. [0] https://htdp.org/2024-11-6/Book/index.html [1] https://www.amazon.com/stores/author/B09QMPRYYM/allbooks?ccs_id=112842… [2] https://felleisen.org/matthias/Thoughts/The_Design_Recipe.html

Here is Felleisen's (who I should note is retiring) views on teaching programming at NEU, which is worth a read: https://felleisen.org/matthias/Thoughts/Developing_Developers.html

theres also a follow up book called "how to design classes" a draft versions is available here https://felleisen.org/matthias/htdc.html

And for others it goes quite quickly! There is no doubt that programming can be helped with a natural aptitude and that it won't make sense to everyone no matter how smart they are, but that is true of many fields. I'd also argue it's often a teaching problem. I'd highly recommend this essay that goes into the flaws in particular with introductory CS education: https://felleisen.org/matthias/Thoughts/Developing_Developers.html

Matthias is an awesome professor. His blog/Thoughts page has a lot of great content. https://felleisen.org/matthias/Thoughts/index.html

Shriram did an excellent job being a lively, energetic and engaging speaker who distilled some of the core concepts of the paper down without getting tangled in the formalisms. I do not have an academic background in theoretical computer science and was nevertheless able to follow along his talk perfectly well. For anyone interested in reading it, the paper by Matthias Felleisen that this talk is based on can be found on the author's website: https://felleisen.org/matthias/papers.html

IMO a couple of cool aspects of Racket that aren't called out in beginner guides, but I think are really useful in real programs: 1. The use of custodians on a per-(green-)thread basis that brings "oh yes, if the thread crashes or is shutdown, racket guarantees that all open files/sockets/resources will be shut down". For example you can use this to ensure that a timed out client doesn't cause unnecessary resource usage. https://docs.racket-lang.org/more/index.html#%28part._.Terminating_.Co… 2. Events and composable concurrency from Concurrent ML - Unlike Go's channels, concurrent ML events are composable up the stack, and have some nice things built in like "NACK events" (allowing cancellation down the stack). Unfortunately there aren't great primers about using this that I know of apart from the Kill Safe Synchronization Abstractions paper. https://users.cs.utah.edu/plt/kill-safe/ 3. Sandboxing - https://docs.racket-lang.org/reference/Sandboxed_Evaluation.html Some of these were added to make it easier for the IDE to manage errant programs that could be written by beginners, but it is also a very "applicable to production" set of tools. Racket internalizes Extra-linguistic mechanisms https://felleisen.org/matthias/manifesto/sec_intern.html Also the fact that various DSLs can inter-op with each other directly, so that you can use something like a binary parser description, as if it was just another Racket library. For example this description of the format…

> I don't care about "power" for a language construct. I need guarantees a lot more. Does using this construct allow me to put some things in the "that doesn't matter here" bin, so I can focus on some things without worrying about everything at once? Conditions and restarts aren’t much better or worse than standard exceptions in that[1] respect. You can basically implement them[2] on top of those + dynamic scope: the gist is that when an exceptional condition happens, instead of destructively unwinding the stack immediately the code only invokes a callback (selected by condition type, installed by some dynamically enclosing code), which then can choose one of the available handling strategies and unwind the stack to the requisite point (using try / throw if implementing on top of that). The fun part is that it can unwind less than to the point where the callback was installed: e.g. a REPL installs a handler that, on an undefined variable error, asks the user interactively for the value to use instead, invokes the language-provided USE-VALUE restart and proceeds; no debugger-level carnal knowledge of the language runtime is necessary at any point. (Compare also the DOS abort/retry/ignore prompt. Win32 SEH is also capable of expressing a certain degree of resumable exceptions not exposed by C++ runtime, as seen in classic VB’s On Error Resume Next—though that is admittedly a bad idea.) The advantage[3] of this construct is that it enables you to structure APIs differently,…

I know Shriram very well, he and Kathi do excellent work and as I said they are focused on more valuable projects than trying to prove one language is superior to another for CS1. They are building tools and curricula, and have done some research that sheds some light on the tradeoffs in using certain languages like Racket. Kathi's "Rainfall Accumulates" paper is one of the few papers that gets close to work in the space I am talking about. Shriram's analyses often leave me stunned at just how sharp that guy is, and helps remind me that CS Ed really needs to level up its game. That said, the HtDP curriculum that they were involved in, and led to Bootstrap and a host of their other projects, was not grounded in any kind of data collection or treated as an empirical research project. Smart people with good intentions built something and threw it into a classroom. Intentionally so, by design [1]. Their subsequent work with Pyret is much better grounded and well-informed, and I've been absolutely fascinated by it. Their data science curriculum delights me, and I have often thought that if I had more time I'd translate it to Python. I think their more recent proposal about a Table Abstract Data Type is just inspired. But we are still VERY far from ever proving things like, "Racket is easier for students to learn". I'm fairly sure it's not even worth doing. I appreciate the original article was just one student's perspective. It's a perspective I don't entirely disagree with.…

Julia combines the following: - multiple dispatch - parametricity - lightweight subtyping - staged programming In interesting ways. felleisen's class talks (partially) about it here: https://felleisen.org/matthias/4400-s20/lecture15.html I guess the best way to put it is that Julia encourages a style where 90%+ of code can go through paths that are static. Personally, I think Julia starts off as easy as python, but to get C++ or Fortran speed, you can't just code naively. Things go into a steep learning curve at that point, but perhaps there isn't yet as much know how about how to code "professional Julia" yet. There needs to be a book like Fluent Python or Effective C++ for Julia, or perhaps a condensed version of the Julia manual (see the 1 page zig manual for inspiration). The other problem I have with Julia right now is lack of static type checkers. "modern python" (e.g, python in production in the last 5 years) tends to leverage the large ecosystem of things that hook into mypy (I'm taking about tools like pydantic) to reduce the inherent brittleness of the language. Ruby, php, and every other dynamic language has also seen that trend. Right now, I've barely seen that with Julia, and it needs this badly for higher uptake in industry. It's why for example, perhaps you see a lot of Julia packages written for people's phds right now.

I'm assuming it's more in line with The Little Schemer series of books (https://felleisen.org/matthias/BTLS-index.html) or maybe the little book of deep learning (https://fleuret.org/francois/lbdl.html)?

Matthias Felleisen, architect (I think) of the current curriculum, explains to a hypothetical skeptical university administrator the virtues of it: https://felleisen.org/matthias/Thoughts/py.html

It's the philosophy behind How to Design Programs (https://htdp.org/) and Matthias' other educational works. On HtDP might be relevant to your interests (https://felleisen.org/matthias/OnHtDP/index.html)

N.b. here is a brief article[0] in which Matthias Felleisen explains the reasoning behind the CS curriculum he developed at Northeastern University. [0] https://felleisen.org/matthias/Thoughts/Developing_Developers.html

Apparently you’re not the only subordinate he’s loaded off in academia. https://felleisen.org/matthias/Thoughts/Free_Speech.html

I see that Matthias has responded and issued an apology on his website: https://felleisen.org/matthias/Thoughts/Apology.html

The link to the personal site was a byproduct of what he described as a "social experiment" in which he published the James Damore memo on his office door, and was offended that students reported him to the dean for acting to create a hostile work environment, rather than engage with him directly about the scientific merits of Damore's memo. He describes this himself here: https://felleisen.org/matthias/Thoughts/Free_Speech.html

I think those slides [0] were written on a reMarkable tablet. I wonder if this was done live with some sort of screenshare. [0]: https://felleisen.org/matthias/7480-s21/1.pdf

It's not always dots. Sometimes lines https://felleisen.org/matthias/7480-s21/2.pdf

The lecture topics is very nice, it threads a lot of known ideas that are scattered around the world (concrete or virtual) https://felleisen.org/matthias/7480-s21/lectures.html

The slides are unreadable though: https://felleisen.org/matthias/7480-s21/18.pdf

On an undated page on his personal website, Matthias Felleisen writes that a third edition is coming soon: https://felleisen.org/matthias/HtDP3e/index.html

Okay, I just checked my Northeastern application submission: GPA: 5.46/5 weighted SAT Reading and Writing: 790 SAT Math: 790 SAT Essay: 19 SAT Math II: 800 SAT Chemistry: 800 P.S: As for California, you're not going to like this: https://felleisen.org/matthias/Articles/loyalty.pdf In order to advance in academia in the UCs, you have to sign a loyalty oath supporting affirmative action!

While being a general purpose programming language, Racket is intended for Language Oriented Programming[1]. I was looking at Lisp Game Jam 2018's submissions when i stumbled on this game https://euhmeuh.itch.io/lisp-vs-blub-empire. The author made a throwaway language by wrapping Web Assembly intermediate language into racket using less than 250 lines of code[2]. This is what Racket is really about; an environment to quickly create a specific programming language for a specific problem[3]. [1] https://en.wikipedia.org/wiki/Language-oriented_programming [2] https://github.com/euhmeuh/wasm-adventure/blob/master/src/wat.rkt [3] https://felleisen.org/matthias/manifesto/

Beautiful Racket[0] is a good starting point that covers a lot of nice small examples that incrementally build up your understanding of the different components involved in making languages. And it uses Racket[1], which incorporates the idea of crafting many small "domain-specific" languages to solve different problems into its entire philosophy[2]. [0] https://beautifulracket.com/ [1] https://racket-lang.org/ [2] http://felleisen.org/matthias/manifesto/

The approach of incrementally introducing language features is what Matthias Felleisen advocates: https://felleisen.org/matthias/Thoughts/Developing_Developers.html Felleisen's argument is that all general-purpose languages are too big to be appropriate for teaching, and you should use specialized teaching languages. In Northeastern University's introductory programming class, students start with a minimal Scheme called Beginning Student Language (which has primitives, function application, if, cond, and top-level define), then move up to Intermediate Student Language (which adds local), then Intermediate Student Language with Lambda (which adds function literals). Each addition is given a motivation (locals let you avoid repeat computations, local functions let you capture the environment, lambdas let you use local functions without giving them a name). But Hedy seems to make the mistake that many curriculums do of focusing on the minutiae of syntax. Don't do that! Northeastern's course emphasizes broad concepts such as abstraction, accumulators, and generative recursion. Meanwhile, it uses simple s-expr syntax.

Oh, you think there should be an actual counterargument to the proposition that Scheme is "not a Lisp"? Well, okay. This is of course a purely semantic discussion, about the meaning of the word "Lisp" (and "Scheme", if you like). Words are defined by their community of users, and you are of course free to use them however you like, at the risk of talking nonsense and tricking yourself into logical fallacies if you adopt an inconsistent meaning, or failing to communicate if you adopt a non-mainstream meaning. So let's consider whether the mainstream meaning of the word "Lisp", that is, the usage of the word among Lisp experts, includes or excludes Scheme. This runs into the difficulty of determining who "Lisp experts" are, since that depends on what "Lisp" means; we could run into a schism like the Protestant/Catholic schism, in which each side considered themselves to be the guardians of, and experts on, the true meaning of Christianity. To avoid this problem, presumably we can all agree that at least the people who wrote the Common Lisp specification or major contributions to it, who are credited as major contributors to "Lisp" in the Common Lisp standard, and who have published well-regarded books about Common Lisp, are "Lisp experts", independent of the results of our inquiry about Scheme. (I am taking the liberty of supposing that your comment above implies that Common Lisp is a Lisp, despite its departure from traditional Lisp features such as fexprs, fsubrs, and…

I have found that the best way of learning the HtDP approach to program design, at least for me (I find the book itself a bit dry), are the EdX "How to Code" free moocs [1] [2]. The instructor is fantastic. It completely changed the way I program and design. If you like the approach and want to learn more, like, for instance, how to extend it to OO design, I list below links to several courses (most, except for the last one, offer enough material to complete them on your own, but I couldn't find any videos) at the university where HtDP's main author, Matthias Felleisen, is tenured (North Eastern). The courses are listed in the order in which they should be taken, and the rationale is explained by the professor in the paper "Developing Developers" [3]: * CS 2500 - Fundamentals I [https://course.ccs.neu.edu/cs2500/] * CS 2510 - Fundamentals II - Introduction to Class-based Program Design [https://course.ccs.neu.edu/cs2510/index.html] * CS 2800 - Logic and Computation [https://course.ccs.neu.edu/cs2800/index.html] * CS 3500 - Object Oriented Design - Spring 2018 (scaling up the 3 previous courses) [https://course.ccs.neu.edu/cs3500/] * CS 4500 - Software Development [http://www.ccs.neu.edu/home/matthias/4500-f18/index.html] [1] https://www.edx.org/course/how-code-simple-data-ubcx-htc1x [2] https://www.edx.org/course/how-code-complex-data-ubcx-htc2x [3] http://felleisen.org/matthias/Thoughts/Developing_Developers.html

I recently rebuilt my personal website on a Racket project: https://gitlab.com/JoelMcCracken/joelmccracken.com/ My post about why I chose it: https://joelmccracken.com/entries/pollen-writing-semantic-markup.html A really good resource for understanding the motivation behind racket: https://felleisen.org/matthias/manifesto/ For a taste of the build code I wrote: https://gitlab.com/JoelMcCracken/joelmccracken.com/blob/master/src/bui… and https://gitlab.com/JoelMcCracken/joelmccracken.com/blob/master/src/pol…