How to Average in Prolog (2017) | Hacker News Reader

How to Average in Prolog (2017)

storytotell.org

72 pointstodsacerdoti23 comments

The author seems to be frustrated at something but I'm not sure what. There is value in learning how to implement something from first principles. Teachers aren't sitting around scheming about how they can waste their students' time with "meaningless calisthenics", they're trying to help them. Calling them "clueless professors" isn't great either. There's a degree of disrespect in undergraduates dunking on professional tertiary-level educators for making them do homework.

Also, Prolog does not have a "standard library". What predicates are implemented varies greatly by implementation, and if you want to write portable code then you have to stick as closely as possible to the ISO standard.

This is a strange article to me. I've not seen any class that teaches Prolog place these constraints (use recursion / don't add new predicates) or even accidentally have the outcome of "making prolog look tedious". What's the joke here?

That aside, I wonder if getting the reverse solution (sum(?, 10)) is better served by the straightforward or the tedious approach. I suspect both would work just the same, but I'd be curious if anyone knows otherwise.

It's been a long time since I took a class like this, but I definitely had a similar experience to the author.

Ideas like fold and map where _never_ mentioned in lisp (to exaggerate, every function had to have the recursive implementation with 5 state variables and then a simpler form for the initial call), at no point did higher-order functions or closures make an appearance while rotating a list by 1 and then 2 positions.

The treatment of Prolog was somehow worse. Often the code only made any sense once you reversed what the lecturer was saying, realizing the arrow meant "X given Y" not "X implies Y", at which point, if you could imagine the variables ran "backwards" (unification was not explained) the outcome might start to seem _possible_. I expect the lecturer was as baffled by their presentation as we were.

In general, it left the rest of the class believing quite strongly that languages other than Java were impossible to use and generally a bad move. I may have been relatively bitter in the course evaluation by the end.

Thie irony is palpable. I had the (misfortune) of only being (mis)taught procedural languages by professors who thought computers were big calculators who could never be understood, but could be bent to your will by writing more code and maybe by getting a weird grad student to help.

Patterns might appear to the enlighted on the zeroth or first instance, but even the mortal must notice them after several goes. The magic of lisp is that if you notice yourself doing anything more than once you can go ahead and abstract it out.

Not everything needs to be lifted to functional valhalla of course, but not factoring out e.g. map and filter requires (imho) a wilful ignorance of the sort that no teacher should countenance. I think it's bad professional practise, bad pedagogy, and a bad time overall. I will die on this hill.

If you are only used to Java (the bad, old, ancient version), you don't even notice that you can factor out map and filter.

Having been on the other side of this (teaching undergrads), I do get why courses would be structured like this. If you actually try explaining multiple things, lots of students freeze up and absorb nothing. Certainly there’s a few motivated and curious students who are three lectures ahead of you, but if you design the class for them, 60% of students will just fail.

So I get why a professor wouldn’t jump in with maps and folds. First, you need to make students solve a simple problem, then another. At the third problem, they might start to notice a pattern - that’s when you say gee your right there must be a better way to do this, and introduce maps and folds. The top 10% of the class will have been rolling their eyes the whole time, thinking well duh this is so boring. But most students seem to need their hand held through this whole process. And today, of course, most students are probably just having LLMs do their homework and REALLY learn nothing

Ah, yes. Like in the class where we learned Moscow ML, where loops don’t and variables ain’t, and Godspeed!

I found the article to be hilarious.

It's existence obviously means some professor didn't allow them to use the standard library and they tongue in cheek show how irritating that is.

I'm sure it's possible they made it up, but we had similar restrictions where I could use an Arduino for my engineering Senior Design Project in college, but no Arduino or module libraries - just our own C. We passed, but barely. It also was weird as it didn't match how normal people would solve the problem.

Yeah, this line made it click:

> Now this is starting to look like Professor of Programming Languages code!

A lot of tier 2/3 CS schools with programming language courses (a survey of multiple languages across various paradigms) teach Prolog this way (and I've seen some fantastically terrible examples of Lisp code coming out of those same courses). It's unfortunate because, at these schools, this is often the only formal course where students branch out of C/Java/C++/C#/Python/JS (and they may only get 2-3 of those over the rest of their courses). It leaves the students with a gross misunderstanding of the languages and dread when they see them again.

>I'm sure it's possible they made it up, but we had similar restrictions where I could use an Arduino for my engineering Senior Design Project in college, but no Arduino or module libraries - just our own C.

When I started compsci, it was the first year of a all-new curriculum for CompSci.

Literally the first week: We had to program an Arduino to play a song on a speaker by toggling GPIO, within a week. No assembly or any of that high-level mumbo-jumbo. We had to read the datasheet, look at the instructions and write the hex representation for each instruction in a txt file.

We had a "linker" tool: It took a basic bootloader (containing some helper functions for GPIO), turned our hex-txt file into actual binary, then just copies that to a set address. The bootloader did nothing more than init the GPIO pins and jump into our code.

We were given the locations of where these helper functions lived, nothing else.

It was to give a quick and intimate understanding of how CPUs actually work and why we use compilers and stuff. It worked really well, but it was so much of a pain that they changed it to allow students to use asm a year or two after.

You were lucky! We had to design and build the computer out of Z80-family components first before we could play around in binary.

There was actually a reason - this was back in '83/84 in a physics lab, and the idea was to be able to build your own logging / control device. PCs existed, but were terribly expensive.

> It also was weird as it didn't match how normal people would solve the problem.

If I can solve a problem by building from preexisting LEGO blocks then I'll probably do that, but it wouldn't be a valuable learning exercise. Students aren't being given problems in need of effective solution, these problems are tools to facilitate understanding.

What you described could be pointless if it made you work on reimplementing trivial stuff that you'd already mastered long time ago instead of focusing on actual problem. Writing your 100th hashmap implementation or yet another I2C driver isn't particularly valuable. Since you mentioned "barely passing", I don't think that was the case though.

It's one of those projects where you never have enough time throughout the year. Coding what we did from scratch wasn't very easy either. I could now probably do the coding in a weekend with the right library code. You learn something either way I guess.

There's nothing wrong with teaching like that. If the class is supposed to teach you something that isn't just "use the stdlib", then it makes sense to ban it.

I'm guessing the author is aware and just venting. It doesn't make it less frustrating though. It's almost like someone asking you to dig a hole with chopsticks.

It reminds me of a satirical post called “Evolution of a Haskell Programmer” in which a nice simple implementation of the Fibonacci function becomes more and more convoluted, abstract, and academic [1].

[1] https://people.willamette.edu/~fruehr/haskell/evolution.html

*factorial function

Or maybe just a very bad implementation of the Fibonnaci sequence.

I was extremely confused for a moment and pondered returning my MSc.

>getting the reverse solution (sum(?, 10))

Doing an "all modes" predicate:

  sum_list(List,Sum)

...where...

  sum_list([1,2,3], 6)

...is "True" as expected would probably be a pretty interesting exercise if you wanted to be able to get all of the lists. You'd probably need to do an "enumerate the rationals" type of thing, since you need to go to infinity in a couple of different directions at the same time. That is, you can't do nested loops/recursing:

   for(x=-∞; x<∞; ++x) {
       for(y=-∞; y<∞; ++y) {

i.e.

   sum_list([],0).
   sum_list([L|Ls],BigSum) :- sum_list(Ls, LittleSum), add(L,LittleSum,BigSum).

...with an all-modes "add/3". Since there are an infinite supply of pairs that add up to, say 10:

       ⋮
    [12,-2]
    [11,-1]
    [10, 0]
    [ 9, 1]
    [ 8, 2]
       ⋮
    [ 0,10]
    [-1,11]
    [-2,12]
       ⋮

...and you can also go to arbitrary list lengths:

  [10]
  [1,9]
  [1,1,8]
  [1,1,1,7]
   ⋮
  [1,1,1,1,1,1,1,1,1,1]
   ⋮
  [0,1,1,1,1,1,1,1,1,1,1]
  [1,0,1,1,1,1,1,1,1,1,1]
   ⋮
  [1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0]
   ⋮
  [-100,-99,-98,...,-12,-11,-9,-8,...,0,1,2,3,4,5,6,7,8,9,10,11,...,99,100]

...your life probably gets easier if you limit the domain to positive integers (without zero) since then the list length doesn't diverge. Then a declarative looking solution probably just has a all-modes equivalent to "sort" somewhere within? Certainly interesting to think about.

https://www.cs.ox.ac.uk/people/jeremy.gibbons/publications/r...

https://prolog-lang.org/ImplementersForum/0103-modes.html

https://www.swi-prolog.org/pldoc/man?predicate=permutation%2...

It’s been more than 30 years since I took a (very basic) course in logic programming in general and Prolog in particular, so I can’t read the level of sarcasm in the text, but: Surely, when a course places various artificial limitations on programming, like “hands off the standard library”, the reason is that they are not trying to teach you to be productive Prolog (or whatever language) programmers, they are trying to teach you basic principles, and truly internalizing those principles often (not for everyone!) requires swimming around in them for a while. In Lisp, you are not just supposed to know that you can write a tail-recursive function for something, you are supposed to have done it so many times that you can do it almost without thinking. In calculus, you are not supposed to look up the derivative of arcsin in a table, you are supposed to feel it, so that to immediately see that that subsituting t=sin(x) makes that integral much nicer. They are not training you to use the standard library, they are training you to write it.

Admittedly, teachers sometimes seem to lose track of this and assign busywork exercises for no good reason.

Love the jab regarding "only tools available in the 18th century", applies to so many things in mainstream computing.

TIL: Grok cannot do Prolog, it insists that

  average([X],X) :- !.

is better than

  average([X],X).

Reply on news.ycombinator.com