A Philosophy of Software Design | John Ousterhout | Talks at Google

Each repost is worth it. This, along with John Ousterhout's talk [1] on deep interfaces was transformational for me. And this is coming from a guy who codes in python, so lots of transferable learnings. [1] ▶ this video

This google talk ▶ this video is a condensed version of the (already small - 150 pags IIRC) book. I highly recommend both. To the point made by the GP (and others here) about how useful the book is, I must add that I got a whole lot more from this small book than some other well known and oft suggested titles (like Clean Code, POSA etc). My most recent peeve about the matter is that Kent Beck"s "Tidy, Fisrt?" was apparently motivated partly in response to this book and yet it falls way too short to matching up. Half of thst book is way too simplistic and almost patronizing and the other is handwavy abstract notions too scared to touch reality lest it spoil the narrative.

> I'd rather get to value now by making something that just works(and is adequately tested) than engineer something thats future proof but takes longer to get out. If you haven't read it, I highly recommend A Philosophy of Software Design by John Ousterhout. His talk is a great teaser for the book: ▶ this video Here's the thing: a program properly written for the future does not take longer to get out. Not much, at least. What we instinctively think of as "future proof" is generally anything but: by anticipating some particular kind of change that may happen some time in the future, but in practice almost never does, we end up with more complex programs that are harder to modify when an actual (typically unforeseen ) change comes our way. The best way to future proof your program is to make it simpler , according to the requirement you are currently aware of. If you expect a particular change, sure, plan for it. But for the unexpected, just keep it simple. Because simple is easier to adapt, add to, or rewrite. That said, the simplest solution is rarely the most obvious. Making thing simple does take a bit more time than rushing through the first thing that comes to mind. But it also pays off in a matter of weeks, so it's quite worth it. And if you have a hard time assessing what "simple" means, SLoC is a surprisingly good metric (we have research that shows this). And mostly your modules should be deep: small APIs that hide significant implementations. I think of it as encapsulati

I haven't read the book yet, but I have watched his Talks at Google talk on the topic [1] a couple of times (1 hour), highly recommended. [1] ▶ this video

I've been re-learning CS (programmed as a kid, then missed getting a minor in CS in college after the service by one 300-level course which wasn't being re-offered when I needed it) and then just did (La)TeX and AppleScript for my day job, but am now trying to create a tool for CNC which is quite different from those which have existed previously, and one thing which has helped a lot is MIT OCW: - the Python courses got me up-to-speed on the basics of that language: link and link - Structure and Interpretation of Computer Programs served as a disciplined review of a book which I wasn't patient enough to do the exercises of when I first read it: link - Mathematics for Computer Science helped make up for my spotty math: link I've also found the recent book: link very helpful (first reading I did one chapter at a time, re-writing my current project applying the principles of that chapter) --- interesting video overview at: ▶ this video If one is fortunate, there are videos on specific subjects/algorithms which one needs, e.g., link

Probably the best book I’ve read on this subject. There’s a lecture by the author[1] as a quick overview of what the book is about. [1]: ▶ this video

Ah, a Java developer. Try a normal language and when faced with the need to split code up, use... functions. You will be enlightened. Mandatory homework: - link - "A philosophy of software design" by John Ousterhout. Video primer: ▶ this video - "Functional Core, Imperative Shell": link

>"A Philosophy of Software Design" by John Ousterhout Indeed, very interesting little book! He's done a talk[0] about it if you want a taste before buying. [0] ▶ this video

I haven't read the book, but this presentation from professor John Ousterhout on the book was pretty good: ▶ this video

I came into this thread hoping to find the suggestion near the top. Beyond his credibility as the creator of Tcl, in the talk he gave at Google about the book [1] he describes the course he teaches that was the inspiration for the book. The course is to write a word processor with a team and extended it with features over the semester, swapping codebases between teams so occasionally you have to work with other's code. Essentially the largest possible code project you can fit in one semester. Along the way, Ousterhout will give a deep code review of the each project. I think it must be very insightful to see the same project implemented so many ways, and to see what works in terms of simplicity and extensibility. [1] ▶ this video

You’re right re: it’s early internals, and we probably both know people who still (mistakenly) complain about that. Conceptually the “everything is a string”(EIAS) model still holds though, even though it’s supported by dual-ported “objects” w native representation, and the running is often byte-compiled instead of string parsing. We’ve got early smart fans who saw the vision and possibilities like Karl Lehenbauer, Don Libes, Richard Hipp, and the current core team like Kevin Kenny, Don Porter, Donal Fellows, etc who deeply understand What Tcl Is, and strictly maintain it, even while pushing it ahead (TclObj, finally an in-core blessed object system, native database framework, Miguel Sopher’s(RIP) work on the stackless non-recursive engine (NRE) and coroutines that fell out of that work... Back to Ousterhout though, you might dig his “Philosophy of Software Design”[0] book, or talks associated with it[1]. Lots to like in this space... [0] link [1] ▶ this video

John Ousterhout has been addressing this one class at a time at Stanford for a while now, and has scaled up to a book: link Video overview at: ▶ this video