[08:16] *** vmlemon_ has joined #kamaelia

[08:44] *** vmlemon_ has joined #kamaelia

[08:50] *** vmlemon_ has joined #kamaelia

[10:55] *** MS- Working on Axon 1.6 release notes

[10:59] *** Davbo has joined #kamaelia

[11:02] < MS-> afternoon

[11:03] < Davbo> Afternoon all

[11:33] < Davbo> Haskell is weird.

[11:36] < MS-> It's a functional language. Most functional languages are similar to each other and a different mindset

[11:36] *** vmlemon_ wonders what a dysfunctional language would look like, if someone had the chance to write one (Java?) ;)

[11:37] < MS-> The one I learnt in detail (did multi-thousand line programs in) was SML - which uses strict evaluation rather than lazy evaluation (which of course haskell uses)

[11:37] < MS-> vmlemon_: It'd look like datfuncational language

[11:37] *** Davbo didn't really *get* the strict and lazy stuff

[11:38] < MS-> heh, you of all people should :)

[11:38] < MS-> >>> X = [1,2,3]

[11:38] < MS-> >>> X

[11:38] < MS-> [1, 2, 3]

[11:38] < MS-> X is a value that is a list

[11:39] *** Davbo nods

[11:39] < MS-> >>> def X():

[11:39] < MS-> ... return [1,2,3]

[11:39] < MS-> ...

[11:39] < MS-> >>> for i in X():

[11:39] < MS-> ... print i,

[11:39] < MS-> ...

[11:39] < MS-> 1 2 3

[11:39] < MS-> X() is a function that strictly returns a list of values

[11:40] < MS-> Or rather X() returns the entire iterable

[11:40] < MS-> as a strict response

[11:40] < vmlemon_> *disfunctional

[11:40] < vmlemon_> Stupid typo

[11:40] < MS-> >>> def X():

[11:40] < MS-> ... yield 1

[11:40] < MS-> ... yield 2

[11:40] < MS-> ... yield 3

[11:40] < MS-> ...

[11:40] < MS-> >>> for i in X():

[11:40] < vmlemon_> kamlogbot: poke

[11:40] Reply: Not the eye! Not the eye!

[11:40] < MS-> ... print i,

[11:40] < MS-> ...

[11:40] < MS-> 1 2 3

[11:41] < MS-> X() still returns an iterable, but it lazily generates values on demand

[11:41] < Davbo> oh i see, yeah

[11:41] < MS-> put another way, X() is value which is a strict list

[11:41] < Davbo> it doesn't evaluate until you ask

[11:41] < MS-> in the first case

[11:41] < MS-> and X() is a lazy list

[11:41] < MS-> in the second case

[11:44] < Davbo> thanks MS- i get it now

[11:46] < Davbo> this explains lambda functions too

[11:48] < MS-> Python lambda's aren't quite the same as true lambda's by the way

[11:48] < MS-> They're not as .. clean

[11:48] < MS-> neither the expression form, nor the closure form

[11:48] < MS-> It's something that annoys me about python occasionally

[11:48] < Davbo> Yeah, it's different in Haskell

[11:49] < MS-> Proper lambda's are nice

[11:50] < MS-> Have you done currying yet?

[11:50] < Davbo> it also explains why my lecturer goes on about tree's so much...(the data structure, not the plant)

[11:50] < Davbo> reading about lazy evaluation now it looks like it's all handled in an expression tree

[11:50] *** MS- nods

[11:50] < Davbo> i don't think we've done that

[11:50] < MS-> yep, you don't evaluate it until you need the alue

[11:50] < MS-> /alue/value/

[11:51] < MS-> Currying is in a similar vein

[11:52] < Davbo> this is cool: http://en.wikipedia.org/wiki/Functional_programming#Coding_styles

[11:54] < MS-> compactness does not always equate to comprehensibility though

[11:54] < MS-> Clearest example of that as a language is prolog

[11:54] < MS-> You can do more in less lines in prolog than in many other languages and exponentially less people understand it

[11:55] < Davbo> i suppose so

[11:56] *** Davbo is amazed by how many students didn't seem to *get* recursion of lists in Prolog

[11:56] < Davbo> after 2 lectures on it

[11:57] < Davbo> the pattern is always same, act on the head then post the tail back to the function..

[11:57] < Davbo> My Prolog lecturer is learning Python, I might offer him some lectures ;-)

[12:12] < MS-> heh

[12:12] < MS-> Recursion is a surprisingly difficult concept for people to grasp

[12:13] < MS-> Probably because it's really identical to iteration, but rarely taught that way

[12:13] *** vmlemon_ has joined #kamaelia

[12:13] < Davbo> lists in haskell == http://learnyouahaskell.com/listmonster.png

[12:15] < MS-> Loading for that website == FAIL

[12:17] < Davbo> it's appeared on reddit and hacker news (where all the old redditors have gone, http://news.ycombinator.com )

[12:17] < Davbo> so probably having somewhat of a /. effect

[12:20] < Davbo> oh that's awesome! infinite lists

[12:20] < Davbo> didn't know you could do that

[12:20] < Davbo> side-effect of being lazy i guess

[12:22] < vmlemon_> Hmm, anyone familiar with Google Code?

[12:22] < MS-> vmlemon_: Depends on what you want to know :-)

[12:23] *** vmlemon_ assumes that http://projectname.googlecode.com/svn/ is the "repository URL" for the purposes of configuring the Drupal SVN module...

[12:24] < vmlemon_> Aah, seemed to work

[12:27] < vmlemon_> Meh, they don't seem to give revision numbers in URLs, from what I can tell, unless there's a Special Tecnique

[12:27] < vmlemon_> *Technique

[12:27] < vmlemon_> (Although I'm not that familiar with SVN)

[12:27] < Davbo> don't think that'd be anything to do with svn since it's googles frontend

[12:28] < vmlemon_> Damn

[12:28] < Davbo> right, i'm off to this: http://www.sheffieldoktoberfest.co.uk/

[12:30] < Davbo> cya later chaps!

[12:30] < vmlemon_> See you Davbo

[12:31] *** vmlemon_ didn't know they had an Oktoberfest in Sheffield...

[12:34] < MS-> OK

[12:34] < MS-> An advert for an electronic potato peeler

[12:34] < MS-> That's strange

[12:34] < MS-> "the best a potato can get"

[12:34] < vmlemon_> Where?

[12:34] < MS-> On TV

[12:34] < MS-> gone now

[12:34] < vmlemon_> Hah

[12:34] < MS-> I mean

[12:35] < MS-> *WHY* ?

[12:35] < MS-> It's not like it's any different from a normal potato peeler

[12:35] < MS-> (ie same shape, just has a shaking blade AFAICT)

[12:35] < vmlemon_> Will it magically revive mouldy potatoes, or make them taste better somehow? ;)

[12:36] < MS-> I mean it was a slly add - a mick take of the Gillette razor ads

[12:36] < MS-> but they clearly meant it too

[12:36] < MS-> which is *wierd*

[12:37] *** vmlemon_ wonders if there's ever going to be viable replacement for FAT* that doesn't chew data, and is at least as interoperable between OSes...

[12:38] < vmlemon_> (I've had to repair the FS on my phone's MMC card at least 5 times in the last week, after it somehow ended up getting corrupt and damaged a load of MP3 files in the process)

[12:38] < MS-> SMB is the closest you get really

[12:38] < MS-> but hardly counts

[12:39] < vmlemon_> Although it's been used with at least 4 different implementations, each probably with their own bugs and quirks...

[12:40] < vmlemon_> (Windows XP, Symbian OS, Linux and Mac OS X Leopard, and Mac OS 9 briefly)

[12:42] < vmlemon_> I've seen Linux's dmesg spammed with panic messages whilst trying to read it, long random garbage filenames on Mac OS 9 (just before that box locked up entirely), and lost quite a bit of data in the process (although it wasn't exactly crucial stuff)

[12:44] *** vmlemon_ wonders if there's a problem with the Flash memory chips being crappy/out of spec

[12:54] < MS-> It could be that

[12:54] < MS-> Windows tends to try and mask such error AFAICT

[12:56] < MS-> http://www.kamaelia.org/ReleaseNotes060 - complete release notes for the release

[12:56] < MS-> includes the Axon 1.6 release notes which are here:

[12:56] < MS-> http://www.kamaelia.org/ReleaseNotesAxon160

[13:12] *** MS- goes off for a while

[13:12] < MS-> (though feedback on the new release notes would be very welcome)

[13:12] *** MS- is now known as ms-afk

[13:14] *** vmlemon_ has joined #kamaelia

[13:19] *** vmlemon_ has joined #kamaelia

[14:11] *** vmlemon_ has joined #kamaelia

[14:22] *** vmlemon_ has joined #kamaelia

[15:31] < eikenberry> 3rd Paragraph... first sentence... this bit doesn't sound right.

[15:31] < eikenberry> [...] does mean that you can exceptions thrown if the component [...]

[15:31] < eikenberry> "you can exceptions thrown"?

[16:35] < ms-afk> ta, I'll fix that :)

[17:06] < vmlemon_> Exceptions Pong! ;)

[17:39] *** vmlemon_ has joined #kamaelia