HN Books @HNBooksMonth

The best books of Hacker News.

Hacker News Comments on
Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp

Peter Norvig · 7 HN comments
HN Books has aggregated all Hacker News stories and comments that mention "Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp" by Peter Norvig.
View on Amazon [↗]
HN Books may receive an affiliate commission when you make purchases on sites after clicking through links on this page.
Amazon Summary
Paradigms of AI Programming is the first text to teach advanced Common Lisp techniques in the context of building major AI systems. By reconstructing authentic, complex AI programs using state-of-the-art Common Lisp, the book teaches students and professionals how to build and debug robust practical programs, while demonstrating superior programming style and important AI concepts. The author strongly emphasizes the practical performance issues involved in writing real working programs of significant size. Chapters on troubleshooting and efficiency are included, along with a discussion of the fundamentals of object-oriented programming and a description of the main CLOS functions. This volume is an excellent text for a course on AI programming, a useful supplement for general AI courses and an indispensable reference for the professional programmer.
HN Books Rankings

Hacker News Stories and Comments

All the comments and stories posted to Hacker News that reference this book.
That's not a bad approach, necessarily.

There is a fairly simple program in

https://www.amazon.com/Paradigms-Artificial-Intelligence-Pro...

that solves word problems using the methods of the old AI. The point is that is is efficient and effective to use real math operators and not expect to fit numbers through the mysterious bottleneck of neural encoding.

Jun 20, 2021 · Rochus on Common Lisp Books
Quite a random selection for such an official looking URL; what about e.g. "Common Lisp - The Language" (https://www.amazon.com/-/de/dp/1555580416) or e.g. "Object-oriented programming in Common LISP" (https://www.amazon.com/-/de/dp/0201175894)? However, the reference to "Principles of Biomedical Informatics" was useful; looks like a very interesting book; another important CL application book not on the list, is of course "Paradigms of Artificial Intelligence Programming" (https://www.amazon.com/-/de/dp/1558601910).
lispm
CLtL2 ( https://www.cs.cmu.edu/Groups/AI/html/cltl/cltl2.html ) is freely available, PAIP ( https://github.com/norvig/paip-lisp ) also .
Haven't read it personally but heard great things about: Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp - Peter Norvig

https://www.amazon.com/dp/1558601910

It is actively harmful to teach students that software architecture is something that somehow arises from diagrams or that those kinds of silly pictures capture anything important about it. Powerful architectures come out of powerful ideas that in turn come from accumulated hard work of many people in different disciplines. One can learn much more from walking through the actual source code of some classic projects and from trying to understand the ideas that make them tick:

https://github.com/onetrueawk/awk - UNIX philosophy of small tools, DSLs, CS theory: state machines / regular expressions, Thompson algorithm ...

https://github.com/mirrors/emacs - Both a program and a VM for a programming language, hooks, before/after/around advices, modes, asynchronous processing with callbacks, ... Worth to think of challenges of designing interactive programs for extensibility.

https://github.com/rails/rails - Metaprogramming DSLs for creating powerful libraries, again a lesson in hooks (before_save etc.), advices (around_filter etc.), ...

https://github.com/git/git - The distributed paradigm, lots of CS theory again: hashing for ensuring consistency, DAGs everywhere, ... By the way, the sentence "yet the underlying git magic sometimes resulted in frustration with the students" is hilarious in the context of a "software architecture" course.

One of computer algebra systems - the idea of a http://en.wikipedia.org/wiki/Canonical_form

One of computer graphics engines - Linear algebra

...

There are loads of things one can learn from those projects by studying the source in some depth, but I can't think of any valuable things one could learn by just drawing pictures of the modules and connecting them with arrows. There are also several great books that explore real software design issues and not that kind of pretentious BS, they all come from acknowledged all-time master software "architects", yet all of them almost never find diagrams or "viewpoints" useful for saying the things they want to say, and they all walk you through real issues in real programs:

http://www.amazon.com/Programming-Addison-Wesley-Professiona...

http://www.amazon.com/Paradigms-Artificial-Intelligence-Prog...

http://www.amazon.com/Structure-Interpretation-Computer-Prog...

http://www.amazon.com/Unix-Programming-Environment-Prentice-...

http://www.amazon.com/Programming-Environment-Addison-Wesley...

To me, the kind of approach pictured in the post, seems like copying methods from electrical or civil engineering to appear more "serious", without giving due consideration to whether they really are helpful for anything for real-world software engineering or not. The "software engineering" class which taught those kind of diagram-drawing was about the only university class I did not ever get any use from, in fact I had enough industry experience by the point I took it that it just looked silly.

synctext
Actively harmful? Diagrams?

Sorry I have to counter-react strongly. Your post is negative without a valid point and the irony is that you agree with the post.

> One can learn much more from walking through the actual source code of some classic projects and from trying to understand what makes them tick

That is the fun part about this post! You propose to mandidate a list of classical code bases. This course lets students freely pick any Github project with activity and complexity. They get graded based on pull requests.. Contributing code and interacting with an Open Source project you picked a week ago is not "drawing pictures" and "connecting them with arrows".

stiff
Programs are powerful because of concepts. Whether or not you will be able to build a good 3d engine rests much more on the fact whether you know or able to invent a concept of a vector and have it guide all your future coding than it rests on whatever is visible from a block diagram. Both the course and the book linked to seem to focus on some abstract ideas of doubtful usefulness and never ever seem to touch upon those important things that historically have allowed us to build complex programs where other approaches have failed. Google can exist not because people invented new kinds of diagrams, but because large scale numerical linear algebra techniques were applied to the problem of search. This is the heart of Google's "architecture", not a class diagram of the crawler.

Picking arbitrary programs won't do. The point is to pick the really good designs and illustrate why they are good, and I think it boils down much more to knowing mathematics, algorithms, programming languages and having studied a lot of existing software, than to usage of any modelling techniques so far invented in formal software engineering circles.

broseph
There's no conflict between reading and understanding a codebase and seeing the value in a diagram. You can have both. Take a look at the example you chose: [0] and [1] (about a third of the way down).

They first explained PageRank (without a diagram), then explained the flow of the data from the crawler (with a diagram). You seem to be arguing that diagrams are never useful, and that just isn't true.

[0] http://infolab.stanford.edu/~backrub/google.html [1] http://infolab.stanford.edu/~backrub/over.gif

avandeursen
Here's an addition to the answers from the others -- I'm one of the authors of the post.

Thanks for your feedback.

Perhaps we did not sufficiently emphasize it in the blog post, but we do tell the students about strong existing architectures, open source as well as from industry. The books listed in further reading in the post actually contain chapters about git and emacs, and I share your enthusiasm for Bentley's little language approach.

The philosophy of the course is based on trying to apply published approaches to software architecture (such as those in Rozanski & Woods' book, but it could be others) to real systems actually maintained and used. We encourage to get in touch with the creators of those systems.

The students actually take a deep dive into a foreign code base -- I included pictures because that is easy to share in a post, but the students analyze code, report about that, execute test cases, deploy systems, etc. The pictures are indeed, as suggested by some of the others, means for communication.

stiff
What repels me is the kind of approach taken by this Rozanski & Woods book. It's like a 500 pages of authors philosophy of software, and whether all that is of any use is completely uncertain. There is not much of a widely established corpus of knowledge on software engineering/architecture, another book would treat an almost completely different set of concepts, and whatever is commonly agreed upon is trivial and most people invent in on their own when they need it. You can publish completely anything about "Software architecture" in this spirit thats sounds smart enough and it won't ever be put to any test. I personally, from experience, don't believe any practical high-level theory of software engineering of this kind exists at all, the more "philosophical" or "theoretical" it gets the less useful it becomes. It is much better to spend this time studying established disciplines where things actually get tested out one way or another, mathematics, algorithms, operating systems, ... If there is anything specific to be taught under "software architecture", it's those ideas ("patterns") that made certain programs so much better than the alternatives, but you only really learn them by digging deep in, not by studying some very abstract models.
hansbogert
From your post it seems you think software architecture and -engineering are the same.. In this course -- disclaimer: I was a student taking this course -- it's not that case, Software Architecture is not the sum of a program's lines or modules. SA is the methodology of getting involved and steering a project, this includes handling team efforts and other stakeholders. Looking and learning a lot of (implementation) patterns is of course very useful, but only a subpart of SA.

I tend to think that a good SArchitect knows that the patterns they might be using are good or well suited for the current problem, a better SArchitect knows that he's perhaps using a less well suited pattern for the problem, but can layout a plan to migrate to a new and better situation without breaking continuity of the project.

Furthermore, it can't be stated clearer that in the course there are a lot of guest lecturers who _do_ show different idea's.

porker
In addition to what the other respondents have written, could it be that you are not a visual learner, and diagrams don't 'do it' for you?
currywurst
The pictures are a result of studying the systems in question.

For example, you have given links to a couple of github repos. Now if I'm trying to create an overview of how say emacs works, I would try to identify the main sub-parts and break the system down into more manageable chunks of study. This is all what 'viewpoints' are trying to structure. None of this is evident from just the codebase unless it has been captured in some documentation, or you take the trouble to understand it yourself.

You seem to have a very low opinion of software architects, but believe me, you wouldn't want to work on a 5-year old system where huge teams of developers have let loose and no one/team was responsible to ensure a cohesive, maintainable system.

Viewpoints are fantastic for communication purposes, and if you feel that the particular viewpoints shown don't make much of a difference, I agree :). A student project is also not the ideal environment, but it is really valuable to know how to create them, considering the information needs of the audience (biz vs tech vs in-depth tech). And that is what this course is all about.

stiff
The point is that how emacs is broken down in modules is one of the least important things about emacs. I can draw a block diagram without a "software architecture" course, thank you. In software engineering, there are of minor usefulness most of the time, if of any.

There have to be persons that guide the overall development, sure, but this does not mean that those have to be "architects" living in a castle somewhere drawing those diagrams. The best "architects" are people with long experience in the trenches that know all the ins and outs, all the relevant theory, know the domain, and supervise it down to the nitty-gritty details. Linus Torvalds is a software architect for Linux, he doesn't do much coding anymore, but he isn't busy drawing diagrams without understanding the code really well either, he just is the person with the widest understanding of the whole project:

https://lkml.org/lkml/2012/10/2/547

currywurst
There are a LOT of practicing architects that really fit the mould you are describing! Linus has the big picture in his head, and perhaps if he were to draw them out, does it make him an ivory tower denizen ?!

Also, ignoring how a system is modularized is typically how you get tangled codebases by introducing unexpected dependencies. Just because it is 'less interesting' doesn't make it 'unimportant'.

    Talking about stuff like this is bound to sound esoteric, I think. So
    I want to put this disclaimer upfront that I detest esotericism.

    I can only assume that your problems are similar to mine, so I can
    only suggest what works for me. And that might not completely work out
    for you in the end, but it's worth a try for sure.

    Concentration: The problem of not being able to keep distracting
    thoughts away can be lessened with meditation. I came across this
    suggestion in the book Pragmatic Thinking and Learning [1] and have
    found an excellent CD to listen to called Guided Mindfulness
    Meditation [2] by Jon Kabat-Zinn.

    I tend to try to avoid meditation because for a while I seem to do
    fine and so long as I do fine it just feels like a waste of time for
    me. Time that I could invest reading a book. But eventually I always
    end up having an extreme amount of distracting thoughts to the point
    that I cannot learn anymore. I've now had this problem crop up often
    enough with meditation always helping that I'm now a lot more willing
    to spend the time and meditate. I want to emphasize that for *me* it
    was necessary to get to the dead end and suffer from it to become
    willing to change something. Maybe you can relate.

    Structure: Well well, the way you write it sounds a little bit rigid
    to me. I tightened up imagining all that structure you strive for and
    I'm thinking you should relax a little bit. Or at least I should (and
    do). So maybe we are different in this regard.

    I do think you should lay back a bit and think about what really
    interests you deep down in your heart. I assume you've been working
    too much on hopelessly boring stuff, because with that I can relate
    again. I've been working a little bit on a little server in erlang but
    somehow at some point I couldn't bring myself to working further on
    it. Well I could, but all the time I felt something was wrong.

    As I'm happy to learn interesting programming languages and have heard
    all the hype about lisp for so long (I'm looking at you, pg) I finally
    gave in and started reading Practical Common Lisp [3] and now
    Paradigms of Artificial Intelligence Programming [4] and what can I
    say. I see now that what disappoints me in erlang but also in other
    languages is having forced upon me one paradigm and/or a rigid set of
    rules. In the case of erlang that might be perfectly fine as the
    language can make certain guarantees that way. I've realized though
    that I would much rather enjoy the lisp-ish freedom while molding a
    solution. So this is my story of disappointment and fresh wind.

    One quick addition in the end: In an xkcd comic [5] there is a
    description of a solution (see the alt-text of the image) that delays
    access to certain websites (like reddit, hn for me) but does not block
    them completely. It just delays the access (-- more discussion on the
    xkcd blog [6]). This serves the purpose of destroying the notion of
    instant reward these stupid little bits of new information might give
    you, however irrelevant they may be. I've found this to be helpful for
    me because sometimes in the past I've procrastinated the hell out of
    the day. I got fed up with repeatedly spending hours with unproductive
    stuff and feeling sorry for the time in the end. See the pattern? I
    needed to run into this problem several times before I decided that I
    have to change something. I don't want to make some point here. I just
    find this pattern interesting.

    What I have done is I have taken an existing little chrome extension
    called delaybot which by default only delays for rand(1.5) seconds and
    changed the delay to 30 secs. This has worked wonders in the
    beginning. I say in the beginning because I've now disabled the
    extension as it is getting in my way now. No, this is not the
    procrastinator disabling a helpful little tool. :-) I've found that
    since I've picked up meditation again I didn't run into this problem
    anymore anyways. I also tend to just bookmark away a lot of actually
    interesting discussions to read them later, which of course I never
    do. I do this bookmarking and closing of tabs because I tend to
    accumulate too many tabs easily otherwise.

    Not all is great though, the article made me realise that I'm a little
    bit too hard with myself when I'm excerting will-power. I try to go
    through the mentioned lisp books fast (as there are more to come
    still) and at some point I notice that I can't bring myself to read a
    lot more at that point. To me this looks similar to the cookie
    experiment where a group of people is less productive after excerting
    will power in a previous task.

    So, to conclude: Even if not all is roses I can say with certainty
    that meditation is the single most helpful tool to increase my
    productivity. It changes me from being helpless to being more in
    control of what I'd like to do with my time.

    Regarding your lack of passion: Man, search your feelings. If you find
    something that really interests you, you probably wouldn't think much
    about what other people could do better than you. That AI book [4] I'm
    reading? It features ancient techniques at the point where I am right
    now but it's still a great read and I'm learning a heck of a
    lot. That's what keeps me going. Also, lisp.

    Phew, that was long.
    I would love to hear feedback. :-)
[1] http://www.amazon.com/Pragmatic-Thinking-Learning-Refactor-P...

[2] http://www.amazon.com/Guided-Mindfulness-Meditation-Jon-Kaba...

[3] http://www.gigamonkeys.com/book/

[4] http://www.amazon.com/Paradigms-Artificial-Intelligence-Prog...

[5] http://xkcd.com/862/

[6] http://blog.xkcd.com/2011/02/18/distraction-affliction-corre...

EDIT: I've changed the formatting because it renders with long lines otherwise.

static_cast
Thanks for your great reply. I've looked into mediation and I should start now doing it. Nice to hear that it helps you.

I really guess I have to look after my feelings. Something went wrong along the way and now I'm struggling.

maigret
Sorry to answer on the most superficial aspect and last line of your post... But I wonder why PG's site is so thin in width, making it extremely well readable, while HN uses the whole screen width? I consider the whole screen text use a UI anti pattern.
lostmypw
I can only speculate. :-) Maybe restricting the width to improve readability would yield suboptimal results in heavily nested threads. One might find out by manipulating the corresponding css attribute. Doesn't chrome or firefox support this out of the box?

So this is the width of the paragraphs. I think it would still be useful if you could disable the automatic line breaking to provide your own formatting. I think there is a middle ground between the two regarding readability.

EDIT: Of course you can disable the automatic line breaking as I've done exactly this by indenting the whole post with 4 spaces, except for the links. But that also changes the font to the monospace family.

Funny, I just bought the old classic that I never got a chance to read:

"Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp" by Peter Norving

http://www.amazon.com/Paradigms-Artificial-Intelligence-Prog...

Guess Lisp is 'really' making a come back.

HN Books is an independent project and is not operated by Y Combinator or Amazon.com.
~ yaj@
;laksdfhjdhksalkfj more things
yahnd.com ~ Privacy Policy ~
Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.