2009 Dec 28 00:58:50  <inimino> hey aamar
2009 Dec 28 00:58:56  <aamar> hey inimino
2009 Dec 28 00:59:29  <inimino> how's it going?
2009 Dec 28 00:59:53  <aamar> good, how are you doing?
2009 Dec 28 00:59:56  <aamar> happy holidays!
2009 Dec 28 01:00:28  <inimino> happy holidays to you too :)
2009 Dec 28 01:01:23  <inimino> I did not get the last four exercises done
2009 Dec 28 01:03:56  <aamar> I got through 4.49
2009 Dec 28 01:03:59  <aamar> So about the same.
2009 Dec 28 01:04:24  <inimino> cool
2009 Dec 28 01:04:55  <aamar> budgeted quite a bit of time -- some of these took a while!
2009 Dec 28 01:05:11  <inimino> yeah, indeed
2009 Dec 28 01:05:11  <aamar> Or I'm getting old.
2009 Dec 28 01:05:16  <inimino> hehe
2009 Dec 28 01:05:48  <inimino> I think you're too young for senility.
2009 Dec 28 01:06:09  <aamar> hopefully for a little while longer
2009 Dec 28 01:06:31  <aamar> should we start?
2009 Dec 28 01:06:39  <inimino> sure
2009 Dec 28 01:06:52  <inimino> these took me quite a bit of time too, I think it just means there is more learning going on
2009 Dec 28 01:07:33  <aamar> 4.41 was where we left off?
2009 Dec 28 01:07:54  <aamar> http://github.com/aalearn/aalearn-sicp/blob/master/ch4-outline.scm#L732-779
2009 Dec 28 01:08:16  <inimino> ah, I think so
2009 Dec 28 01:08:48  <inimino> I remember noting that my 4.41 was wrong, but I never fixed it
2009 Dec 28 01:12:16  <inimino> it's wrong because it only finds two solutions to the looser problem, but your solution to an earlier problem showed that there were more than two solutions
2009 Dec 28 01:13:17  <aamar> ok, let me take a look there
2009 Dec 28 01:14:19  <inimino> yours looks good, and I think is a more straightforward implementation
2009 Dec 28 01:14:42  <aamar> Right ok, 5 solutions.
2009 Dec 28 01:14:51  <aamar> I didn't test mine in that situation.
2009 Dec 28 01:15:04  <aamar> (i.e. in the 4.38 version with one fewer restrictions)
2009 Dec 28 01:15:06  <inimino> mine is more trying to implement something like amb without amb, yours is more direct
2009 Dec 28 01:15:12  <aamar> I'll try it and see if it obtains good answers.
2009 Dec 28 01:16:08  <inimino> I think it will
2009 Dec 28 01:16:36  <aamar> It's an interesting approach
2009 Dec 28 01:17:18  <aamar> it does get the right answer at first -- so it seems there are some branches it's not trying.
2009 Dec 28 01:17:54  <inimino> yes
2009 Dec 28 01:17:57  <inimino> I'm not sure why
2009 Dec 28 01:18:18  <aamar> Oh, maybe it's only branching at the outer-most layer.
2009 Dec 28 01:18:51  <inimino> hm, that looks consistent with the results
2009 Dec 28 01:19:47  <inimino> ah, I think that's right
2009 Dec 28 01:19:59  <inimino> my try implementation is not quite right, I think
2009 Dec 28 01:20:05  <aamar> we could tinker for a bit to confirm, or go to the next one for now?
2009 Dec 28 01:20:38  <inimino> well, this turns out to be basically part of the evaluator presented later in the chapter, just lifted into the program (incorrectly)
2009 Dec 28 01:21:07  <inimino> I think the benifit comes from getting through the rest of the chapter more than debugging this first try
2009 Dec 28 01:21:12  <aamar> yes, it is fairly similar, but I didn't get quite far enough in it to intuit what's different.
2009 Dec 28 01:21:27  <inimino> but I might come back to it and see if I can determine exactly the error...
2009 Dec 28 01:21:32  <inimino> I think it's related to:
2009 Dec 28 01:21:43  <inimino>         (let ((result (proc test-value)))
2009 Dec 28 01:21:43  <inimino>           (if result
2009 Dec 28 01:21:43  <inimino>               (list result (lambda () (try (cdr values) proc)))
2009 Dec 28 01:22:07  <inimino> if it finds a result in a branch, it doesn't look for any more results in that branch
2009 Dec 28 01:22:24  <inimino> it needs to somewow bubble the continuations back out too
2009 Dec 28 01:22:35  <inimino> anyway, lets move on for now
2009 Dec 28 01:22:41  <aamar> that's it
2009 Dec 28 01:23:04  <aamar> that's why you only have 5 continuations in your first "results" line.
2009 Dec 28 01:23:08  <aamar> ok
2009 Dec 28 01:23:13  <aamar> 4.42
2009 Dec 28 01:23:20  <aamar> http://github.com/aalearn/aalearn-sicp/blob/master/ch4-outline.scm#L780-822
2009 Dec 28 01:24:28  <inimino> http://inimino.org/~inimino/projects/2009/SICP/chap_4/4.42
2009 Dec 28 01:25:16  <aamar> ha, your version of XOR is massively better
2009 Dec 28 01:26:28  <inimino> hehe, thanks
2009 Dec 28 01:27:35  <aamar> I like "excluding" too
2009 Dec 28 01:27:59  <aamar> Mine doesn't have any of the efficiency optimizations.
2009 Dec 28 01:28:20  <inimino> hm, different implementations, I realize I never actually tried to run mine
2009 Dec 28 01:29:07  <inimino> oh, no I did
2009 Dec 28 01:29:09  <aamar> seems like it will work
2009 Dec 28 01:29:29  <inimino> yeah, and wasn't implemented in amb-eval
2009 Dec 28 01:29:39  <inimino> I didn't care enough to fix it so I didn't run it
2009 Dec 28 01:29:39  <aamar> ;The object #f, passed as the first argument to integer-equal?, is not the correct type.
2009 Dec 28 01:30:01  <inimino> oh, I guess I have to use (eq there
2009 Dec 28 01:30:28  <inimino> or eq?
2009 Dec 28 01:31:00  <inimino> (eq? #t #f) seems to work
2009 Dec 28 01:31:09  <aamar> ok tried that
2009 Dec 28 01:31:11  <aamar> ;Too many arguments supplied (a b) (#f #f #t #f #t)
2009 Dec 28 01:31:20  <aamar> possibly a ")" out of place?
2009 Dec 28 01:32:07  <inimino> hm, did you implement `and` in your amb-eval?
2009 Dec 28 01:32:15  <inimino> I'm wondering why we got different errors
2009 Dec 28 01:32:22  <aamar> nope, my typo
2009 Dec 28 01:33:03  <aamar> I did implement and
2009 Dec 28 01:33:13  <aamar> as well as or
2009 Dec 28 01:33:20  <aamar> both implemented in terms of "if"
2009 Dec 28 01:33:40  <inimino> ah, ok, cool
2009 Dec 28 01:34:39  <aamar> ok, fixed the typo
2009 Dec 28 01:34:46  <aamar> the problem is that my "and" is not general
2009 Dec 28 01:34:50  <aamar> it only takes 2 arguments
2009 Dec 28 01:34:59  <inimino> ok, that's what it looked like from the error
2009 Dec 28 01:35:06  <aamar> yes
2009 Dec 28 01:35:35  <aamar> ok, that explains it... I bet this runs with a proper "and"
2009 Dec 28 01:37:11  <aamar> should we look at 4.43?
2009 Dec 28 01:37:16  <inimino> sure
2009 Dec 28 01:37:35  <inimino> oh, I skipped this one
2009 Dec 28 01:37:40  <inimino> but I will read your solution
2009 Dec 28 01:37:47  <aamar> This one was massively long!
2009 Dec 28 01:38:34  <aamar> my solution felt like a mess, actually, because I never figured out how to cleanly map the fathers to the daughters.
2009 Dec 28 01:40:06  <inimino> wow
2009 Dec 28 01:40:14  <inimino> this is way longer than I expected the solution to be
2009 Dec 28 01:42:10  <inimino> well, it looks like it works
2009 Dec 28 01:43:27  <inimino> I think I mostly follow it
2009 Dec 28 01:43:50  <inimino> I guess I thought this exercise would be very similar to the earlier logic puzzle ones
2009 Dec 28 01:44:17  <inimino> I'm surprised at the complexity
2009 Dec 28 01:46:02  <aamar> I bet there are much easier ways to handle it... but I ended up with this :(
2009 Dec 28 01:46:28  <aamar> It's conceptually not different from the earlier ones -- it's just that there's more objects to keep track of.
2009 Dec 28 01:46:43  <inimino> yeah
2009 Dec 28 01:47:06  <inimino> the vague idea I have is to create father-daughter pairs
2009 Dec 28 01:47:20  <aamar> okay, let's look at 4.44
2009 Dec 28 01:47:26  <inimino> from the set of remaining fathers and daughters
2009 Dec 28 01:47:52  <inimino> so you can call a function that ambiguously gives you a new pair, and then run some tests... not sure
2009 Dec 28 01:47:57  <inimino> ok, 4.44
2009 Dec 28 01:48:11  <inimino> http://inimino.org/~inimino/projects/2009/SICP/chap_4/4.44
2009 Dec 28 01:48:14  <aamar> father-daughter-yacht triples might work
2009 Dec 28 01:48:17  <aamar> interesting
2009 Dec 28 01:48:18  <aamar> ok
2009 Dec 28 01:49:35  <aamar> I think your (not-checking new-queen) should be (not-checking new-queen queen)
2009 Dec 28 01:50:09  <inimino> oh, yes
2009 Dec 28 01:50:31  -*- inimino fixes
2009 Dec 28 01:51:28  <aamar> I think they're not all that different -- you put your recursion in a sensible place.
2009 Dec 28 01:52:41  <aamar> my version doesn't short circuit a checking queen as fast.
2009 Dec 28 01:53:02  <aamar> I should note that mine is very slow -- took a minute or so for 6 queens, never finished for 8.
2009 Dec 28 01:53:42  <aamar> oh, actually yours doesn't short-circuit faster -- basically works the same way there.
2009 Dec 28 01:54:18  <inimino> they look about the same for efficiency from my reading
2009 Dec 28 01:54:35  <inimino> I should note that I never ran mine but didn't expect it to be slow, so your result is surprising to me
2009 Dec 28 01:55:52  <inimino> hm
2009 Dec 28 01:55:59  <inimino> I'm not sure they're the same
2009 Dec 28 01:57:07  <inimino> (let ((my-queens (cons (list n (amb-enumerate board-size)) (safe-queens (- n 1)))))
2009 Dec 28 01:57:45  <inimino> this seems like it might be doing things in an inefficient order?
2009 Dec 28 01:58:13  <inimino> hm, or maybe not
2009 Dec 28 01:58:37  <inimino> I guess that's equivalent actually
2009 Dec 28 01:58:44  <aamar> Yeah, yours is running slowly too.
2009 Dec 28 01:58:51  <inimino> well, I wouldn't have expected this to be so slow, that's odd
2009 Dec 28 01:59:03  <aamar> Well, it finished now
2009 Dec 28 01:59:07  <aamar> So it's faster than mine.
2009 Dec 28 01:59:19  <inimino> oh
2009 Dec 28 02:00:24  <inimino> well I have a vague intuition about why but I can't really formulate it
2009 Dec 28 02:00:40  <inimino> I still find reasoning about the performance of these programs quite hard
2009 Dec 28 02:00:54  <aamar> what's the vague intuition?
2009 Dec 28 02:01:01  <inimino> I guess something that generates a full trace of the execution path and plots a nice graph would be nice
2009 Dec 28 02:01:30  <inimino> it's those two lines
2009 Dec 28 02:01:33  <inimino>  (let ((my-queens (cons (list n (amb-enumerate board-size)) (safe-queens (- n 1)))))
2009 Dec 28 02:01:35  <inimino> (require (safe? my-queens))
2009 Dec 28 02:01:58  <aamar> ok, most likely yes
2009 Dec 28 02:02:03  <inimino> it seems like you are generating a row
2009 Dec 28 02:02:13  <inimino> then generating all smaller boards that are safe
2009 Dec 28 02:02:16  <inimino> then testing them all
2009 Dec 28 02:02:18  <inimino> most will fail
2009 Dec 28 02:02:27  <inimino> I think mine tests each row as it is added
2009 Dec 28 02:02:38  <inimino> so it generates fewer possibilities
2009 Dec 28 02:02:52  <inimino> or s/row/column/
2009 Dec 28 02:02:55  <inimino> however you think about it
2009 Dec 28 02:03:30  <aamar> ah, sort of like a Louis Reasoner attempt at the 8-queens problem.
2009 Dec 28 02:03:39  <aamar> Been feeling a lot like Louis recently.
2009 Dec 28 02:03:59  <aamar> I'm almost certain that you're right
2009 Dec 28 02:04:04  <inimino> this chapter has been doing that to me too
2009 Dec 28 02:06:57  <inimino> well, next one?
2009 Dec 28 02:07:05  <aamar> ok sure
2009 Dec 28 02:07:30  <inimino> ok
2009 Dec 28 02:07:35  <aamar> http://github.com/aalearn/aalearn-sicp/blob/master/ch4-outline.scm#L1001-1027
2009 Dec 28 02:07:44  <inimino> http://inimino.org/~inimino/projects/2009/SICP/chap_4/4.45
2009 Dec 28 02:10:28  <inimino> I think your first parse is my last one
2009 Dec 28 02:10:44  <aamar> my 1 = your 5, my 2 = your 3
2009 Dec 28 02:11:09  <aamar> my 3 = your 4
2009 Dec 28 02:11:24  <aamar> my 4 = your 1
2009 Dec 28 02:11:42  <aamar> my 5 = your 2
2009 Dec 28 02:11:47  <aamar> okay, they are the same
2009 Dec 28 02:11:49  <inimino> yeah, I think that's it
2009 Dec 28 02:11:52  <inimino> ok
2009 Dec 28 02:11:59  <inimino> 4.46?
2009 Dec 28 02:12:23  <aamar> yes
2009 Dec 28 02:12:29  <aamar> I was quite unsure of my answer to this one
2009 Dec 28 02:12:56  <inimino> http://inimino.org/~inimino/projects/2009/SICP/chap_4/4.46
2009 Dec 28 02:12:57  <aamar> Oh I see
2009 Dec 28 02:13:04  <aamar> your answer is persuasive!
2009 Dec 28 02:14:02  <inimino> I think your 4.46 is very like my answer to 4.47
2009 Dec 28 02:15:27  <aamar> In fact I skipped 4.46 at first, then returned to it after 4.47
2009 Dec 28 02:15:41  <aamar> Reading your answer to 4.47, and I think it's essentially the same as mine.
2009 Dec 28 02:16:09  <inimino> yeah
2009 Dec 28 02:16:27  <inimino> I think actually what you mention on 4.46 would also be a problem, if the other thing didn't bite first
2009 Dec 28 02:17:04  <inimino> I found 4.47 really illustrative
2009 Dec 28 02:17:34  <inimino> it took me quite a while to get it right, I think
2009 Dec 28 02:17:49  <inimino> your answer looks exactly the same, which is reassuring
2009 Dec 28 02:18:02  <aamar> Yes, I appreciate your longer explanation; it definitely maps to what I was thinking.
2009 Dec 28 02:18:39  <aamar> 4.48 ?
2009 Dec 28 02:19:01  <inimino> sure
2009 Dec 28 02:19:17  <inimino> ah, I skipped this one too
2009 Dec 28 02:19:40  <aamar> ok
2009 Dec 28 02:19:46  <aamar> this one wasn't particularly interesting
2009 Dec 28 02:20:00  <inimino> your implementation looks straightforward
2009 Dec 28 02:20:02  <aamar> http://github.com/aalearn/aalearn-sicp/blob/master/ch4-outline.scm#L1068-1091 <- 4.49
2009 Dec 28 02:20:15  <inimino> http://inimino.org/~inimino/projects/2009/SICP/chap_4/4.49
2009 Dec 28 02:21:32  <aamar> Interesting...
2009 Dec 28 02:21:45  <aamar> The book was odd on this point.
2009 Dec 28 02:21:50  <inimino> your results look about like what I expected
2009 Dec 28 02:22:01  <inimino> I think that was the desired implementation
2009 Dec 28 02:22:10  <aamar> I couldn't figure out a way to avoid infinite recursion without limiting the length of the sentence...
2009 Dec 28 02:22:18  <aamar> It never produced a single valid phrase.
2009 Dec 28 02:22:21  <inimino> not sure about the (require (not (null? *unparsed*))) bit
2009 Dec 28 02:22:26  <inimino> hm
2009 Dec 28 02:22:51  <inimino> I would have thought it would have produced something short at first
2009 Dec 28 02:22:53  <aamar> That's from the original implementation of parse-word.
2009 Dec 28 02:23:12  <aamar> That with the next line act like the length-limiter you describe in your answer
2009 Dec 28 02:23:19  <inimino> right, I meant more the idea of limiting the length that way
2009 Dec 28 02:23:30  <inimino> yes
2009 Dec 28 02:23:52  <inimino> so without the length limitation it didn't terminate?
2009 Dec 28 02:24:10  <inimino> is there anything in the grammar in which the first branch isn't also the shortest?
2009 Dec 28 02:24:31  <aamar> right
2009 Dec 28 02:24:53  <aamar> oh, you know, it might have been my adjectives patch!
2009 Dec 28 02:25:34  <inimino> ah!
2009 Dec 28 02:26:11  <aamar> ;Aborting!: out of memory
2009 Dec 28 02:26:21  <aamar> ok, so my quick attempt to pull that out didn't work.
2009 Dec 28 02:27:27  <inimino> yeah, actually your adjective patch looks like it should be okay as it tries the bare noun first
2009 Dec 28 02:27:52  <aamar> ok, still getting infinite loop and out of memory errors
2009 Dec 28 02:28:08  <aamar> oh well - the length limited one works fine, as you describe in your answer.
2009 Dec 28 02:28:17  <aamar> And is superior in some ways.
2009 Dec 28 02:28:45  <aamar> ok that's it for now
2009 Dec 28 02:29:32  <inimino> alright
2009 Dec 28 02:30:38  <inimino> your amb-any looks fine to me, not sure why it wouldn't terminate, maybe I'll play with this
2009 Dec 28 02:30:55  <inimino> alright, so for next time, should we just finish up to 4.54?
2009 Dec 28 02:31:18  <inimino> I am still just reading into the amb-eval implementation, I found it pretty heavy going
2009 Dec 28 02:31:22  <aamar> A little more modest.
2009 Dec 28 02:31:36  <aamar> Might be good actually, since I'm moving and there's new years.
2009 Dec 28 02:31:48  <inimino> yeah, I'm in no rush to get through this section, I guess
2009 Dec 28 02:32:22  <aamar> Okay, sounds good.
2009 Dec 28 02:33:00  <inimino> alright, cool
2009 Dec 28 02:33:24  <inimino> see you in a couple weeks :)
2009 Dec 28 02:33:45  <inimino> in the new year, I should say :-)
2009 Dec 28 02:34:41  <aamar> ok, talk to you then!
2009 Dec 28 02:35:34  -=- aamar has changed topic for ##SICP to: "Topic: SICP book club | Next meeting: Sunday, Jan 10, 5PM PST, Exer. 4.50-4.54 | http://hn-sicp.pbwiki.com | http://www.cafepress.com/SICP2 | http://www.cafepress.com/SICP2 | http://g.imagehost.org/0293/Untitled_11.jpg"
2009 Dec 28 02:35:54  <inimino> cool