2014-10-02T00:02:47Z Bicyclidine quit (Ping timeout: 258 seconds)
2014-10-02T00:03:52Z drewc1 joined #lisp
2014-10-02T00:03:52Z drewc quit (Read error: Connection reset by peer)
2014-10-02T00:05:15Z drewc joined #lisp
2014-10-02T00:05:22Z drewc1 quit (Read error: Connection reset by peer)
2014-10-02T00:05:45Z slyrus quit (Ping timeout: 272 seconds)
2014-10-02T00:06:26Z hellome joined #lisp
2014-10-02T00:07:22Z drewc quit (Client Quit)
2014-10-02T00:07:36Z wizzo quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
2014-10-02T00:07:42Z drewc joined #lisp
2014-10-02T00:09:50Z drewc quit (Client Quit)
2014-10-02T00:10:02Z drewc joined #lisp
2014-10-02T00:10:47Z harish quit (Ping timeout: 272 seconds)
2014-10-02T00:20:01Z innertracks quit (Quit: innertracks)
2014-10-02T00:20:06Z RenRenJuan quit (Quit: This computer has gone to sleep)
2014-10-02T00:26:45Z jamfade joined #lisp
2014-10-02T00:27:07Z innertracks joined #lisp
2014-10-02T00:30:46Z rme joined #lisp
2014-10-02T00:31:48Z zz_karupa is now known as karupa
2014-10-02T00:32:54Z jamfade quit (Quit: Leaving)
2014-10-02T00:36:44Z ltbarcly joined #lisp
2014-10-02T00:37:22Z Soft quit (Ping timeout: 245 seconds)
2014-10-02T00:37:59Z jkaye joined #lisp
2014-10-02T00:39:16Z Soft joined #lisp
2014-10-02T00:39:57Z [1]cneira joined #lisp
2014-10-02T00:40:28Z ltbarcly quit (Client Quit)
2014-10-02T00:41:01Z Hache__ joined #lisp
2014-10-02T00:41:11Z nand1 quit (Remote host closed the connection)
2014-10-02T00:41:37Z frkout_ quit (Remote host closed the connection)
2014-10-02T00:42:04Z frkout joined #lisp
2014-10-02T00:42:08Z cneira quit (Ping timeout: 260 seconds)
2014-10-02T00:42:08Z [1]cneira is now known as cneira
2014-10-02T00:42:22Z jkaye quit (Ping timeout: 240 seconds)
2014-10-02T00:43:57Z blakbunnie27 quit (Ping timeout: 272 seconds)
2014-10-02T00:45:53Z nand1 joined #lisp
2014-10-02T00:50:47Z nonamae joined #lisp
2014-10-02T00:56:09Z karswell` joined #lisp
2014-10-02T00:56:52Z kirin` quit (Ping timeout: 240 seconds)
2014-10-02T00:57:13Z gigetoo quit (Ping timeout: 258 seconds)
2014-10-02T00:57:52Z gigetoo joined #lisp
2014-10-02T01:00:30Z theseb joined #lisp
2014-10-02T01:01:16Z theseb: I was here earlier and people weren't excited about Clojure......Why aren't more CLispers excited about Clojoure since by targeting the platform you get sooo much library support?
2014-10-02T01:01:39Z theseb: isn't that a big whine from lisp haters?....they whine that CLisp doesn't have good libraries for buzzword X?
2014-10-02T01:01:48Z theseb: java stdlib has all buzzwords covered!?
2014-10-02T01:02:02Z theseb: yes?
2014-10-02T01:02:29Z kirin` joined #lisp
2014-10-02T01:02:35Z Bike: i don't think i've heard that. there are lots of libraries.
2014-10-02T01:02:36Z tadni joined #lisp
2014-10-02T01:04:05Z theseb: Bike: my meta question i guess is why more lang designers don't target the JVM since you get soo much *documented* libraries immediately?
2014-10-02T01:04:39Z ndrei joined #lisp
2014-10-02T01:04:53Z Bike: jvm is more an implementation thing than a language thing, and anyway plenty of systems target the jvm
2014-10-02T01:05:01Z Bike: plenty target something that can call out to c functions too
2014-10-02T01:05:24Z tadni quit (Read error: Connection reset by peer)
2014-10-02T01:06:07Z theseb: Bike: yes but I doubt there are C libraries for all the web tech like there is for Java...XML,SOAP, RSS, etc.
2014-10-02T01:06:27Z Bike: http://xmlsoft.org/ ...?
2014-10-02T01:07:49Z theseb: Bike: C is not known as a web dev friendly lang
2014-10-02T01:07:53Z theseb: that's all i'm sayin
2014-10-02T01:08:08Z theseb: clisp would make much more sense to do a web app
2014-10-02T01:08:09Z pjb: theseb: yes, basically there are such C libraries.  You'd have to search for quite an esoteric java library to have one without equivalent in C.
2014-10-02T01:08:25Z pjb: theseb: Common Lisp.
2014-10-02T01:08:46Z pjb: theseb: For web apps, you want good support for threads.
2014-10-02T01:08:56Z theseb: pjb: yes
2014-10-02T01:08:59Z pjb: It's easier to get it with sbcl than with clisp.
2014-10-02T01:09:18Z tadni joined #lisp
2014-10-02T01:09:40Z theseb: pjb, Bike: if i may ask 1 more meta question....is there any reason all lispers would *not* give clojure the love?  it seems to be trying real hard to be a good fresh new lisp
2014-10-02T01:10:01Z pjb: theseb: Clojure is not exiting because 1- it is not a common lisp, 2- there is already ABCL and CLforJava to run on JVM.
2014-10-02T01:10:13Z Bike: i'm not into "lisp" as a platonic ideal, I just like CL
2014-10-02T01:10:16Z oGMo: theseb: because a "fresh new lisp" isn't what's necessary
2014-10-02T01:10:19Z White_Flame: many lispers don't care about the pure functional aspects that clojure focuses on
2014-10-02T01:11:04Z innertracks quit (Ping timeout: 260 seconds)
2014-10-02T01:11:04Z oGMo: theseb: e.g., CL isn't perfect, but the issues are not the ones the vast majority of people think they are
2014-10-02T01:11:14Z theseb: White_Flame: fair enough.
2014-10-02T01:12:00Z White_Flame: In general, clojure doesn't solve problems that most CL have with CL
2014-10-02T01:12:13Z theseb: White_Flame: i'm not a language expert but i'm *guessing* concurrency would be something people will care about when we all have 64 core motherboards
2014-10-02T01:12:20Z White_Flame: and given how plastic the language is, most people solve problems with CL that they encounter with more CL
2014-10-02T01:12:47Z White_Flame: concurrency is something you get or write a good library for that meshes with your application semantics, then use it
2014-10-02T01:12:52Z oGMo: CL has no problem with concurrency
2014-10-02T01:13:33Z wilfredh quit (Quit: Connection closed for inactivity)
2014-10-02T01:13:48Z White_Flame: I'm sure the same situation exists in Clojure:  individual apps either have a library or a set of internal policies that all concurrency is written against
2014-10-02T01:15:14Z White_Flame: The one thing that I believe many lispers would admire about clojure is the ability to extend the fundamental stdlib functions with new types, since things like map and length aren't generic methods
2014-10-02T01:15:15Z theseb: White_Flame: i think to do concurrency / multicore programming as easy as possible you need to minimize amount of *state* you carry around
2014-10-02T01:15:20Z askatasuna joined #lisp
2014-10-02T01:15:50Z White_Flame: theseb: for various definitions of "carry around"
2014-10-02T01:15:57Z theseb: White_Flame: CLisp and Scheme don't *force* you to have a lot of state but i think Haskell and Clojure try harder to erect 10 ft high walls against you adding more state
2014-10-02T01:16:08Z White_Flame: inside a function body, being able to bang whatever you like, as long as the external semantics are safe, should be fine
2014-10-02T01:16:23Z tadni: theseb: CL and Scheme*
2014-10-02T01:16:24Z pjb: theseb: fucking NOT clisp!
2014-10-02T01:16:35Z pjb: theseb: clisp is an implementation, Common Lisp is a language!
2014-10-02T01:16:59Z theseb: pjb: lol...ok :)
2014-10-02T01:17:23Z blakbunnie27 joined #lisp
2014-10-02T01:18:40Z oGMo: White_Flame: there's a system somehwere that provides a :cl replacement package with everything as GFs
2014-10-02T01:18:44Z theseb: White_Flame: i just thought of something....you know how perl has "use strict;"?  what if CL had a command that disallowed use of state changing commands!?!?!?
2014-10-02T01:18:58Z theseb: my point is there are ways to get the 100% pure functional ideal in CL!
2014-10-02T01:18:59Z White_Flame: oGMo: right, hence the "most people solve problems with CL that they encouner with more CL" :)
2014-10-02T01:18:59Z theseb: yes?
2014-10-02T01:19:06Z oGMo: White_Flame: hehe
2014-10-02T01:19:40Z White_Flame: theseb: and that could potentially be done from "user" code in CL itself
2014-10-02T01:19:52Z Bike: it would be nice to have a declaration like no-consing and such
2014-10-02T01:19:58Z theseb: White_Flame: yes...maybe call it "use functional"
2014-10-02T01:20:00Z Bike: or to be able to implement such a thing yourself
2014-10-02T01:20:07Z oGMo: i think the real "issue" most people will ever encounter you can't just solve easily are package-local nicknames
2014-10-02T01:20:30Z White_Flame: Bike: since one of my back-burner ideas is a lisp implementation with its runtime written in CL, I agree
2014-10-02T01:21:01Z theseb: Bike: what is the problem with consing? i'm intrigued
2014-10-02T01:21:24Z Bike: in certain kinds of code you don't want to spend time allocating and running the gc, is all
2014-10-02T01:21:29Z White_Flame: theseb:  for me, you can't write a GC in Lisp if that Lisp is allocating memory itself
2014-10-02T01:21:35Z theseb: ah
2014-10-02T01:21:40Z theseb: optimization
2014-10-02T01:21:57Z oGMo: White_Flame: why not?
2014-10-02T01:22:18Z White_Flame: well, it makes it a bit harder :)
2014-10-02T01:22:27Z White_Flame: (for varying definitions of "a bit")
2014-10-02T01:22:51Z oGMo: shouldn't be a lot .. even if your GC allocates, your GC is not the memory allocator
2014-10-02T01:23:05Z harish joined #lisp
2014-10-02T01:23:07Z theseb: White_Flame: i can see how cons allocates more memory but even without cons you can allocate new memory too right?.. e.g. (list 1 2 3) ??
2014-10-02T01:23:09Z oGMo: granted it would be a bit silly for it to allocate in the heap
2014-10-02T01:23:15Z theseb: White_Flame: sorry if that's a dumb question
2014-10-02T01:23:25Z White_Flame: theseb: "consing" is the general term for "memory allocation" in Lisp, even if it doesn't use cons cells
2014-10-02T01:23:40Z nyef: And LIST is usually defined in terms of CONS anyway...
2014-10-02T01:23:54Z theseb: White_Flame: holy moly...so for optimization you want to avoid creating new lists completely?
2014-10-02T01:23:57Z theseb: wow that would be hardcore
2014-10-02T01:24:00Z Bike: sometimes, yeah.
2014-10-02T01:24:03Z pjb: theseb: there are no command in Common Lisp.
2014-10-02T01:24:03Z zRecursive joined #lisp
2014-10-02T01:24:05Z Bike: it's not that bad.
2014-10-02T01:24:13Z Bike: for instance you can imagine some code doing some complicated arithmetic on floats.
2014-10-02T01:24:18Z White_Flame: theseb: that's a general optimization in any GC'd langauge
2014-10-02T01:24:19Z Bike: no need to allocate memory on the heap for that.
2014-10-02T01:24:48Z oGMo: theseb: not really :p
2014-10-02T01:24:48Z White_Flame: and even in non-GC'd languages
2014-10-02T01:25:09Z theseb: anyone worried about that level of optimization i'm guessing is making the big bucks doing some hardcore cl programming
2014-10-02T01:25:15Z theseb: very cool
2014-10-02T01:25:23Z Bike: you sure are optimistic
2014-10-02T01:25:36Z White_Flame: or you're doing things a billion times, and the GC (or alloc/dealloc in other languages) load is significant
2014-10-02T01:26:12Z oGMo: o.O
2014-10-02T01:26:30Z White_Flame: theseb: I guess you've never heard of memory pools?
2014-10-02T01:26:45Z White_Flame: preallocated buffers?  etc.  all the same concept
2014-10-02T01:26:50Z pjb: White_Flame: I've only written garbage collectors in Common Lisp, never in any other language.  So I wouldn't know.
2014-10-02T01:27:51Z theseb: White_Flame: no :)
2014-10-02T01:27:56Z White_Flame: pjb:  plain CL GCs that collect their own environment?
2014-10-02T01:27:57Z pjb: theseb: the key word is "new", not "list".
2014-10-02T01:28:47Z pjb: White_Flame: not really, but think about it!  A garbage collector algorithm won't generate garbage.  So with a little care, you can write it in lisp easily.
2014-10-02T01:29:25Z White_Flame: right, the "with a little care", ie programmer policy.  Which would be assisted if you had declarations to that effect
2014-10-02T01:29:36Z nyef: pjb: That's a little bit disingenuous, given things like closure allocation, bignum consing, SAP boxing, and so on.
2014-10-02T01:30:12Z pjb: Yes.  You often need to do closures and bignums when collecting garbage. Sure.
2014-10-02T01:30:33Z patilana joined #lisp
2014-10-02T01:30:45Z harish quit (Ping timeout: 260 seconds)
2014-10-02T01:31:08Z nyef: On the other hand, I did at one point start looking at implementing a GC for SBCL in Lisp.
2014-10-02T01:31:27Z pjb: Perhaps sbcl is particularly hard in this respect?
2014-10-02T01:31:33Z White_Flame: In toying around with writing new GCs, it would be very handy not to have to extremely massage your plain lisp code in order to follow constraints
2014-10-02T01:31:47Z White_Flame: (meaning the code implementing the GC itself)
2014-10-02T01:33:14Z White_Flame: The core idea behind my thinking is to have thread- or job-specific heaps, and deal with cross-heap references, independent complete collections within a heap that don't stop other tasks, etc
2014-10-02T01:33:22Z pjb: You can do that by writing a specific compiler for your gc code.
2014-10-02T01:33:36Z White_Flame: so having a Lisp-language testbed for playing with GC concepts is a nice idea
2014-10-02T01:33:54Z White_Flame: well yeah
2014-10-02T01:33:57Z nyef: Oh, the other aspect was how do you make sure that you don't break anything when processing the parts of the heap containing your GC.
2014-10-02T01:34:04Z Bike: "a little care" -> "just write your own compiler!"
2014-10-02T01:34:12Z nyef: Movitz has its GC in Lisp, IIRC.
2014-10-02T01:34:25Z pjb: Movitz doesn't have a GC, IIRC.
2014-10-02T01:34:52Z nyef: minion: Movitz?
2014-10-02T01:34:52Z minion: Movitz: No definition was found in the first 5 lines of http://www.cliki.net/Movitz
2014-10-02T01:34:56Z davazp quit (Remote host closed the connection)
2014-10-02T01:35:22Z nyef: Hrm.
2014-10-02T01:35:53Z nyef: http://common-lisp.net/project/movitz/movitz.html says that there's a stop-and-copy Cheney collector.
2014-10-02T01:36:22Z Zhivago: You really want something like processes to do that.
2014-10-02T01:36:38Z Zhivago: Then you can write a GC for a process's memory which runs outside of the process.
2014-10-02T01:36:55Z Bike: "slightly more than 2 MB of RAM (the less you have, the sooner you run out..)"
2014-10-02T01:37:21Z DTSCode quit (Read error: Connection reset by peer)
2014-10-02T01:37:40Z nyef: That was the classic way of using a LispM anyway, wasn't it? No GC, run it until it runs out of memory, then reboot...
2014-10-02T01:38:47Z pillton: nyef: People must have done very little back then.
2014-10-02T01:39:01Z White_Flame: or avoided consing as much as possible
2014-10-02T01:39:26Z nyef: They wrote an entire emacs-type text editor to cons basically nothing in normal operation.
2014-10-02T01:40:15Z White_Flame: I'd bet money that function names like rplacd came about from that era
2014-10-02T01:40:22Z nyef: Earlier.
2014-10-02T01:40:27Z Bike: sheesh. you know, i built boehm yesterday, and it actually comes with an example library using it... for string manipulation as for text editors
2014-10-02T01:40:32Z nyef: IIRC, it's a machine instruction name.
2014-10-02T01:40:52Z nyef: For some IBM mainframe, I think?
2014-10-02T01:42:08Z White_Flame: but destructive operations on cons cells themselves being integrated into Lisp smells like a "before we had GC working" motivation
2014-10-02T01:42:40Z White_Flame: even if the asm operation existed before then
2014-10-02T01:43:04Z Bike: lisp 1.5 had gc
2014-10-02T01:43:09Z nyef: Well, yes and no. Remember that the original set of data types was spectacularly poor.
2014-10-02T01:43:18Z Bike: have you seen that old code? it sure ain't "functional programming"
2014-10-02T01:43:20Z nyef: Something like conses, integers, and symbols.
2014-10-02T01:43:33Z White_Flame: weren't symbols called 'atoms' back then?
2014-10-02T01:43:34Z harish joined #lisp
2014-10-02T01:43:49Z Bike: no, that's non-conses generally
2014-10-02T01:44:06Z Bike: they used symbols as strings and such, though
2014-10-02T01:44:07Z White_Flame: then again, the early mccarthy examples likely only had conses & symbols/atoms, no numbers
2014-10-02T01:44:08Z pillton: Zhivago: I like that idea. You could have a NULL GC that errors if you try and allocate something.
2014-10-02T01:44:10Z Bike: i think they even did that in maclisp
2014-10-02T01:44:47Z emma quit (Ping timeout: 245 seconds)
2014-10-02T01:44:47Z Bike: it's been a while since i read mccarthy but i think there were numbers. it's not like list structure was a design goal (see: m expressions)
2014-10-02T01:44:50Z theseb: does anyone find this as mind bendingly interesting as i do?....for *years* i've read how CL lists are "really conses"....clojure doesn't have the concept of conses...in clojure lists are lists are lists!!!! they broke the mold!
2014-10-02T01:45:12Z theseb: there is nothing "more fundamental" than a list
2014-10-02T01:45:13Z theseb: i like it
2014-10-02T01:45:17Z Bike: lists without conses is from uh, well i've read some 80s papers doing it
2014-10-02T01:45:38Z White_Flame: isn't that fundamental abstraction in Clojure called a "sequence"?
2014-10-02T01:45:55Z Bike: and yeah, it's not like vectors are too novel, though using them for code is approaching it
2014-10-02T01:46:03Z Bike: (also in 80s papers though)
2014-10-02T01:46:14Z White_Flame: Forth = code as vectors
2014-10-02T01:46:28Z Bike: oh, true
2014-10-02T01:46:35Z nyef: And if you want a Forth-like language with GC, there's Factor.
2014-10-02T01:46:44Z theseb: Bike: i've just always had this secret aversion to conses....so it just enforces my opinion that an entire popular lisp agrees with me...that's all...i just got validated
2014-10-02T01:46:52Z blakbunnie27 quit (Ping timeout: 245 seconds)
2014-10-02T01:46:56Z theseb: Bike: i realize ymmv
2014-10-02T01:46:58Z Bike: ok
2014-10-02T01:46:59Z emma joined #lisp
2014-10-02T01:47:31Z theseb: if anyone cares....i just find lists so beautifully simple powerful and elegant...conses not so much
2014-10-02T01:47:44Z White_Flame: theseb: conses are a low-level building block.  Clojure deals more with interfaces than concreteness
2014-10-02T01:47:50Z pillton: theseb: That doesn't make sense.
2014-10-02T01:47:50Z theseb: conses seem to add a lot of complexity w/o much gain
2014-10-02T01:47:58Z White_Flame: conses don't just build lists, but also trees
2014-10-02T01:47:59Z theseb: it is just a matter of taste..that's all
2014-10-02T01:48:04Z White_Flame: and hold key/value pairs
2014-10-02T01:48:29Z nyef: For what it's worth, my troll detector pinged quite a while ago.
2014-10-02T01:49:11Z theseb: pillton: imagine trying to explain lists to a newb... (1 2 3) is clean and simple....now try writing out the cons representation..i think you'd agree it is a big more complex?
2014-10-02T01:49:30Z theseb: pillton: that's all...(1 . (2 . (3 . nil)))
2014-10-02T01:49:41Z theseb: nyef: *sigh*
2014-10-02T01:49:50Z pillton: Education and conses are orthogonal.
2014-10-02T01:50:25Z White_Flame: theseb: why would you get into conses for newbie orientation?
2014-10-02T01:50:29Z chu joined #lisp
2014-10-02T01:50:47Z White_Flame: of course, you can show the benefits of tail-consing, learn about the pros & cons of singly-linked list structure, show how trees are done, etc
2014-10-02T01:50:54Z White_Flame: depending on how far "newbie" goes
2014-10-02T01:51:00Z pillton: I don't teach my son about numbers using polar representation.
2014-10-02T01:52:12Z White_Flame: besides, clojure looks an awful lot like Lisp here: http://clojure.org/sequences
2014-10-02T01:52:22Z White_Flame: again, interface vs concreteness
2014-10-02T01:52:50Z theseb: White_Flame: i shall read..thanks
2014-10-02T01:52:58Z White_Flame: ???
2014-10-02T01:53:01Z White_Flame: that's new to you?
2014-10-02T01:53:06Z theseb: no :)
2014-10-02T01:53:25Z White_Flame: I just meant the interface itself.  first, rest, & cons
2014-10-02T01:54:21Z theseb: White_Flame: are conses basically about optimization?
2014-10-02T01:54:42Z theseb: White_Flame: i.e. that's the best way to implement lists on a tiny amount of memory?
2014-10-02T01:55:05Z White_Flame: I don't know how to answer that
2014-10-02T01:55:25Z White_Flame: the question itself seems to belie certain non-understanding
2014-10-02T01:55:40Z White_Flame: conses are a linked datastructure building block
2014-10-02T01:55:58Z White_Flame: clojure also builds its sequences on Lisp's cons functionality
2014-10-02T01:56:17Z theseb: White_Flame: i'm trying to figure out why in the little lisp that i do conses don't seem that important....i don't worry about optimization so i wondered if that is why conses don't seem to interest me that much
2014-10-02T01:56:24Z White_Flame: but clojure itself is about "optimization" in that respect, since it can choose which underlying data structure to use to expose Lisp's cons interface
2014-10-02T01:57:03Z White_Flame: conses are a building block that the standard functions use
2014-10-02T01:57:37Z White_Flame: so you don't have to directly interact with cons cells yourself that much, depending on what you're doing
2014-10-02T01:57:56Z theseb: White_Flame: ok..that's what i wanted to verify
2014-10-02T01:57:57Z theseb: thanks
2014-10-02T01:58:24Z ltbarcly joined #lisp
2014-10-02T01:58:28Z theseb: White_Flame: i think it is kind of elegant to avoid interacting with cons cells explicitly...keeping everything in terms of lists
2014-10-02T01:58:44Z White_Flame: what's the difference?
2014-10-02T01:59:06Z White_Flame: a list is simply defined as a bunch of cons cells cdr'd (or rest'd) together
2014-10-02T01:59:14Z White_Flame: even in Clojure
2014-10-02T01:59:21Z theseb: White_Flame: my brain can easily understand lists....they are just ordered sets of elements...as a math guy i see that kind of stuff all the time
2014-10-02T01:59:33Z theseb: White_Flame: cons cells otoh i'm not sooo used to...that's part of it
2014-10-02T01:59:49Z White_Flame: what is one "slot" in a list called?
2014-10-02T02:00:03Z theseb: an element perhaps
2014-10-02T02:00:10Z White_Flame: no, that's the contents of the slot
2014-10-02T02:00:13Z theseb: expression
2014-10-02T02:00:18Z Adlai joined #lisp
2014-10-02T02:00:24Z theseb: if not expression then i don't know
2014-10-02T02:00:25Z White_Flame: the slot itself is a cell
2014-10-02T02:00:31Z theseb: ah
2014-10-02T02:00:35Z White_Flame: ie, a cons cell in Lisp/Clojure/etc
2014-10-02T02:00:40Z White_Flame: there's no difference
2014-10-02T02:00:52Z theseb: White_Flame: wait..i thought cons cells were *pairs*
2014-10-02T02:00:58Z theseb: White_Flame: hence i see stuff like (a . b)
2014-10-02T02:01:07Z White_Flame: right.  THe first half holds the element, the second half chains itself to the list
2014-10-02T02:01:25Z theseb: right
2014-10-02T02:01:43Z White_Flame: so technically, the "cell" would be the car of the cons cell, since that's where the element lives
2014-10-02T02:01:57Z theseb: yes
2014-10-02T02:02:07Z DTSCode joined #lisp
2014-10-02T02:02:14Z White_Flame: but the cons cell needs to exist, to have that slot be in a list, not just floating off in the heap on its own
2014-10-02T02:02:32Z patilana quit (Quit: Going to sleep)
2014-10-02T02:02:41Z White_Flame: so there is no separation of a list and how a single element is contained in a list, hence cons cells
2014-10-02T02:03:03Z White_Flame: and again, there's no difference in Clojure's & Lisp's  view of a list
2014-10-02T02:04:34Z theseb: "but the cons cell needs to exist, to have that slot be in a list, not just floating off in the heap on its own" <--- but that's an implementation detail....my point is from a mathematical "I don't care about optimization" perspective....you don't need to know or care about conses ..see what i mean about being mainly about implementation/optimization?
2014-10-02T02:04:47Z White_Flame: it's not an implementation detail
2014-10-02T02:04:51Z White_Flame: a slot is "in a list"
2014-10-02T02:05:08Z theseb: yes
2014-10-02T02:05:09Z White_Flame: or else it's just some storage somewhere, akin to (defvar *a* 3)
2014-10-02T02:05:14Z White_Flame: that is not a list member
2014-10-02T02:05:38Z theseb: White_Flame: e.g. Python has lists but no conses...NO ONE is Python land knows what is cons is....
2014-10-02T02:05:41Z White_Flame: with (cons 3 . x), in either clojure or lisp, that defines the _slot_ which _holds_ 3 as part of the list that continues on into x
2014-10-02T02:06:00Z theseb: White_Flame: iirc..CL people would say Python is using *vectors*
2014-10-02T02:06:44Z White_Flame: from what I understand of Python, correct.  I don't think it uses linked-list semantics
2014-10-02T02:07:06Z theseb: White_Flame: everywhere in CL that is list is used a vector could be used instead right?
2014-10-02T02:07:17Z harish quit (Ping timeout: 245 seconds)
2014-10-02T02:07:20Z theseb: White_Flame: and vectors aren't thought of as being made of conses right?
2014-10-02T02:07:40Z White_Flame: this is pre-CS101 stuff
2014-10-02T02:07:44Z theseb: White_Flame: in short..perhaps what i'm trying to say is I'd like to build my own lisp on the foundation of vectors instead of lists
2014-10-02T02:08:12Z theseb: maybe that's the way to summarize what i'm (badlly) trying to say
2014-10-02T02:08:23Z White_Flame: vectors are less capable than lists
2014-10-02T02:08:39Z White_Flame: you'd have to chop them up and copy bits together in order to perform linked list operations
2014-10-02T02:08:42Z zRecursive: Is vectore much like array ?
2014-10-02T02:08:47Z White_Flame: and you can't have them share sub-spans of  data
2014-10-02T02:08:58Z phadthai: an exemple where conses are handy is http://www.lispworks.com/documentation/HyperSpec/Body/f_car_c.htm
2014-10-02T02:09:07Z phadthai: s/exemple/example/
2014-10-02T02:09:17Z kristof joined #lisp
2014-10-02T02:09:40Z scottj joined #lisp
2014-10-02T02:10:04Z theseb: White_Flame: huh?  why couldn't you write code to make vectors do whatever you want including the 2 items you mentioned?
2014-10-02T02:10:13Z Zhivago: A vector is a one dimensional array, in CL.
2014-10-02T02:10:31Z zRecursive: There is #(1 2 3) but why isnot there #a(1 2 3) in CL ?
2014-10-02T02:10:39Z White_Flame: theseb: how would you make 2 vectors share their last N elements, so if you changed the value in 1, it would reflect in the other?
2014-10-02T02:10:58Z White_Flame: manual copying at the vector interface, I guess
2014-10-02T02:11:06Z White_Flame: but vectors are a TON more work than lists for many operations
2014-10-02T02:11:21Z zRecursive: Zhivago: oh, i see now
2014-10-02T02:11:32Z theseb: White_Flame: see...you're proving my point...you're bringing up optimization issues again!
2014-10-02T02:11:40Z White_Flame: again, basic CS101 stuff, the difference between vectors and linked lists.  if you aren't familiar with the tradeoffs between the two, I'm not going to sit hear and tutor you on it
2014-10-02T02:12:09Z White_Flame: theseb: it's not optimization, it's complexity, usability, atomicity, and robustness
2014-10-02T02:12:44Z theseb: White_Flame: ok....thanks for the help....i think i understand things a little better now
2014-10-02T02:13:25Z lisper29 joined #lisp
2014-10-02T02:14:30Z theseb: White_Flame: wait..there must be a way to make vectors have good qualities in all cases...otherwise Python would be known as a complex mess which it isn't
2014-10-02T02:14:49Z segmond joined #lisp
2014-10-02T02:14:50Z ltbarcly_ joined #lisp
2014-10-02T02:15:01Z White_Flame: theseb: Honestly, I don't think you have enough fundamental understanding in order to make the judgment calls you wish to make
2014-10-02T02:15:13Z theseb: ok..perhaps...thanks again..i'll read more
2014-10-02T02:15:27Z theseb: interesting stuff
2014-10-02T02:15:37Z kristof: do displaced arrays not do what's being discussed?
2014-10-02T02:16:07Z White_Flame: (cons 1 . x), (cons 2 . x), mutate x, no
2014-10-02T02:16:27Z ltbarcly quit (Ping timeout: 245 seconds)
2014-10-02T02:17:19Z theseb: good byes
2014-10-02T02:17:24Z Bike: you can't have an array that's part original and part displaced
2014-10-02T02:17:25Z nyef: Hunh. ACONS is a standard function? Neat.
2014-10-02T02:17:25Z White_Flame: bye
2014-10-02T02:17:26Z theseb quit (Quit: Page closed)
2014-10-02T02:19:45Z harish joined #lisp
2014-10-02T02:26:49Z msx joined #lisp
2014-10-02T02:27:58Z ltbarcly joined #lisp
2014-10-02T02:28:09Z |xk05| quit (Ping timeout: 260 seconds)
2014-10-02T02:29:01Z erikc joined #lisp
2014-10-02T02:29:33Z ltbarcly_ quit (Ping timeout: 260 seconds)
2014-10-02T02:30:06Z jusss joined #lisp
2014-10-02T02:30:07Z jusss` joined #lisp
2014-10-02T02:30:43Z White_Flame quit (Remote host closed the connection)
2014-10-02T02:31:06Z White_Flame joined #lisp
2014-10-02T02:32:31Z Colleen_ joined #lisp
2014-10-02T02:33:15Z Colleen quit (Quit: See you, space cowboy...)
2014-10-02T02:33:15Z Colleen_ is now known as Colleen
2014-10-02T02:33:59Z guicho joined #lisp
2014-10-02T02:39:16Z jusss` quit (Remote host closed the connection)
2014-10-02T02:39:17Z jusss quit (Remote host closed the connection)
2014-10-02T02:40:02Z jusss joined #lisp
2014-10-02T02:46:23Z blakbunnie27 joined #lisp
2014-10-02T02:49:57Z MrWoohoo quit (Quit: ["Textual IRC Client: www.textualapp.com"])
2014-10-02T02:50:30Z Colleen_ joined #lisp
2014-10-02T02:51:13Z jusss` joined #lisp
2014-10-02T02:51:38Z Colleen quit (Quit: See you, space cowboy...)
2014-10-02T02:51:38Z Colleen_ is now known as Colleen
2014-10-02T02:53:56Z jusss quit (Ping timeout: 250 seconds)
2014-10-02T02:55:45Z ltbarcly quit (Quit: Computer has gone to sleep.)
2014-10-02T02:57:18Z blakbunnie27 quit (Read error: Connection timed out)
2014-10-02T02:57:38Z chu quit (Quit: ERC Version 5.3 (IRC client for Emacs))
2014-10-02T03:00:53Z blakbunnie27 joined #lisp
2014-10-02T03:02:06Z ltbarcly joined #lisp
2014-10-02T03:06:40Z svetlyak40wt joined #lisp
2014-10-02T03:10:04Z kristof quit (Ping timeout: 260 seconds)
2014-10-02T03:10:05Z zacharias_ joined #lisp
2014-10-02T03:12:47Z zacharias quit (Ping timeout: 245 seconds)
2014-10-02T03:13:25Z killmaster quit (Ping timeout: 260 seconds)
2014-10-02T03:14:00Z killmaster joined #lisp
2014-10-02T03:20:48Z tadni quit (Ping timeout: 260 seconds)
2014-10-02T03:25:58Z simulacrum joined #lisp
2014-10-02T03:28:58Z erikc quit (Quit: erikc)
2014-10-02T03:29:39Z someone quit (Quit: ZNC - http://znc.in)
2014-10-02T03:30:36Z nonamae quit (Ping timeout: 260 seconds)
2014-10-02T03:35:38Z rme quit (Quit: rme)
2014-10-02T03:37:06Z lisper29 quit (Quit: This computer has gone to sleep)
2014-10-02T03:38:42Z ltbarcly quit (Quit: Computer has gone to sleep.)
2014-10-02T03:41:31Z Vivitron quit (Read error: Connection reset by peer)
2014-10-02T03:41:43Z slyrus joined #lisp
2014-10-02T03:42:00Z Vivitron joined #lisp
2014-10-02T03:42:21Z hiyosi quit (Ping timeout: 272 seconds)
2014-10-02T03:43:24Z tadni joined #lisp
2014-10-02T03:43:50Z sheilong quit (Quit: Konversation terminated!)
2014-10-02T03:46:11Z svetlyak40wt quit (Remote host closed the connection)
2014-10-02T03:47:37Z jusss` quit (Remote host closed the connection)
2014-10-02T03:51:13Z cneira quit (Ping timeout: 260 seconds)
2014-10-02T03:55:39Z kobain quit (Quit: KVIrc 4.1.3 Equilibrium http://www.kvirc.net/)
2014-10-02T03:58:37Z ivan\ quit (Quit: ERC Version 5.3 (IRC client for Emacs))
2014-10-02T03:59:16Z jleija joined #lisp
2014-10-02T04:00:14Z nyef quit (Quit: G'night all.)
2014-10-02T04:04:41Z gingerale joined #lisp
2014-10-02T04:06:22Z emma quit (Ping timeout: 240 seconds)
2014-10-02T04:06:31Z beach joined #lisp
2014-10-02T04:06:40Z beach: Good morning everyone!
2014-10-02T04:06:47Z slyrus: morning beach
2014-10-02T04:06:53Z pillton: Hey beach.
2014-10-02T04:06:53Z emma joined #lisp
2014-10-02T04:07:37Z _xyjprc_: Good to see many are awake! I was trying to collect every line of file to a list, as in http://paste.lisp.org/display/143911  the code works perfect when file is small; when file exceeds ~80MB (~16380 lines), SBCL is stuck... Any ideas?
2014-10-02T04:08:26Z zRecursive quit (Remote host closed the connection)
2014-10-02T04:08:28Z hiyosi joined #lisp
2014-10-02T04:08:51Z beach: stuck?
2014-10-02T04:09:43Z _xyjprc_: Seems the reading never ends, code after this doesn't execute; no CPU utilization or whatever...
2014-10-02T04:11:04Z ndrei quit (Ping timeout: 272 seconds)
2014-10-02T04:11:06Z phao quit (Quit: Leaving)
2014-10-02T04:11:14Z pillton: Emacs might be trying to print it.
2014-10-02T04:11:28Z pillton: Try (read-lines-from-file "filename.txt") nil
2014-10-02T04:11:34Z ndrei joined #lisp
2014-10-02T04:11:44Z pillton: Or (length (read-lines-from-file "filename.txt"))
2014-10-02T04:12:27Z Hache__ quit (Remote host closed the connection)
2014-10-02T04:13:10Z hiyosi quit (Ping timeout: 244 seconds)
2014-10-02T04:14:37Z beach: Yeah, it's probably the printing.
2014-10-02T04:15:08Z drmeister: Hello beach.
2014-10-02T04:15:28Z beach: Hi drmeister.
2014-10-02T04:15:42Z beach: _xyjprc_: Did you fix it?
2014-10-02T04:20:04Z ndrei quit (Ping timeout: 260 seconds)
2014-10-02T04:21:54Z beach: _xyjprc_: Anyway, it is working fine for me (except that PRINTF doesn't exist, of course), as long as I do something like (progn (read-lines-from-file ...) nil).
2014-10-02T04:22:34Z _xyjprc_: The whole line calling that function is like (shift-cascades (filter-cascades (build-cascades (read-lines-from-file *infile*)))))  so I guess emacs should not be printing something as its results should be passed to build-cascades and further functions
2014-10-02T04:22:58Z jleija quit (Quit: leaving)
2014-10-02T04:23:22Z _xyjprc_: That's interesting, even if the file you are trying to read is larger than 100MB and has >20000 lines?
2014-10-02T04:23:34Z beach: _xyjprc_: Then your problem is in the calling function, because the one you submitted works fine.
2014-10-02T04:23:51Z beach: Yes, 150MB.
2014-10-02T04:23:53Z Bike: well, have you tried (progn (read-lines-from-file ...) nil) yourself, before you do the build-cascades and all?
2014-10-02T04:25:28Z _xyjprc_: Unfortunately it doesn't work
2014-10-02T04:25:40Z ndrei joined #lisp
2014-10-02T04:25:42Z beach: What happens when you try?
2014-10-02T04:25:51Z kobain joined #lisp
2014-10-02T04:26:09Z White_Flame: are you swap thrashing?
2014-10-02T04:26:47Z White_Flame: did you check the *inferior-lisp* buffer to see if SBCL died?
2014-10-02T04:27:06Z _xyjprc_: "[begin] read file" is printed, nothing else, because I should have "[begin] dealing with cascades" printed if that finishes correctly
2014-10-02T04:27:08Z _xyjprc_: let me see
2014-10-02T04:27:23Z Bike: no, look, have you tried the progn thing by itself without any cascades.
2014-10-02T04:27:24Z _xyjprc_: ram should be more than enough, I have 31G free memory
2014-10-02T04:28:24Z beach: _xyjprc_: It looks like you didn't try it by itself without the existing calling function.
2014-10-02T04:28:28Z _xyjprc_: *inferior-lisp* shows fatal error encountered in SBCL pid 11332(tid 140737127773952): Heap exhausted, game over.
2014-10-02T04:28:51Z White_Flame: I suspect that's from your further processing, not just from the read
2014-10-02T04:30:42Z beach: Bike: Around?
2014-10-02T04:30:47Z Bike: yo
2014-10-02T04:31:52Z beach: Bike: A few weeks ago, nyef suggested to me that a code walker could be used as an interpreter.  Since then, I have on the backburner the idea of creating a general code walker, perhaps customized with CLOS functions and such.
2014-10-02T04:32:13Z Bike: ah, i think that's been tried a few times...
2014-10-02T04:32:13Z _xyjprc_: Without everything it still fails. Let me try more
2014-10-02T04:32:25Z Bike: actually i think the sbcl people were working on one? (with some degree of portability)
2014-10-02T04:32:52Z Bike: i also tried writing one with contextl and stuff. also i wrote about half a closure compiler going off that tagbody thing, but that's simple by comparison
2014-10-02T04:33:01Z beach: Bike: The existing SBCL one only seems to call a particular function for every form.
2014-10-02T04:33:13Z Bike: yeah, not sb-walker, something new in the last few months
2014-10-02T04:33:19Z beach: Oh, I see.
2014-10-02T04:33:53Z beach: Anyway, you seem to know about direct interpreters, so it would be nice if you had some ideas about how to structure such a thing.
2014-10-02T04:34:32Z beach: It would have to be possible to use it as a direct interpreter, a minimal compiler, and a converter from forms to ASTs.
2014-10-02T04:35:17Z beach: Also, this is Cleavir, so it would have to be implementation independent.
2014-10-02T04:35:25Z beach: ... or rather configurable.
2014-10-02T04:35:46Z Bike: yeah, maybe contextl would help with that. you know about it, right?
2014-10-02T04:35:56Z beach: I do, yes.
2014-10-02T04:36:01Z askatasuna quit (Ping timeout: 260 seconds)
2014-10-02T04:36:08Z lisper29 joined #lisp
2014-10-02T04:36:18Z beach: What role would contextl play in such a thing?
2014-10-02T04:36:22Z kcj joined #lisp
2014-10-02T04:36:34Z _xyjprc_: http://paste.lisp.org/display/143912
2014-10-02T04:36:44Z Bike: Dynamically binding processor functions temporarily
2014-10-02T04:36:55Z _xyjprc_: This still doesn't work and "heap exhausted"
2014-10-02T04:36:57Z Bike: e.g. let's say you want to process a (function (lambda ...)) form, and track what variables the lambda closes over
2014-10-02T04:37:14Z beach: OK
2014-10-02T04:37:24Z Bike: you could have the method on FUNCTION (which might be a method specialized on (eql 'function)) bind a contextl layer in addition to everything else
2014-10-02T04:37:53Z beach: I see.
2014-10-02T04:38:15Z Bike: of course maybe by "trivial" you're thinking more trivial than that, but I think that's the kind of thing walkers have historically tried to allow?
2014-10-02T04:38:42Z pillton: _xyjprc_: SBCL has the command line option --dynamic-space-size. Try increasing that.
2014-10-02T04:38:48Z beach: Bike: I didn't say "trivial".
2014-10-02T04:38:56Z Bike: er. minimal, sorry.
2014-10-02T04:39:14Z jkaye joined #lisp
2014-10-02T04:39:18Z beach: Bike: Oh, by "minimal compiler" I meant in the Common Lisp sense of "minimal compilation"
2014-10-02T04:39:22Z Bike: Oh.
2014-10-02T04:39:52Z pillton: _xyjprc_: e.g. sbcl --dynamic-space-size 16000 --load "your-last-paste" --eval '(main)'
2014-10-02T04:41:01Z beach: Bike: I'll look again at contextl and contemplate how it would make possible what I want.
2014-10-02T04:41:13Z Bike: Basically you have lexical compilation bindings - e.g. declare, macrolet - that are reflected as dynamic in the processor by some method, whether it's another parameter, dynamic variables, or something as huge as contextl
2014-10-02T04:41:26Z Harag joined #lisp
2014-10-02T04:41:35Z _xyjprc_: pillton Now it works!
2014-10-02T04:41:43Z keen___ joined #lisp
2014-10-02T04:42:16Z pillton: _xyjprc_: great.
2014-10-02T04:42:21Z Bike: contextl is just a convenient way of avoiding baking in all possible functional behavior into all the processors
2014-10-02T04:42:26Z _xyjprc_: Thanks everyone!
2014-10-02T04:42:32Z beach: Bike: Yeah, sure.
2014-10-02T04:42:42Z keen__ quit (Ping timeout: 245 seconds)
2014-10-02T04:43:03Z _xyjprc_: (But just out of curiosity, why loading such a small file will exhaust the stack?)
2014-10-02T04:43:19Z beach: _xyjprc_: It doesn't here.
2014-10-02T04:43:22Z White_Flame: because you're not just loading the file, you're calling your cascade processing on it
2014-10-02T04:43:23Z pillton: It is the heap, not that stack.
2014-10-02T04:43:26Z Bike: like, you could do the closure thing if you had like (defun process-symbol (...) (signal 'variable-closed-over symbol) ...) (defun process-lambda (...) (handler-bind ((variable-closed-over ...)) ...))
2014-10-02T04:43:37Z |3b|: sbcl needs to allocate a fixed amount of address space in advance due to way its GC works, by default it isn't all that large amount
2014-10-02T04:43:52Z jkaye quit (Ping timeout: 240 seconds)
2014-10-02T04:44:10Z beach: Bike: Using signals?  Hmm.  OK.
2014-10-02T04:44:26Z Bike: i think that would work, anyway. haven't tried it.
2014-10-02T04:44:36Z |3b|: and characters are usually unicode (so 21+ bits, probably 32), so your file takes up more space in ram
2014-10-02T04:45:09Z beach: Bike: My thinking so far was to call a generic function for each form and have it dispatch on a "processor".
2014-10-02T04:45:15Z |3b|: (variable byte encodings are inconvenient to use internally in CL, since STRINGs are defined as VECTORs of CHARACTERs
2014-10-02T04:45:39Z _xyjprc_: I see. I will add the cascading stuff back and see if it works now. Thanks again!
2014-10-02T04:45:42Z Bike: beach: the processor being some other object? sounds like LIL somehow
2014-10-02T04:45:59Z beach: Yes, and object.  I haven't looked into LIL.
2014-10-02T04:46:13Z resttime quit (Quit: resttime)
2014-10-02T04:46:22Z |3b|: _xyjprc_: also, make sure you are using a 64bit sbcl if you have that much ram available, it defaults to a larger heap (though possibly still not large enough)... you can check with (machine-type) at repl
2014-10-02T04:47:06Z beach: Oh, first-class interfaces.  Yes, I remember skimming that.
2014-10-02T04:47:18Z Bike: that could work too. presumably you'd be passing the processor along to subforms' processor calls
2014-10-02T04:47:41Z beach: Bike: Yes, *almost* all the time.
2014-10-02T04:48:04Z beach: Bike: But consider for instance that the AST interpreter must call the minimal compiler on the body of MACROLET.
2014-10-02T04:48:33Z beach: Bike: Because if we are cross compiling, the local macro must be executed by the host.
2014-10-02T04:48:34Z nug700 joined #lisp
2014-10-02T04:48:35Z _xyjprc_: Thanks |3b|, I will check :-)
2014-10-02T04:48:40Z Bike: right, so you pick a different processor
2014-10-02T04:49:10Z beach: Yes, and that has to be part of the processing of a particular processor on MACROLET.
2014-10-02T04:49:26Z beach: In this case of the AST converter.
2014-10-02T04:50:11Z Bike: i guess the main concern would be it might be difficult to efficiently uh... compose processors, i guess
2014-10-02T04:50:25Z edgar-rft joined #lisp
2014-10-02T04:51:38Z beach: I don't know about having to compose them.  But a processor definitely has to be able to select a different one for subforms sometimes.  On the other hand, having to do this explicitly all the time would be too verbose, because "normally" the same processor would be used for subforms.
2014-10-02T04:52:06Z marchdown joined #lisp
2014-10-02T04:52:27Z beach: I mean, if all this has to be configured for (say) each special operator, it is as verbose as writing a special program for that particular processing.
2014-10-02T04:52:27Z scottj left #lisp
2014-10-02T04:53:23Z Bike: well, imagine the escape analysis case again. you basically want to process the lambda as usual, and also track variables.
2014-10-02T04:53:27Z lisper29 left #lisp
2014-10-02T04:53:36Z beach: Sure.
2014-10-02T04:53:55Z Bike: hm, I guess you could have a default processor that just recurses to the evaluated subforms of a given special form, and then define methods on it when you want to do other things
2014-10-02T04:54:20Z beach: I was hoping that.
2014-10-02T04:54:43Z beach: Like defining a method on AST-conversion and MACROLET.
2014-10-02T04:54:45Z |3b|: possibly separate functions for processing a node and handling recusion?
2014-10-02T04:55:16Z beach: Yes, maybe so.  But again, if all that has to be configured, the result would be as verbose as a special-purpose program.
2014-10-02T04:55:19Z |3b|: actually, i guess pre- and post-processing
2014-10-02T04:55:28Z Bike: mm, i don't know if you could do decouple single node processing from recursion too well
2014-10-02T04:55:37Z |3b|: most uses could reuse the recursion part
2014-10-02T04:55:43Z kisp joined #lisp
2014-10-02T04:56:18Z leo2007 quit (Quit: rcirc on GNU Emacs 24.4.50.1)
2014-10-02T04:56:21Z |3b|: though i guess "pre- and post-processing" hooks is just an :around method
2014-10-02T04:56:24Z Bike: yeah, it just seems like they'd be in one method though.
2014-10-02T04:56:30Z Bike: maybe- yeah, some complicated method combo maybe
2014-10-02T04:57:01Z gingerale quit (Ping timeout: 260 seconds)
2014-10-02T04:57:14Z |3b|: not really complicated method combination, just some guidelines on which parts should be handled in which types of methods
2014-10-02T04:57:56Z |3b|: though actually, that isn't quite right, since you don't want the :around methods from less specialized classes, so might need a special combination
2014-10-02T04:58:04Z |3b|: or just separate functions
2014-10-02T04:58:54Z beach: This discussion looks very similar to what I go through when I think about it.
2014-10-02T04:59:50Z |3b|: something like (defmethod walk (form walker) (pre-process (car form) form walker) (recur (car form) form walker) (post-process (car form) form walker)), where pre and post-process by default do nothing, and recur calls WALK on the evaluated parts of all the CL special operators
2014-10-02T05:00:01Z Bike: honestly, whenever i think about writing compilers too long i go in circles of pie in the sky, and that's why i haven't and you have. probably best to start on something and see where it goes...
2014-10-02T05:00:11Z |3b| needs a better code walker for 3bgl-shaders at some point
2014-10-02T05:00:18Z beach: Bike: Heh!
2014-10-02T05:00:26Z |3b|: Bike: yeah, my solution to that is "just do something horrible that works" :p
2014-10-02T05:00:51Z beach: That's basically what I started doing.  Just to see what trouble I would get into.
2014-10-02T05:00:54Z |3b|: (which is why 3bgl-shaders needs a better code walker)
2014-10-02T05:01:30Z |3b|: though i think some of my problem is that the passes got a bit confused, so it is hard to tell which actually affect what forms
2014-10-02T05:02:48Z marchdown quit (Quit: marchdown)
2014-10-02T05:03:29Z beach: OK, I'll continue thinking about it.  If anyone has any insight, let me know.
2014-10-02T05:03:57Z marchdown joined #lisp
2014-10-02T05:07:29Z marchdown quit (Client Quit)
2014-10-02T05:07:39Z stepnem joined #lisp
2014-10-02T05:09:14Z hiyosi joined #lisp
2014-10-02T05:12:04Z marchdown joined #lisp
2014-10-02T05:13:37Z hiyosi quit (Ping timeout: 244 seconds)
2014-10-02T05:14:02Z MoALTz quit (Quit: Leaving)
2014-10-02T05:20:33Z oleo__ quit (Quit: Verlassend)
2014-10-02T05:30:59Z wizzo joined #lisp
2014-10-02T05:32:07Z c107 quit (Remote host closed the connection)
2014-10-02T05:32:42Z _xyjprc_ quit (Remote host closed the connection)
2014-10-02T05:32:57Z beach: Bike: Have you seen what I did with environments in Cleavir?
2014-10-02T05:33:30Z madrik joined #lisp
2014-10-02T05:34:34Z beach: Bike: I think I am on the right track there in terms of making it implementation independent.  Just saying, because of your "pie in the sky" problem.
2014-10-02T05:35:54Z kisp quit (Remote host closed the connection)
2014-10-02T05:37:40Z Bike: i saw that preliminary pdf you put out once
2014-10-02T05:37:58Z beach: That one might need to be updated :)
2014-10-02T05:38:33Z beach: I basically made CLOSy versions of the CLtL2 functions, and added missing stuff like blocks and tags.
2014-10-02T05:39:13Z beach: Implementations supply a few methods on those functions.
2014-10-02T05:40:20Z beach: I introduce a global environment object.  An implementation that does not have first-class global environments (which would be most of them) supplies a bogus object that can be dispatched on.
2014-10-02T05:41:27Z beach: Anyway, again, just saying, in case you want to stop your circling and thing about something more concrete.
2014-10-02T05:41:35Z marchdown quit (Quit: marchdown)
2014-10-02T05:41:36Z beach: think
2014-10-02T05:42:21Z drmeister: In a couple of weeks I'll be able to test out the environments.
2014-10-02T05:42:41Z madmalik joined #lisp
2014-10-02T05:42:50Z drmeister: And see how they shoe-horn into Clasp.
2014-10-02T05:42:56Z mrSpec joined #lisp
2014-10-02T05:43:24Z beach: drmeister: You could already test the environments by using the minimal compiler.  I am well on the way with AST generation as well.
2014-10-02T05:43:28Z drmeister: I have to get some other work out first that I've been neglecting.
2014-10-02T05:43:35Z Bike: well, i figured my closure compiler would ideally have cltl2 and cleavir environment introspection anyway
2014-10-02T05:43:37Z drmeister: Grant proposals, papers etc.
2014-10-02T05:43:45Z Bike: it's hard to muster up the willpower to deal with aprsing lambda lists, though
2014-10-02T05:44:06Z |3b|: Bike: alexandria:parse-ordinary-lambda-list ?
2014-10-02T05:44:19Z Bike: yeah, but then i have to do things with it...
2014-10-02T05:44:29Z drmeister: clasp/src/core/lambdaListHandler.cc ?
2014-10-02T05:44:34Z beach: Cleavir also has lambda list utilities.
2014-10-02T05:44:36Z pt1 joined #lisp
2014-10-02T05:44:43Z |3b| really wishes there was a corresponding macro-lambda-list or destructuring-lambda-list parser
2014-10-02T05:44:49Z Bike: like, i have to bind them sequentially and... argh
2014-10-02T05:44:56Z beach: |3b|: Cleavir has all of those.
2014-10-02T05:45:08Z |3b|: beach: yeah, i suppose i should have used past tense :)
2014-10-02T05:45:29Z |3b| already did whatever it was, so either i have one too or figured out how to avoid needing it
2014-10-02T05:46:52Z beach: It turns out the code walker itself only needs ordinary lambda lists, because it calls parse-macro on MACROLET definitions.
2014-10-02T05:47:10Z beach: But parse-macro needs to parse macro lambda lists of course.
2014-10-02T05:47:34Z |3b|: yeah, i think i was working on compiler macros or something at the time
2014-10-02T05:48:30Z drmeister: Don't you just strip out &whole and &environment and then you have an ordinary lambda list?
2014-10-02T05:48:40Z beach: Nope.
2014-10-02T05:48:44Z pt1 quit (Remote host closed the connection)
2014-10-02T05:48:53Z beach: You also have destructuring.
2014-10-02T05:49:00Z farhaven quit (Ping timeout: 250 seconds)
2014-10-02T05:49:34Z drmeister: Ah yes.
2014-10-02T05:49:49Z svetlyak40wt joined #lisp
2014-10-02T05:49:54Z innertracks joined #lisp
2014-10-02T05:51:05Z Bike: hm, did pjb's parsers handle it, i wonder
2014-10-02T05:51:45Z beach: Handle destructuring?
2014-10-02T05:52:00Z Bike: macro lambda lists, yeah.
2014-10-02T05:52:11Z Bike: he had a clos setup that looked nicer than alexandria's billion values, honestly
2014-10-02T05:52:24Z beach: Must be similar to that of Cleavir.
2014-10-02T05:52:39Z beach: I use a class instance as a result of parsing.
2014-10-02T05:53:26Z Bike: https://gitorious.org/com-informatimago/com-informatimago/source/1ee0848bf0ee59d55dac072600ca6404a5ef1090:common-lisp/lisp-sexp/source-form.lisp hm yep, even modify macro lls and shit
2014-10-02T05:55:24Z beach: Great!
2014-10-02T05:55:38Z beach: Looks very general.
2014-10-02T06:01:10Z radioninja joined #lisp
2014-10-02T06:03:58Z Shinmera joined #lisp
2014-10-02T06:04:12Z meiji11 quit (Remote host closed the connection)
2014-10-02T06:04:49Z innertracks quit (Quit: innertracks)
2014-10-02T06:09:59Z hiyosi joined #lisp
2014-10-02T06:14:33Z beach: OK, time to get to work.
2014-10-02T06:14:38Z beach left #lisp
2014-10-02T06:14:52Z hiyosi quit (Ping timeout: 260 seconds)
2014-10-02T06:14:58Z gravicappa joined #lisp
2014-10-02T06:19:01Z Grue` joined #lisp
2014-10-02T06:24:41Z Grue` quit (Ping timeout: 272 seconds)
2014-10-02T06:27:12Z nonamae joined #lisp
2014-10-02T06:29:50Z defaultxr quit (Quit: gnight)
2014-10-02T06:30:24Z mac_ified quit (Remote host closed the connection)
2014-10-02T06:31:12Z mac_ified joined #lisp
2014-10-02T06:34:45Z RenRenJuan joined #lisp
2014-10-02T06:34:53Z Grue` joined #lisp
2014-10-02T06:39:04Z freaksken joined #lisp
2014-10-02T06:39:28Z pt1 joined #lisp
2014-10-02T06:40:13Z jkaye joined #lisp
2014-10-02T06:41:26Z mishoo joined #lisp
2014-10-02T06:44:54Z jkaye quit (Ping timeout: 258 seconds)
2014-10-02T06:49:22Z fridim__ joined #lisp
2014-10-02T06:53:27Z radioninja quit (Remote host closed the connection)
2014-10-02T06:56:13Z uzo quit (Ping timeout: 246 seconds)
2014-10-02T06:59:07Z kobain quit (Quit: KVIrc 4.1.3 Equilibrium http://www.kvirc.net/)
2014-10-02T07:01:22Z Grue` quit (Ping timeout: 250 seconds)
2014-10-02T07:01:38Z drdanmaku quit (Quit: Connection closed for inactivity)
2014-10-02T07:06:32Z marvimias joined #lisp
2014-10-02T07:09:51Z frkout quit (Read error: Connection reset by peer)
2014-10-02T07:10:18Z frkout joined #lisp
2014-10-02T07:10:20Z c74d quit (Read error: Connection reset by peer)
2014-10-02T07:10:29Z Grue` joined #lisp
2014-10-02T07:10:49Z hiyosi joined #lisp
2014-10-02T07:12:58Z c74d joined #lisp
2014-10-02T07:22:59Z k-stz joined #lisp
2014-10-02T07:23:00Z munksgaard joined #lisp
2014-10-02T07:23:14Z fikusz quit (Ping timeout: 258 seconds)
2014-10-02T07:23:56Z tadni quit (Ping timeout: 260 seconds)
2014-10-02T07:24:02Z tadni` joined #lisp
2014-10-02T07:25:15Z Beetny joined #lisp
2014-10-02T07:26:57Z tadni`` joined #lisp
2014-10-02T07:28:22Z tadni` quit (Ping timeout: 240 seconds)
2014-10-02T07:29:13Z Cymew joined #lisp
2014-10-02T07:29:58Z marchdown joined #lisp
2014-10-02T07:30:01Z ggole joined #lisp
2014-10-02T07:36:42Z dfox quit (Ping timeout: 272 seconds)
2014-10-02T07:36:58Z fikusz joined #lisp
2014-10-02T07:37:21Z dfox joined #lisp
2014-10-02T07:37:39Z leo2007 joined #lisp
2014-10-02T07:37:41Z leo2007 quit (Remote host closed the connection)
2014-10-02T07:38:08Z MrWoohoo joined #lisp
2014-10-02T07:39:21Z jusss joined #lisp
2014-10-02T07:42:22Z nonamae quit (Ping timeout: 240 seconds)
2014-10-02T07:43:08Z leo2007 joined #lisp
2014-10-02T07:44:01Z ehu joined #lisp
2014-10-02T07:46:52Z tadni`` quit (Ping timeout: 245 seconds)
2014-10-02T07:49:54Z varjag joined #lisp
2014-10-02T07:51:15Z madmalik quit (Quit: Connection closed for inactivity)
2014-10-02T07:51:31Z svetlyak40wt quit (Read error: Connection timed out)
2014-10-02T07:52:17Z svetlyak40wt joined #lisp
2014-10-02T07:54:51Z huza joined #lisp
2014-10-02T07:56:35Z simulacrum quit (Remote host closed the connection)
2014-10-02T07:56:46Z hitecnologys joined #lisp
2014-10-02T07:57:14Z jusss` joined #lisp
2014-10-02T07:57:33Z huza quit (Client Quit)
2014-10-02T07:57:44Z huza joined #lisp
2014-10-02T07:57:58Z nug700 quit (Quit: bye)
2014-10-02T07:59:30Z oudeis joined #lisp
2014-10-02T07:59:32Z arenz joined #lisp
2014-10-02T08:00:30Z DTSCode quit (Ping timeout: 244 seconds)
2014-10-02T08:00:43Z jusss quit (Ping timeout: 272 seconds)
2014-10-02T08:02:13Z slyrus quit (Ping timeout: 272 seconds)
2014-10-02T08:04:30Z nostoi joined #lisp
2014-10-02T08:05:05Z angavrilov joined #lisp
2014-10-02T08:05:22Z johs_ is now known as johs
2014-10-02T08:14:59Z pt1 quit (Remote host closed the connection)
2014-10-02T08:17:17Z pt1_ joined #lisp
2014-10-02T08:19:22Z ehu quit (Ping timeout: 240 seconds)
2014-10-02T08:23:58Z denisrum joined #lisp
2014-10-02T08:26:28Z akkad quit (Quit: Emacs must have died)
2014-10-02T08:27:39Z ehu joined #lisp
2014-10-02T08:28:49Z alchemis7 left #lisp
2014-10-02T08:28:50Z alchemis7 joined #lisp
2014-10-02T08:29:13Z jusss` is now known as jusss
2014-10-02T08:29:36Z jusss quit (Changing host)
2014-10-02T08:29:37Z jusss joined #lisp
2014-10-02T08:30:30Z Shinmera quit (Remote host closed the connection)
2014-10-02T08:30:54Z Shinmera joined #lisp
2014-10-02T08:30:59Z huza quit (Quit: WeeChat 0.3.8)
2014-10-02T08:32:07Z simulacrum joined #lisp
2014-10-02T08:33:39Z ndrei quit (Ping timeout: 272 seconds)
2014-10-02T08:35:41Z munksgaard quit (Ping timeout: 258 seconds)
2014-10-02T08:36:20Z minion quit (Remote host closed the connection)
2014-10-02T08:36:20Z specbot quit (Remote host closed the connection)
2014-10-02T08:36:21Z easye quit (Read error: Connection reset by peer)
2014-10-02T08:37:27Z minion joined #lisp
2014-10-02T08:37:46Z specbot joined #lisp
2014-10-02T08:38:22Z joast quit (Ping timeout: 258 seconds)
2014-10-02T08:45:57Z pierre1_ joined #lisp
2014-10-02T08:46:27Z MouldyOldBones quit (Ping timeout: 264 seconds)
2014-10-02T08:46:35Z moore33 joined #lisp
2014-10-02T08:49:43Z marchdown quit (Quit: marchdown)
2014-10-02T08:50:28Z ndrei joined #lisp
2014-10-02T08:51:36Z nostoi quit (Quit: Verlassend)
2014-10-02T08:51:51Z oudeis quit (Quit: This computer has gone to sleep)
2014-10-02T08:58:16Z simulacrum quit (Remote host closed the connection)
2014-10-02T08:59:53Z splittist joined #lisp
2014-10-02T09:00:50Z MouldyOldBones joined #lisp
2014-10-02T09:01:11Z robot-beethoven quit (Quit: ERC Version 5.3 (IRC client for Emacs))
2014-10-02T09:01:38Z jusss quit (Quit: ERC Version 5.2 (IRC client for Emacs))
2014-10-02T09:03:27Z vinleod joined #lisp
2014-10-02T09:04:19Z munksgaard joined #lisp
2014-10-02T09:09:02Z munksgaard quit (Ping timeout: 258 seconds)
2014-10-02T09:09:37Z RenRenJuan quit (Read error: No route to host)
2014-10-02T09:10:12Z ndrei quit (Ping timeout: 245 seconds)
2014-10-02T09:10:20Z harish quit (Ping timeout: 260 seconds)
2014-10-02T09:10:33Z munksgaard joined #lisp
2014-10-02T09:10:51Z schjetne: Has anyone had the idea to make a reverse let, where the body is at the top and bindings at the bottom, like Haskell's where keyword? Obviously a trivial macro, but I'm curious.
2014-10-02T09:11:26Z Shinmera: I don't see how that wouldn't be very confusing-looking.
2014-10-02T09:12:46Z Shinmera: General indentation rules and conventions don't lend themselves well to such an idea either.
2014-10-02T09:13:36Z zacharias_ quit (Ping timeout: 260 seconds)
2014-10-02T09:14:28Z schjetne: Depending on context I think it reads better. When describing mathematical functions or algorithms in speech or prose I tend to use ‘where’ a lot more than ‘let‘
2014-10-02T09:14:48Z schjetne: But you're right that it wouldn't look very good with Lisp syntax
2014-10-02T09:15:08Z Shinmera: Lisp isn't quite speech or mathematical description, so
2014-10-02T09:15:46Z madmalik joined #lisp
2014-10-02T09:15:56Z schjetne: I thought about it because I have some functions with fairly lengthy sections of rather uninteresting bindings, and then a very succint body. I want that to be the first thing I see when I jump to that function definition.
2014-10-02T09:15:59Z Shinmera: I just heavily doubt that anyone has done it. In general I've never seen constructs that look at the tail of a list rather than the head elements.
2014-10-02T09:16:32Z schjetne: I probably wouldn't bother unless I can come up with a way to make it look good.
2014-10-02T09:16:58Z |3b|: ((lambda (a b c) (body a b c)) (complicated initial value for a) (value for b) (c)) ?
2014-10-02T09:17:24Z Shinmera: Hah, a nice idea
2014-10-02T09:18:09Z |3b| supposes ((lambda (&key a b c) ...) :a ... :b ... :c) would be better
2014-10-02T09:18:18Z schjetne: I was thinking perhaps something like (where-let (forms) (where bindings))
2014-10-02T09:18:34Z Shinmera: |3b|'s solution Would probably be a bit more readable than having the variable labels at the bottom too.
2014-10-02T09:18:49Z schjetne: which just turns into a good old (let (bindings) forms)
2014-10-02T09:18:54Z |3b|: pretty sure i've seen someone talk about a form like that, but i wouldn't want to read code using it
2014-10-02T09:19:02Z Shinmera: schjetne: Indentation won't play well with that though :/
2014-10-02T09:19:18Z aoh quit (Ping timeout: 272 seconds)
2014-10-02T09:19:27Z theos quit (Disconnected by services)
2014-10-02T09:19:54Z theos joined #lisp
2014-10-02T09:20:13Z munksgaard quit (Ping timeout: 260 seconds)
2014-10-02T09:20:28Z marchdown joined #lisp
2014-10-02T09:20:33Z |3b|: consider that your '(forms)' would have to look like ((form) (form) ...) which would be ugly/confusing, or it would have to be (form) and require progn for multiple forms
2014-10-02T09:20:40Z schjetne: Yeah, it's a tradeoff, it would probably much only pay off when the bindings is a boring wall of text, and it's questionable if one should write functions that look like that in the first place
2014-10-02T09:21:02Z Shinmera: |3b|: Oh, right, not sure if you saw my message (last week?) about the logs. You can get machine-readable ones with http://log.irc.tymoon.eu/api/chatlog/get?server=freenode&channel=lisp
2014-10-02T09:21:21Z Shinmera: |3b|: I only started logging early this year, but if you want I can give you a full log since then as a file.
2014-10-02T09:21:28Z schjetne: probably lesser of two evils to require a progn
2014-10-02T09:21:43Z |3b|: Shinmera: yeah, I'd want the full history though, and too lazy to do anything with it in the first place, so no real use for either :/
2014-10-02T09:21:52Z munksgaard joined #lisp
2014-10-02T09:21:53Z Shinmera: |3b|: Alright.
2014-10-02T09:22:12Z White_Flame: If the binding list of the let is big, monotonous, and non-challenging, macros should help collapse that into nothing, thus leaving visual focus on the body
2014-10-02T09:22:14Z Shinmera: When I have the time I'll add some number crunching/stats stuff to the irc logs pages.
2014-10-02T09:22:59Z przl joined #lisp
2014-10-02T09:23:16Z Shinmera: Gotta head off for lunch now though.
2014-10-02T09:23:18Z Shinmera quit (Quit: しつれいしなければならないんです。)
2014-10-02T09:26:29Z marchdown quit (Quit: marchdown)
2014-10-02T09:27:43Z madrik quit (Ping timeout: 272 seconds)
2014-10-02T09:29:58Z aoh joined #lisp
2014-10-02T09:35:13Z dxtr quit (Remote host closed the connection)
2014-10-02T09:36:33Z svetlyak40wt quit (Read error: Connection timed out)
2014-10-02T09:37:45Z svetlyak40wt joined #lisp
2014-10-02T09:38:26Z easye joined #lisp
2014-10-02T09:40:04Z dxtr joined #lisp
2014-10-02T09:40:36Z tadni joined #lisp
2014-10-02T09:45:06Z kcj quit (Remote host closed the connection)
2014-10-02T09:46:28Z oudeis joined #lisp
2014-10-02T09:46:42Z Karl_Dscc joined #lisp
2014-10-02T09:47:17Z ndrei joined #lisp
2014-10-02T09:48:01Z cross quit (Quit: Lost terminal)
2014-10-02T09:52:58Z Svetlana joined #lisp
2014-10-02T09:56:15Z EvW joined #lisp
2014-10-02T09:57:26Z oudeis quit (Read error: Connection reset by peer)
2014-10-02T09:58:07Z Shinmera joined #lisp
2014-10-02T10:00:31Z oudeis joined #lisp
2014-10-02T10:02:41Z Karl_Dscc quit (Remote host closed the connection)
2014-10-02T10:06:24Z mrSpec quit (Ping timeout: 250 seconds)
2014-10-02T10:07:26Z munksgaard quit (Ping timeout: 272 seconds)
2014-10-02T10:07:56Z svetlyak40wt quit (Remote host closed the connection)
2014-10-02T10:08:38Z svetlyak40wt joined #lisp
2014-10-02T10:10:32Z svetlyak40wt quit (Remote host closed the connection)
2014-10-02T10:15:02Z marchdown joined #lisp
2014-10-02T10:15:40Z marchdown quit (Client Quit)
2014-10-02T10:16:04Z oudeis quit (Quit: This computer has gone to sleep)
2014-10-02T10:18:16Z farhaven joined #lisp
2014-10-02T10:18:30Z loiclisp joined #lisp
2014-10-02T10:19:24Z harish joined #lisp
2014-10-02T10:19:41Z BitPuffin joined #lisp
2014-10-02T10:20:37Z mrSpec joined #lisp
2014-10-02T10:21:40Z svetlyak40wt joined #lisp
2014-10-02T10:25:15Z loiclisp quit (Quit: Leaving)
2014-10-02T10:26:03Z Karl_Dscc joined #lisp
2014-10-02T10:40:47Z marchdown joined #lisp
2014-10-02T10:41:53Z zacharias joined #lisp
2014-10-02T10:42:50Z simulacrum joined #lisp
2014-10-02T10:48:25Z mac_ified quit (Ping timeout: 260 seconds)
2014-10-02T10:49:00Z mac_ified joined #lisp
2014-10-02T10:53:28Z zacharias quit (Ping timeout: 260 seconds)
2014-10-02T10:53:48Z stardiviner joined #lisp
2014-10-02T10:54:30Z EvW quit (Ping timeout: 272 seconds)
2014-10-02T10:57:45Z Karl_Dscc quit (Remote host closed the connection)
2014-10-02T11:01:27Z przl quit (Ping timeout: 272 seconds)
2014-10-02T11:05:55Z jusss joined #lisp
2014-10-02T11:06:20Z zacharias joined #lisp
2014-10-02T11:09:27Z Grue` quit (Ping timeout: 245 seconds)
2014-10-02T11:12:51Z kuzy000_ joined #lisp
2014-10-02T11:17:55Z tadni`` joined #lisp
2014-10-02T11:18:20Z tadni quit (Ping timeout: 250 seconds)
2014-10-02T11:19:26Z Grue` joined #lisp
2014-10-02T11:20:56Z tadni`` quit (Remote host closed the connection)
2014-10-02T11:21:25Z tadni joined #lisp
2014-10-02T11:23:59Z munksgaard joined #lisp
2014-10-02T11:24:04Z cmack quit (Remote host closed the connection)
2014-10-02T11:24:58Z munksgaard quit (Read error: Connection reset by peer)
2014-10-02T11:27:52Z simulacrum quit (Remote host closed the connection)
2014-10-02T11:27:56Z przl joined #lisp
2014-10-02T11:28:43Z mac_ified quit (Ping timeout: 244 seconds)
2014-10-02T11:29:26Z mac_ified joined #lisp
2014-10-02T11:34:00Z Longlius quit (Remote host closed the connection)
2014-10-02T11:41:26Z pjb: minion: memo for theseb: if you were a mathematical guy, you'd realize that it's much easier to build conses from lambda than to build vectors.
2014-10-02T11:41:26Z minion: Remembered. I'll tell theseb when he/she/it next speaks.
2014-10-02T11:41:39Z pjb: minion: memo for theseb: or lists.
2014-10-02T11:41:39Z minion: Remembered. I'll tell theseb when he/she/it next speaks.
2014-10-02T11:43:52Z gniourf quit (Ping timeout: 240 seconds)
2014-10-02T11:46:21Z knob joined #lisp
2014-10-02T11:46:23Z pjb: White_Flame: I have an idea: keep the data in vectors, and use (defvar *vector* (make-array 100 :fill-pointer 0 :adjustable t)) (defun kar (x) (aref *vector* x)) (defun kdr (x) (aref *vector* (1+ x))) (defun kons (a d) (prog1 (fill-pointer *vector*) (vector-push-extend a *vector*) (vector-push-extend d *vector*)))
2014-10-02T11:47:31Z madrik joined #lisp
2014-10-02T11:49:42Z yrk joined #lisp
2014-10-02T11:49:53Z vinleod quit (Quit: ["Textual IRC Client: www.textualapp.com"])
2014-10-02T11:50:09Z yrk quit (Changing host)
2014-10-02T11:50:09Z yrk joined #lisp
2014-10-02T11:50:50Z munksgaard joined #lisp
2014-10-02T11:51:05Z munksgaard quit (Read error: Connection reset by peer)
2014-10-02T11:51:42Z Karl_Dscc joined #lisp
2014-10-02T11:52:04Z marchdown quit (Quit: marchdown)
2014-10-02T11:55:04Z pjb: schjetne: the problem with (here (aref *v* j (incf i))  where  (j (incf i)))  is that there is a general assumption in Common Lisp that evaluation is performed from left to right, which is important for side effects such as (incf i).
2014-10-02T11:55:29Z pjb: And imagine embedding several of those forms, the zig-zagging required to understand them would be unbearable.
2014-10-02T11:55:54Z hlavaty`: is it legal to (setf (gethash k h) newval) inside maphash over h?
2014-10-02T11:56:05Z hlavaty`: clhs maphash
2014-10-02T11:56:05Z specbot: http://www.lispworks.com/reference/HyperSpec/Body/f_maphas.htm
2014-10-02T11:56:13Z pjb: hlavaty`: only if k is the key given to the lambda by maphash.
2014-10-02T11:56:19Z pjb: You can also use remhash.
2014-10-02T11:56:34Z schjetne: pjb: ah, didn't think about that. That's something that Haskell doesn't have to worry about
2014-10-02T11:56:45Z schjetne: Or rather chooses not to worry about
2014-10-02T11:56:50Z pjb: schjetne: doesn't haskell have monads?
2014-10-02T11:57:01Z hlavaty`: pjb: i see it now, thank you!
2014-10-02T11:57:18Z pjb: schjetne: I don't know much about them, but I'd thought that modads could also impose some execution order or something.
2014-10-02T11:57:21Z schjetne: I haven't used Haskell enough to know how monads work in relation to where bindings
2014-10-02T12:00:54Z ggole: Where bindings are just let in a different order.
2014-10-02T12:01:19Z munksgaard joined #lisp
2014-10-02T12:01:24Z munksgaard quit (Read error: Connection reset by peer)
2014-10-02T12:02:02Z pjb: ggole: yes, and that's the problem in CL where you expect the left-to-right order.
2014-10-02T12:02:38Z ggole: Yes, in strict languages the "traditional" order of binding constructs makes a lot of sense
2014-10-02T12:04:32Z pjb: Now, perhaps, inspired from the lambda application, something like (here (j k) (aref *v* (incf i) j k) where (j (incf i)) (k (incf i))) could be done.  But again, if we abstracted out let from ((lambda (j k) …) …), it's for a reason.
2014-10-02T12:05:34Z Grue`: i think this macro will be reasonable if j and k were implemented as symbol-macrolets
2014-10-02T12:05:54Z pjb: It would expand to a simple let.
2014-10-02T12:06:03Z pjb: The question is whether it's readable.
2014-10-02T12:06:05Z Grue`: then they are not really evaluated before the body of the macro
2014-10-02T12:06:25Z pjb: This would be even more complex to understand.
2014-10-02T12:06:26Z munksgaard joined #lisp
2014-10-02T12:07:21Z Grue`: it would emulate "lazy evaluation" or w/e they do in haskell
2014-10-02T12:08:03Z Grue`: except each binding should probably be memoized so as not to calculate things twice
2014-10-02T12:08:05Z Joreji joined #lisp
2014-10-02T12:08:18Z pt1 joined #lisp
2014-10-02T12:08:33Z Shinmera: Has to be memoized. Think about bindings with side-effects.
2014-10-02T12:09:24Z ggole: Sounds like you are Greenspunning graph reduction.
2014-10-02T12:10:57Z pt1_ quit (Ping timeout: 260 seconds)
2014-10-02T12:13:38Z pjb: Grue`: ah, if you are re-implementing Haskell, ok.
2014-10-02T12:20:36Z Xach joined #lisp
2014-10-02T12:24:14Z Beetny quit (Ping timeout: 272 seconds)
2014-10-02T12:24:15Z simulacrum joined #lisp
2014-10-02T12:26:02Z dim: is there WIP for threads support in SBCL on ARM?
2014-10-02T12:27:42Z madrik quit (Ping timeout: 245 seconds)
2014-10-02T12:29:00Z munksgaard quit (Read error: Connection reset by peer)
2014-10-02T12:29:10Z przl quit (Ping timeout: 244 seconds)
2014-10-02T12:29:48Z munksgaard joined #lisp
2014-10-02T12:29:56Z tadni quit (Ping timeout: 272 seconds)
2014-10-02T12:30:05Z pjb: What is WIP?
2014-10-02T12:30:35Z Xach: work-in-progress
2014-10-02T12:30:35Z munksgaard quit (Read error: Connection reset by peer)
2014-10-02T12:30:41Z tadni` joined #lisp
2014-10-02T12:31:45Z przl joined #lisp
2014-10-02T12:32:02Z pjb: thanks.
2014-10-02T12:33:02Z tadni` quit (Remote host closed the connection)
2014-10-02T12:33:43Z tadni` joined #lisp
2014-10-02T12:34:33Z pt1 quit (Remote host closed the connection)
2014-10-02T12:37:38Z nyef joined #lisp
2014-10-02T12:37:50Z nyef: G'morning all.
2014-10-02T12:39:22Z tadni` quit (Ping timeout: 245 seconds)
2014-10-02T12:39:59Z simulacrum quit (Remote host closed the connection)
2014-10-02T12:40:17Z Joreji quit (Ping timeout: 245 seconds)
2014-10-02T12:40:25Z munksgaard joined #lisp
2014-10-02T12:40:53Z pt1 joined #lisp
2014-10-02T12:40:53Z munksgaard quit (Read error: Connection reset by peer)
2014-10-02T12:44:24Z simulacrum joined #lisp
2014-10-02T12:45:28Z xificurC joined #lisp
2014-10-02T12:45:29Z munksgaard joined #lisp
2014-10-02T12:46:01Z ndrei quit (Ping timeout: 260 seconds)
2014-10-02T12:46:28Z jusss quit (Remote host closed the connection)
2014-10-02T12:46:28Z munksgaard quit (Read error: Connection reset by peer)
2014-10-02T12:46:54Z tadni joined #lisp
2014-10-02T12:48:21Z tadni` joined #lisp
2014-10-02T12:50:11Z tkhoa2711 joined #lisp
2014-10-02T12:50:15Z attila_lendvai joined #lisp
2014-10-02T12:51:48Z tadni quit (Ping timeout: 246 seconds)
2014-10-02T12:53:34Z jkaye joined #lisp
2014-10-02T13:00:07Z pt1 quit (Remote host closed the connection)
2014-10-02T13:02:11Z tadni` quit (Ping timeout: 272 seconds)
2014-10-02T13:02:29Z tadni joined #lisp
2014-10-02T13:04:05Z joast joined #lisp
2014-10-02T13:04:32Z pt1 joined #lisp
2014-10-02T13:04:34Z pt1 quit (Remote host closed the connection)
2014-10-02T13:04:40Z pt1 joined #lisp
2014-10-02T13:04:52Z zn quit (Ping timeout: 245 seconds)
2014-10-02T13:05:57Z mac_ified quit (Remote host closed the connection)
2014-10-02T13:06:11Z mac_ified joined #lisp
2014-10-02T13:07:33Z moore33: The class beach taught for years is on reddit! http://www.reddit.com/r/lisp/comments/2hwyum/french_course_on_lisp_programming_slides/
2014-10-02T13:08:05Z moore33 ran sections of the "practical" part when he first came to France.
2014-10-02T13:08:11Z zn joined #lisp
2014-10-02T13:08:40Z Tristam quit (Excess Flood)
2014-10-02T13:09:21Z Tristam joined #lisp
2014-10-02T13:09:21Z Joreji joined #lisp
2014-10-02T13:10:41Z Xach: moore33: not highly reviewed by the reddit peanut gallery
2014-10-02T13:13:20Z moore33: Xach: No. Even though the comments are pretty weak, the lectures are in fact theoretical: sorta the nature of the French education beast. On the other hand, the lab part was pretty good, IMHO.
2014-10-02T13:14:31Z gendl quit (Quit: gendl)
2014-10-02T13:14:38Z mac_ified quit (Ping timeout: 244 seconds)
2014-10-02T13:17:00Z pt1 quit (Remote host closed the connection)
2014-10-02T13:20:34Z flip216 is now known as flip214
2014-10-02T13:22:03Z Krystof: at least it got comments
2014-10-02T13:22:12Z Krystof: no-one understood code walking for pipe sequencing :~(
2014-10-02T13:24:23Z jusss joined #lisp
2014-10-02T13:26:21Z moore33: I feel your pain :)
2014-10-02T13:26:40Z pt1 joined #lisp
2014-10-02T13:27:12Z dim: in the context of PostgreSQL blog posts I found that you need "a story" for people to understand within the attention span they are able to give to the article, so for my posts it's all about finding real data to process and show e.g. window functions in that context
2014-10-02T13:27:17Z pt1 quit (Remote host closed the connection)
2014-10-02T13:27:34Z karupa is now known as zz_karupa
2014-10-02T13:27:43Z pt1 joined #lisp
2014-10-02T13:27:48Z dim: I guess that you need to step back from the solution and talk about a problem people can easily relate to (so with actual data or suchlike), and show your solution in that context
2014-10-02T13:28:09Z dim: of course, doing that is way more work than just talking about a nice abstract (as in generic) solution
2014-10-02T13:28:50Z s0meone joined #lisp
2014-10-02T13:29:09Z Xach: Krystof: i did save it away for when i hit a similar problem and want to understand it better
2014-10-02T13:29:30Z s0meone is now known as someone
2014-10-02T13:29:49Z Joreji quit (Ping timeout: 260 seconds)
2014-10-02T13:31:56Z Krystof: dim: actually I don't mind if the attention-deficit generation doesn't read it.  (And I'm fine with Xach and fe[nl]ix saying that they'll read it later, too)
2014-10-02T13:33:13Z dim: well in my case, I will read it when I have a practical use case of either code walking or pipe sequencing, because skimming through the first parts didn't help me understand what it is about really, I just miss the background
2014-10-02T13:33:26Z dim: s/miss/lack/ maybe
2014-10-02T13:33:29Z sword`` quit (Remote host closed the connection)
2014-10-02T13:33:43Z sword`` joined #lisp
2014-10-02T13:33:48Z loke_ joined #lisp
2014-10-02T13:35:22Z drdanmaku joined #lisp
2014-10-02T13:36:08Z rme joined #lisp
2014-10-02T13:38:23Z clarkema joined #lisp
2014-10-02T13:38:24Z askatasuna joined #lisp
2014-10-02T13:38:31Z dim: ok, first really interesting case for bind, and it fails
2014-10-02T13:39:41Z dlowe: ... which bind?
2014-10-02T13:41:22Z jtza8 joined #lisp
2014-10-02T13:41:57Z eudoxia joined #lisp
2014-10-02T13:43:27Z Lycurgus joined #lisp
2014-10-02T13:44:14Z dim: metabang-bind
2014-10-02T13:44:17Z dim: http://common-lisp.net/project/metabang-bind/user-guide.html
2014-10-02T13:44:28Z dim: replacing 3 nested destructuring-bind with that
2014-10-02T13:44:56Z Lycurgus quit (Client Quit)
2014-10-02T13:45:01Z dim: but it mixes the nil in (&key (var nil var-s-p)) with a nil for a binding that should be (declare (ignore ...)) by the macro
2014-10-02T13:45:09Z dim: maybe that's the code-walker I need now ;-)
2014-10-02T13:46:29Z svetlyak40wt quit (Remote host closed the connection)
2014-10-02T13:47:31Z dim: I can see an easy fix with removing nil as a "ignore me" flag
2014-10-02T13:48:28Z Xach is reminded of "bb" from https://github.com/rongarret/ergolib
2014-10-02T13:48:43Z Lycurgus joined #lisp
2014-10-02T13:49:15Z jzp113 joined #lisp
2014-10-02T13:49:34Z dim: https://github.com/gwkkwg/metabang-bind/issues/9
2014-10-02T13:49:35Z fortitude joined #lisp
2014-10-02T13:49:38Z vaporatorius joined #lisp
2014-10-02T13:50:11Z dim: ergolib is not in QL, right?
2014-10-02T13:50:36Z fe[nl]ix: it doesn't use ASDF
2014-10-02T13:50:55Z dim: oh.
2014-10-02T13:51:21Z dim: I guess I'm going to monkeypatch metabang-bind here
2014-10-02T13:51:46Z oleo joined #lisp
2014-10-02T13:52:10Z Adlai quit (Quit: WeeChat 0.4.3)
2014-10-02T13:53:08Z Xach: ergolib does not look very much like common lisp to me, in many places
2014-10-02T13:53:38Z eudoxia: wow https://github.com/rongarret/ergolib/blob/master/core/ergobase.lisp
2014-10-02T13:53:42Z Xach: it's very much a beanbag chair of code. very cozy for one, but not comfortable to share.
2014-10-02T13:53:55Z fe[nl]ix: dim: to ignore a value you can use metabang-bing:_
2014-10-02T13:54:15Z Grue`: why would you make a lisp library that doesnt use asdf in this day and age
2014-10-02T13:54:25Z askatasuna quit (Ping timeout: 244 seconds)
2014-10-02T13:54:57Z fe[nl]ix: Grue`: some are against ASDF in principle
2014-10-02T13:55:02Z jzp113 left #lisp
2014-10-02T13:55:06Z dim: fe[nl]ix: yes, that's not where the problem is, but I have my own local fix that only allows _ to ignore bindings now
2014-10-02T13:55:14Z moore33: Ron Garret walks alone.
2014-10-02T13:55:17Z przl_ joined #lisp
2014-10-02T13:55:25Z Xach: Grue`: it is old, old code
2014-10-02T13:55:38Z dim: I *love* how easy SLIME and QL makes it to fix (or monkey patch) any lib you depend on
2014-10-02T13:55:45Z Grue`: oh, I just saw the commits from a few hours ago
2014-10-02T13:55:49Z dim: M-. to dive in
2014-10-02T13:55:51Z Grue`: so I assumed its new
2014-10-02T13:56:14Z Grue`: dim: just make sure your changes dont get overwritten when you update
2014-10-02T13:56:15Z dim: frankly it's like all of sudden the right to modify Open Source Software makes sense in practice
2014-10-02T13:56:26Z dim: Grue`: I monkey patch from a distance
2014-10-02T13:56:45Z dim: which is even worse for maintenance, but I did open a bug report to get the issue fixed
2014-10-02T13:57:40Z fe[nl]ix: dim: after all, the gnu manifesto was written with a mixed Lisp/C idea in mind
2014-10-02T13:57:49Z przl quit (Ping timeout: 260 seconds)
2014-10-02T13:57:55Z moore33: Clone the project into local-projects and fix there.
2014-10-02T13:58:19Z dim: the fix I have is nothing proper
2014-10-02T13:58:36Z dim: it forbids using nil as the "ignore binding", leaving only _
2014-10-02T13:59:04Z fe[nl]ix: why ?
2014-10-02T13:59:05Z dim: I guess a proper fix would know to leave alone the nil in (&key (foo nil foo-s-p)), and I don't want to write that fix
2014-10-02T13:59:41Z dim: I won't use nil instead of _ to ignore bindings, that's it
2014-10-02T13:59:44Z dim: I didn't want to anyway
2014-10-02T14:00:41Z jtza8 quit (Ping timeout: 272 seconds)
2014-10-02T14:01:27Z Xach: dim: clbuild was way better at supporting it. i'd like to get closer to that facility.
2014-10-02T14:02:09Z Xach: clbuild unfortunately had its own drawbacks coming along with that benefit, like a greater potential for getting out of sync, or of some individual source control host not being available.
2014-10-02T14:02:26Z Xach: it would be interesting to see what it would look like today with some of the big, mostly-reliable code hosts available these days.
2014-10-02T14:02:50Z Xach: back in the bad old days, it was pretty common for a randomly hosted useful library to be unavailable for various host-related reasons
2014-10-02T14:02:50Z lduros joined #lisp
2014-10-02T14:04:00Z dim: I'm told that to get back the old-days unreliability of the internet, it's easy enough: go in China, behind the Great Firewall, where they feel free to cut any portions of the internet at any time for any reason
2014-10-02T14:06:24Z ahungry_ joined #lisp
2014-10-02T14:09:29Z MutSbeta joined #lisp
2014-10-02T14:10:47Z kushal joined #lisp
2014-10-02T14:12:15Z fortitude: I'd like to reuse some functions and macros from package A, but expose them from package B, and exporting the symbols is insufficient
2014-10-02T14:12:19Z fortitude: is there a reasonable way to do that?
2014-10-02T14:12:21Z tkhoa2711 quit (Ping timeout: 260 seconds)
2014-10-02T14:14:51Z Adlai joined #lisp
2014-10-02T14:16:30Z Xach: Why is exporting the symbols insufficient?
2014-10-02T14:17:31Z fortitude: I thought it would be, but e.g. given a macro A:bar, B:bar doesn't macroexpand
2014-10-02T14:17:40Z Grue` quit (Ping timeout: 244 seconds)
2014-10-02T14:18:11Z fortitude: ... or I'm just not paying any attention
2014-10-02T14:18:11Z |3b|: do you mean it isn't recognized as a macro or that macroexpansion errors?
2014-10-02T14:18:30Z Adlai: fortitude: needed to include a in b?
2014-10-02T14:18:35Z Xach: fortitude: is (eq a:bar b:bar) true?
2014-10-02T14:18:42Z Xach: err, (eq 'a:bar 'b:bar)
2014-10-02T14:18:45Z nonamae joined #lisp
2014-10-02T14:19:02Z fortitude: Xach: nope
2014-10-02T14:19:02Z Adlai: d if it's both bound and exported, the former would be true too!
2014-10-02T14:19:34Z fortitude: Xach: I'm exporting with an (:export A:foo) in my defpackage form
2014-10-02T14:19:41Z fortitude: not sure if that's actually correct
2014-10-02T14:19:41Z przl_ quit (Ping timeout: 272 seconds)
2014-10-02T14:20:13Z |3b|: may need to import it first, DEFPACKAGE just looks at names, not symbols
2014-10-02T14:20:37Z fortitude: |3b|: I thought that might be an issue, I'll investigate
2014-10-02T14:20:44Z clarkema quit (Quit: clarkema)
2014-10-02T14:21:04Z Xach: fortitude: Do you also have (:use :a)?
2014-10-02T14:21:17Z |3b|: so export #:foo :foo "FOO" a:foo all export same symbol, which is whatever symbol named FOO is visible in that package (assuming normal reader settings)
2014-10-02T14:21:58Z clarkema joined #lisp
2014-10-02T14:22:10Z fortitude: Xach, |3b|: I wasn't importing the symbol, which was the problem
2014-10-02T14:22:22Z fortitude: I assumed defpackage picked up on the package qualifier when it didn't complain
2014-10-02T14:22:26Z Xach: fortitude: you don't have to import; you can also inherit. but either way, it must be accessible.
2014-10-02T14:22:40Z fortitude: Xach: right
2014-10-02T14:22:42Z Xach: fortitude: no, it just takes the symbol-name of whatever symbol you give it.
2014-10-02T14:22:51Z stassats joined #lisp
2014-10-02T14:22:56Z przl joined #lisp
2014-10-02T14:25:41Z fortitude: success at last: sxql extended for a non-sql query language
2014-10-02T14:25:47Z fortitude: now I just need to /do/ something with it
2014-10-02T14:26:09Z munksgaard joined #lisp
2014-10-02T14:26:52Z wasamasa: fortitude: which one?
2014-10-02T14:28:22Z fortitude: wasamasa: that's a trick question, because it's actually just a particular chunk of a db language
2014-10-02T14:28:42Z fortitude: not something that's generally useful, but it'll make my bridge a lot nicer to use
2014-10-02T14:28:47Z wasamasa: fortitude: something of the sort the mongodb folks invented?
2014-10-02T14:29:10Z fortitude: wasamasa: more like misguided 4gl from the '80s
2014-10-02T14:29:34Z ndrei joined #lisp
2014-10-02T14:29:37Z beach joined #lisp
2014-10-02T14:29:50Z beach: Good afternoon everyone!
2014-10-02T14:29:57Z Karl_Dscc quit (Remote host closed the connection)
2014-10-02T14:29:58Z wasamasa: fortitude: :<
2014-10-02T14:30:24Z fortitude: wasamasa: indeed, but now I can write my code in lisp, so life just got a whole lot better
2014-10-02T14:30:53Z moore33: beach: Hey beach. I mentioned http://www.reddit.com/r/lisp/comments/2hwyum/french_course_on_lisp_programming_slides/
2014-10-02T14:31:06Z nyef: Hello beach.
2014-10-02T14:31:07Z beach: Yeah, saw it in the logs.
2014-10-02T14:31:34Z askatasuna joined #lisp
2014-10-02T14:31:52Z Harag quit (Ping timeout: 240 seconds)
2014-10-02T14:32:13Z cross joined #lisp
2014-10-02T14:32:22Z hitecnologys quit (Ping timeout: 272 seconds)
2014-10-02T14:32:31Z beach: moore33: This might be the last year it is taught.
2014-10-02T14:32:52Z moore33: beach: Are Irène's slides hers, or do they include stuff you wrote?
2014-10-02T14:32:54Z tadni quit (Remote host closed the connection)
2014-10-02T14:33:26Z beach: I haven't looked, but she has done major modifications, so they are pretty much ers.
2014-10-02T14:33:28Z beach: hers
2014-10-02T14:33:43Z beach: In addition, we do a lot of interactive typing during the lecture.
2014-10-02T14:33:52Z beach: I did, she does.
2014-10-02T14:34:01Z moore33: Ok. That's new in the last 11 years :)
2014-10-02T14:34:20Z tadni joined #lisp
2014-10-02T14:34:27Z Adlai quit (Ping timeout: 264 seconds)
2014-10-02T14:34:52Z beach: It becomes more "real" that way, and one can show various SLIME/Emacs tricks.
2014-10-02T14:35:13Z sword`` quit (Remote host closed the connection)
2014-10-02T14:35:21Z moore33: Absolutely.
2014-10-02T14:35:29Z sword`` joined #lisp
2014-10-02T14:35:56Z ndrei quit (Ping timeout: 250 seconds)
2014-10-02T14:38:59Z beach: moore33: I started watching a 3 hour long video on OpenGL.
2014-10-02T14:39:00Z jtza8 joined #lisp
2014-10-02T14:39:06Z beach: I have watched about a third of it.
2014-10-02T14:39:56Z tadni` joined #lisp
2014-10-02T14:40:04Z moore33: beach: Which one?
2014-10-02T14:40:31Z beach: SIGGRAPH University : "An Introduction to OpenGL Programming"
2014-10-02T14:40:44Z hitecnologys joined #lisp
2014-10-02T14:40:49Z tadni quit (Ping timeout: 260 seconds)
2014-10-02T14:41:21Z moore33: ok
2014-10-02T14:41:26Z beach: https://www.youtube.com/watch?v=6-9XFm7XAT8
2014-10-02T14:42:01Z beach: The speakers are supposedly authors of some authoritative book on OpenGL.
2014-10-02T14:42:20Z ndrei joined #lisp
2014-10-02T14:42:24Z beach: Oh, and it covers modern versions of OpenGL, and modern techniques.
2014-10-02T14:42:40Z beach: But I can't say I am impressed with their programming style so far.
2014-10-02T14:42:46Z |3b|: modern is good :)
2014-10-02T14:42:54Z rme makes a note to watch that
2014-10-02T14:43:04Z munksgaard quit (Ping timeout: 260 seconds)
2014-10-02T14:43:06Z xificurC quit (Quit: WeeChat 1.0)
2014-10-02T14:43:34Z |3b|: modern opengl is sort of annoying to try to combine 'good style' with 'good exposition' :/
2014-10-02T14:43:35Z moore33: Ed Angel has written an introductory graphics textbook that uses OpenGL.
2014-10-02T14:43:57Z wasamasa: moore33: which one?
2014-10-02T14:44:01Z beach: I keep feeling sorry for them that they have to use C.
2014-10-02T14:44:13Z wasamasa: moore33: this: http://www.cs.unm.edu/~angel/BOOK/INTERACTIVE_COMPUTER_GRAPHICS/SIXTH_EDITION/ ?
2014-10-02T14:44:24Z moore33: wasamasa: Yeah
2014-10-02T14:44:58Z vinleod joined #lisp
2014-10-02T14:45:24Z beach: moore33: The purpose of my doing that is so that I can understand your plans for an OpenGL backend for CLIMatis.
2014-10-02T14:45:45Z beach: ... and so that I can understand/maintain the OpenGL backend for McCLIM.
2014-10-02T14:45:46Z wasamasa: moore33: thanks, I'll keep them around in the case I'll be able to do opengl in emacs :P
2014-10-02T14:46:19Z |3b|: beach: not sure CL would be any better for trying to explain things from scratch, still have to do all the boilerplate stuff :/
2014-10-02T14:46:49Z |3b|: and mostly stuff that abstracts reasonably with just the tools available in C
2014-10-02T14:47:06Z moore33: beach: Yeah, good plan. The McClim OpenGL backend is very broken.
2014-10-02T14:48:17Z beach: moore33: I didn't know it was broken.  But I figured it must use "old style" OpenGL.
2014-10-02T14:48:49Z beach: |3b|: You might be right.  I'll have more to say about it in a few years. :)
2014-10-02T14:49:25Z Grue` joined #lisp
2014-10-02T14:49:47Z moore33: beach: I don't think it has worked for years... I remember seeing that the authors ran off into the weeds trying to deal with implementing sheets in a non-mirrored backend.
2014-10-02T14:50:10Z beach: Oh, OK, so that will be a good exercise for me then.
2014-10-02T14:50:58Z beach: Who is the author again?
2014-10-02T14:51:21Z moore33: beach: Are you coming around to the notion that doing rendering in OpenGL would be a good thing? :)
2014-10-02T14:51:36Z moore33: beach: Some of your students from years ago; maybe Iban was in on it?
2014-10-02T14:51:45Z beach: Oh! :)
2014-10-02T14:52:25Z moore33: beach: Oh yeah, it also uses obsolete FFI bindings to OpenGL, just to add to the fun.
2014-10-02T14:52:47Z beach: Good, good! :)
2014-10-02T14:53:04Z moore33: Julien Boninfante
2014-10-02T14:53:06Z gingerale joined #lisp
2014-10-02T14:53:10Z beach: Ah, OK.
2014-10-02T14:53:30Z beach: Before doing anything substantial, I'll consult you about recent bindings and windowing interfaces.
2014-10-02T14:54:02Z moore33: beach: I'm currently an expert in that :)
2014-10-02T14:54:09Z beach: I know! :)
2014-10-02T14:54:28Z moore33: beach: However, I must bow in |3b|'s direction.
2014-10-02T14:54:42Z beach: No problem.
2014-10-02T14:55:26Z beach: moore33: I few days ago, a newcomer here asked about McCLIM, so I ran the demos for the first time in a while.  I was quite impressed actually.  It again made me excited about working on both McCLIM and CLIMatis.
2014-10-02T14:55:40Z beach: McCLIM is not nearly as bad as some people claim.
2014-10-02T14:55:45Z moore33: Great!
2014-10-02T14:56:11Z stardiviner quit (Ping timeout: 272 seconds)
2014-10-02T14:56:17Z moore33: I was reading the Symbolics Dynamic Windows manual on the bus yesterday :)
2014-10-02T14:56:34Z beach: That's the CLIM predecessor right?
2014-10-02T14:56:38Z moore33: Yes.
2014-10-02T14:56:53Z beach: Uses Flavors, yes?
2014-10-02T14:57:06Z moore33: The high level (not "Silica") is very close to CLIM. Yes, Flavors.
2014-10-02T14:58:09Z stassats: "not nearly as bad" isn't an inviting description
2014-10-02T14:58:28Z nyef: Is Dynamic Windows massively thread-happy, on the level of BeOS?
2014-10-02T14:58:54Z moore33: nyef: I don't think so; rather the opposite.
2014-10-02T14:59:26Z nyef: I know from reading Lisp Lore that the windowing system there basically requires a thread per pane.
2014-10-02T15:00:32Z moore33: nyef: That might be true, but I think in the LispM context, you are really talking about an application per pane.
2014-10-02T15:01:07Z nyef: No, this was specifically in the context of a single application frame.
2014-10-02T15:01:36Z moore33: I will have to dig out my copy of Lisp Lore, but I don't think that is true.
2014-10-02T15:02:01Z lduros quit (Remote host closed the connection)
2014-10-02T15:02:28Z moore33: I think dw application frames behave like CLIM application frames, more or less.
2014-10-02T15:06:43Z Karl_Dscc joined #lisp
2014-10-02T15:08:36Z nyef: Basically, I read this bit, and realized that it made sense of a goodly amount of weirdness in the CLIM II spec, but that it was also horrifying from a certain perspective.
2014-10-02T15:08:49Z nonamae quit (Ping timeout: 244 seconds)
2014-10-02T15:08:52Z varjag quit (Quit: Leaving)
2014-10-02T15:10:18Z k-stz quit (Quit: ERC Version 5.3 (IRC client for Emacs))
2014-10-02T15:10:18Z dim: fe[nl]ix: in case you are curious about the monkey patch I'm using, you can see it in https://github.com/dimitri/pgloader/commit/3c334dcdc446a243ae33f41d7ad2a9fcf9b32c32
2014-10-02T15:10:36Z zacharias quit (Ping timeout: 260 seconds)
2014-10-02T15:10:46Z moore33: nyef: Now I'm curious.
2014-10-02T15:12:56Z MoALTz joined #lisp
2014-10-02T15:13:39Z nonamae joined #lisp
2014-10-02T15:15:56Z ThomasH joined #lisp
2014-10-02T15:16:02Z ThomasH: Greetings lispers
2014-10-02T15:16:34Z nyef: IIRC, Lisp Lore is available as a scan by way of the internet archive.
2014-10-02T15:16:49Z beach: Hello ThomasH.
2014-10-02T15:17:33Z innertracks joined #lisp
2014-10-02T15:17:37Z ThomasH: Is there any way to apply the rule of float precision contagion to a list of floats without using a numerical function? I just want to determine what the result would be.
2014-10-02T15:17:44Z ThomasH: Hello beach
2014-10-02T15:17:47Z stepnem quit (Ping timeout: 272 seconds)
2014-10-02T15:17:47Z stepnem joined #lisp
2014-10-02T15:17:54Z zacharias joined #lisp
2014-10-02T15:18:04Z ThomasH: The TYPE-OF the result, that is.
2014-10-02T15:18:38Z pjb: You need a sexp, not just a list of arguments.
2014-10-02T15:18:48Z pjb: Then you can compute the type, without computing the expression.
2014-10-02T15:18:51Z beach: ThomasH: As if some operation had been applied to those floats?
2014-10-02T15:19:00Z pjb: What operation? + or truncate?
2014-10-02T15:19:26Z ThomasH: beach: yes, pjb +, but without actually performing the addition.
2014-10-02T15:21:04Z clarkema quit (Quit: clarkema)
2014-10-02T15:21:09Z moore33: nyef: I found it on archive.org, and I see what you are saying: for applications with multiple panes, he does seem to be advocating multiple processes to handle input in each pane. I don't know if that is strictly necessary, but it might have been an easy way to do it.
2014-10-02T15:21:27Z ndrei quit (Ping timeout: 245 seconds)
2014-10-02T15:22:26Z stassats: ThomasH: limited floats only?
2014-10-02T15:23:33Z stassats: to floats, that is
2014-10-02T15:23:39Z ThomasH: stassats: I can live with limiting it to only floats, that is a reasonable limitation.
2014-10-02T15:23:41Z ndrei joined #lisp
2014-10-02T15:23:54Z moore33: nyef: However, the version on the net may be pre- Dynamic Windows... that phrase doesn't seem to exist in the scan, nor does dw:.
2014-10-02T15:25:00Z stassats: ThomasH: or not limiting to anything, you can make a state machine
2014-10-02T15:25:38Z moore33: nyef: Now I've found the second edition, so stay tuned ;)
2014-10-02T15:26:03Z nyef: moore33: Okay, looking forward to possibly updating my mental models here.
2014-10-02T15:26:11Z ThomasH: stassats: I was hoping for something simple, probably implementation specific. This doesn't warrant the effort of a state machine.
2014-10-02T15:27:17Z stassats: there's no effort?
2014-10-02T15:27:20Z gniourf joined #lisp
2014-10-02T15:27:23Z stassats: i mean, it's pretty trivial
2014-10-02T15:28:57Z ThomasH: I may be worrying about the root of all evil, pre-mature optimization.
2014-10-02T15:29:02Z EvW joined #lisp
2014-10-02T15:29:29Z stassats: applying the function may also produce an error
2014-10-02T15:29:38Z stassats: so, it's not only about optimization
2014-10-02T15:33:10Z ThomasH: My initial idea was (type-of (apply #'+ (list-of-floats))), but that didn't seem elegant. If it produces an error, that's okay.
2014-10-02T15:33:23Z stassats: type-of isn't a good thing
2014-10-02T15:33:37Z ThomasH: Except it could overflow, perhaps.
2014-10-02T15:34:02Z nyef: ... Someone totally needs to buy all-evil.com, so that they can be root@all-evil.com.
2014-10-02T15:34:53Z ndrei quit (Read error: No route to host)
2014-10-02T15:35:01Z stassats: ThomasH: why determine it at all?
2014-10-02T15:35:18Z stassats: nyef: will root@google.com do?
2014-10-02T15:35:39Z Adlai joined #lisp
2014-10-02T15:35:40Z nyef: Heh.
2014-10-02T15:37:05Z tankrim quit (Remote host closed the connection)
2014-10-02T15:37:42Z moore33: nyef: A very quick scan confirms my recollection. In Dynamic Windows, on which the 2nd edition of Lisp Lore is based, a process owns a whole window, like in X, but there is certainly not a process per pane. The older Symbolics stuff seems to have used a process-per-pane, but I think the "pane" was more like a top-level window.
2014-10-02T15:38:16Z moore33: early LispM GUI = great big hack
2014-10-02T15:38:41Z Xach: it's hacks all the way down
2014-10-02T15:38:53Z ThomasH: stassats: working with arrays, trying to set the element-type. Did it wrong and not getting errors, for example, setting a single-float array with a double-float value.
2014-10-02T15:39:06Z ThomasH: *now* getting errors
2014-10-02T15:39:15Z ndrei joined #lisp
2014-10-02T15:39:31Z nyef: Hrm. Okay, so now I need to try and get a second edition Lisp Lore. Good to know.
2014-10-02T15:39:38Z stassats: precomputing all types doesn't sound like a great idea, use a t array?
2014-10-02T15:40:16Z ThomasH: stassats: That is the robust solution.
2014-10-02T15:40:18Z moore33: nyef:http://bookzz.org/book/2116936/af3e28
2014-10-02T15:40:30Z jusss quit (Quit: ERC Version 5.2 (IRC client for Emacs))
2014-10-02T15:40:42Z Cymew quit (Ping timeout: 245 seconds)
2014-10-02T15:40:49Z |3b|: ThomasH: or force the type before writing to the array if you aren't sure
2014-10-02T15:41:31Z nyef: moore33: Thanks. Far  better than paying eBay prices for a hardcopy.
2014-10-02T15:41:37Z ThomasH: |3b|: Yes, I thought about punting and making everything double-float. Where's the fun in that?
2014-10-02T15:42:10Z nyef: Don't have time to read it now, unfortunately, but maybe tonight or this weekend.
2014-10-02T15:42:34Z tkhoa2711 joined #lisp
2014-10-02T15:42:45Z stassats: ThomasH: so, applying the function isn't going to be any better than a t-array
2014-10-02T15:43:49Z ThomasH: stassats: Understood
2014-10-02T15:44:09Z stassats: (or (and (find-if (lambda (x) (typep (x) (typep x 'double-float))) arguments) 'double-float) 'single-float)
2014-10-02T15:44:22Z mac_ified joined #lisp
2014-10-02T15:44:25Z stassats: remove either of (typep (x)
2014-10-02T15:45:04Z _zacts_ joined #lisp
2014-10-02T15:46:53Z innertracks quit (Quit: innertracks)
2014-10-02T15:48:28Z drmeister: stassats: Hello, you said clasp didn't build on Debian Sid - is there anything I can help with or do you want to wait until it's rock solid?
2014-10-02T15:48:41Z ThomasH: stassats: That's the kind of solution I was arriving at that motivated me to look for something builtin. As you noted, pre-computing the type is probably doing it wrong.
2014-10-02T15:48:57Z stassats: drmeister: well, i won't have much time to use it anyway until november, so, i guess i'll wait to build it
2014-10-02T15:49:32Z drmeister: Ok, no problem.  Let's pick it up later then.
2014-10-02T15:50:14Z Shinmera: Can anyone tell me why cliki is down?
2014-10-02T15:50:23Z stassats: minion: cliki?
2014-10-02T15:50:28Z minion: cliki: index: I can't be expected to work when CLiki doesn't respond to me, can I?
2014-10-02T15:50:53Z guicho: it seems down
2014-10-02T15:50:54Z stassats: minion: do you know why?
2014-10-02T15:50:55Z drmeister: But when you do I'll be happy to help out.  Some of the stuff that I know you will find useful is not documented yet and I'd like to use the experience of developing code to automatically generate a complex FFI to improve Clasp.
2014-10-02T15:50:59Z minion: do you know why: I can't be expected to work when CLiki doesn't respond to me, can I?
2014-10-02T15:51:49Z edgar-rft quit (Quit: you are not expected to understand this message)
2014-10-02T15:52:00Z Fare joined #lisp
2014-10-02T15:53:16Z _zacts_ quit (Quit: leaving)
2014-10-02T15:54:14Z LiamH joined #lisp
2014-10-02T15:54:54Z ehu: Shinmera: no idea. but the reason it's not already up is that I can't get reset the server at the moment (my request to get sudo is still pending)
2014-10-02T15:55:12Z Shinmera: Alright, I'll be patient then.
2014-10-02T15:55:42Z splittist: Shinmera: you can use this time to write more great software! (Thanks for all you've done, btw.)
2014-10-02T15:55:57Z slyrus joined #lisp
2014-10-02T15:56:38Z Shinmera: splittist: I need to take some time to relax right now. More coding later today maybe, or tomorrow by the latest.
2014-10-02T15:57:22Z splittist: I'll give you until Monday (:
2014-10-02T16:02:08Z mishoo_ joined #lisp
2014-10-02T16:04:52Z mishoo quit (Ping timeout: 240 seconds)
2014-10-02T16:06:10Z przl quit (Ping timeout: 244 seconds)
2014-10-02T16:09:00Z Joreji joined #lisp
2014-10-02T16:13:00Z rtra quit (Remote host closed the connection)
2014-10-02T16:14:29Z ovidnis joined #lisp
2014-10-02T16:16:50Z kobain joined #lisp
2014-10-02T16:16:54Z zacharias quit (Ping timeout: 250 seconds)
2014-10-02T16:16:55Z _zacts_ joined #lisp
2014-10-02T16:17:37Z Hache_ joined #lisp
2014-10-02T16:18:57Z pt1 quit (Ping timeout: 245 seconds)
2014-10-02T16:21:33Z normanrichards joined #lisp
2014-10-02T16:21:34Z normanrichards quit (Read error: Connection reset by peer)
2014-10-02T16:22:01Z svetlyak40wt joined #lisp
2014-10-02T16:22:33Z innertracks joined #lisp
2014-10-02T16:25:25Z ltbarcly joined #lisp
2014-10-02T16:25:36Z sivoais quit (Remote host closed the connection)
2014-10-02T16:25:42Z sivoais joined #lisp
2014-10-02T16:28:12Z slyrus quit (Ping timeout: 245 seconds)
2014-10-02T16:29:17Z Fare quit (Ping timeout: 272 seconds)
2014-10-02T16:29:39Z Adlai quit (Ping timeout: 264 seconds)
2014-10-02T16:30:37Z Fare joined #lisp
2014-10-02T16:32:31Z EvW quit (Ping timeout: 272 seconds)
2014-10-02T16:35:39Z janmuffino joined #lisp
2014-10-02T16:37:52Z phao joined #lisp
2014-10-02T16:38:25Z phao quit (Client Quit)
2014-10-02T16:38:57Z _zacts_ quit (Ping timeout: 245 seconds)
2014-10-02T16:39:22Z slyrus joined #lisp
2014-10-02T16:40:46Z moore33 quit
2014-10-02T16:44:13Z tkhoa2711 quit (Quit: tkhoa2711)
2014-10-02T16:49:39Z urandom__ joined #lisp
2014-10-02T16:51:04Z attila_lendvai quit (Quit: Leaving.)
2014-10-02T16:56:42Z Fare quit (Quit: Leaving)
2014-10-02T16:57:35Z przl joined #lisp
2014-10-02T16:58:56Z jkaye quit (Remote host closed the connection)
2014-10-02T16:59:30Z jkaye joined #lisp
2014-10-02T17:00:21Z slyrus quit (Ping timeout: 260 seconds)
2014-10-02T17:02:21Z varjag_ joined #lisp
2014-10-02T17:03:48Z jkaye quit (Ping timeout: 246 seconds)
2014-10-02T17:05:21Z jkaye joined #lisp
2014-10-02T17:09:58Z lduros joined #lisp
2014-10-02T17:10:09Z przl quit (Quit: leaving)
2014-10-02T17:12:16Z Xach left #lisp
2014-10-02T17:12:47Z innertracks quit (Quit: innertracks)
2014-10-02T17:12:49Z hugod quit (Remote host closed the connection)
2014-10-02T17:13:09Z innertracks joined #lisp
2014-10-02T17:13:56Z hlavaty` quit (Read error: Connection reset by peer)
2014-10-02T17:14:34Z hlavaty` joined #lisp
2014-10-02T17:15:52Z jkaye quit (Ping timeout: 258 seconds)
2014-10-02T17:15:52Z pnpuff joined #lisp
2014-10-02T17:16:26Z srcerer joined #lisp
2014-10-02T17:16:31Z srcerer quit (Client Quit)
2014-10-02T17:19:18Z hugod joined #lisp
2014-10-02T17:19:27Z sz0 joined #lisp
2014-10-02T17:19:28Z srcerer joined #lisp
2014-10-02T17:22:27Z pnpuff quit (Quit: Lost terminal)
2014-10-02T17:24:48Z stassats quit (Ping timeout: 246 seconds)
2014-10-02T17:26:52Z Joreji quit (Ping timeout: 245 seconds)
2014-10-02T17:30:45Z resttime joined #lisp
2014-10-02T17:36:40Z nug700 joined #lisp
2014-10-02T17:37:52Z _zacts_ joined #lisp
2014-10-02T17:38:25Z clarkema joined #lisp
2014-10-02T17:38:49Z hitecnologys quit (Quit: hitecnologys)
2014-10-02T17:40:42Z ndrei quit (Ping timeout: 245 seconds)
2014-10-02T17:41:32Z joneshf-laptop quit (Ping timeout: 245 seconds)
2014-10-02T17:41:51Z zacharias joined #lisp
2014-10-02T17:42:47Z jkaye joined #lisp
2014-10-02T17:43:11Z _zacts_ quit (Quit: leaving)
2014-10-02T17:44:54Z hardenedapple joined #lisp
2014-10-02T17:45:32Z ehu quit (Ping timeout: 260 seconds)
2014-10-02T17:46:37Z MoALTz quit (Quit: Leaving)
2014-10-02T17:48:19Z Joreji joined #lisp
2014-10-02T17:48:20Z beach left #lisp
2014-10-02T17:48:57Z sz0 quit
2014-10-02T17:50:11Z clarkema quit (Quit: clarkema)
2014-10-02T17:51:42Z Ven joined #lisp
2014-10-02T17:53:05Z clarkema joined #lisp
2014-10-02T17:58:24Z ovidnis quit (Ping timeout: 246 seconds)
2014-10-02T18:00:24Z guicho quit (Read error: Connection reset by peer)
2014-10-02T18:04:49Z akkad joined #lisp
2014-10-02T18:04:56Z paroneayea quit (Changing host)
2014-10-02T18:04:57Z paroneayea joined #lisp
2014-10-02T18:05:25Z ovidnis joined #lisp
2014-10-02T18:05:51Z oudeis joined #lisp
2014-10-02T18:06:11Z zeitue quit (Ping timeout: 272 seconds)
2014-10-02T18:08:00Z pnpuff joined #lisp
2014-10-02T18:08:22Z innertracks quit (Quit: innertracks)
2014-10-02T18:09:17Z clarkema quit (Quit: clarkema)
2014-10-02T18:15:16Z clarkema joined #lisp
2014-10-02T18:15:18Z ovidnis quit (Quit: Lost terminal)
2014-10-02T18:15:24Z clarkema quit (Client Quit)
2014-10-02T18:16:38Z slyrus joined #lisp
2014-10-02T18:17:35Z resttime quit (Ping timeout: 258 seconds)
2014-10-02T18:18:34Z kushal quit (Quit: Leaving)
2014-10-02T18:19:33Z zeitue joined #lisp
2014-10-02T18:22:14Z LesZedCB joined #lisp
2014-10-02T18:22:19Z LesZedCB: hi guys
2014-10-02T18:23:11Z LesZedCB left #lisp
2014-10-02T18:23:43Z chase_gray joined #lisp
2014-10-02T18:25:12Z yrk quit (Read error: Connection reset by peer)
2014-10-02T18:26:45Z akkad: and gals
2014-10-02T18:29:38Z chase_gray: Is there a way to cons elements to a list which is more efficient than (setq x (cons a x))? I.e. can we skip having to create a new list and just directly append?
2014-10-02T18:29:40Z pnpuff left #lisp
2014-10-02T18:30:36Z ggole: Creating a "new list" isn't expensive because list structure is shared between new and old.
2014-10-02T18:31:03Z dlowe: chase_gray: that's a very efficient operation. You can also use (push a x) to do the same thing
2014-10-02T18:31:52Z ggole: Typically (cons a b) is nothing more than allocating and initialising a two-word record.
2014-10-02T18:33:10Z Ven quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
2014-10-02T18:33:29Z denisrum quit (Ping timeout: 272 seconds)
2014-10-02T18:34:41Z eudoxia quit (Quit: Lost terminal)
2014-10-02T18:35:08Z chase_gray: oh ok
2014-10-02T18:35:10Z chase_gray: thank you
2014-10-02T18:36:26Z oudeis quit (Quit: This computer has gone to sleep)
2014-10-02T18:39:30Z yrk joined #lisp
2014-10-02T18:39:56Z yrk quit (Changing host)
2014-10-02T18:39:56Z yrk joined #lisp
2014-10-02T18:40:06Z ndrei joined #lisp
2014-10-02T18:40:46Z pierre1_ quit (Ping timeout: 250 seconds)
2014-10-02T18:42:33Z farhaven quit (Ping timeout: 260 seconds)
2014-10-02T18:42:57Z Patzy quit (Ping timeout: 260 seconds)
2014-10-02T18:43:34Z Patzy joined #lisp
2014-10-02T18:47:08Z chase_gray quit (Ping timeout: 260 seconds)
2014-10-02T18:48:52Z Patzy quit (Ping timeout: 240 seconds)
2014-10-02T18:48:55Z BitPuffin quit (Ping timeout: 244 seconds)
2014-10-02T18:49:40Z Patzy joined #lisp
2014-10-02T18:54:17Z EvW joined #lisp
2014-10-02T18:57:26Z Ven joined #lisp
2014-10-02T18:57:38Z pierre1_ joined #lisp
2014-10-02T18:59:27Z slyrus quit (Ping timeout: 245 seconds)
2014-10-02T19:01:08Z ltbarcly quit (Quit: Computer has gone to sleep.)
2014-10-02T19:04:53Z ltbarcly joined #lisp
2014-10-02T19:05:48Z slyrus joined #lisp
2014-10-02T19:06:06Z jkaye quit (Remote host closed the connection)
2014-10-02T19:06:38Z jkaye joined #lisp
2014-10-02T19:06:53Z cmack joined #lisp
2014-10-02T19:10:16Z ehu joined #lisp
2014-10-02T19:10:52Z jkaye quit (Ping timeout: 258 seconds)
2014-10-02T19:16:12Z vinleod quit (Quit: ["Textual IRC Client: www.textualapp.com"])
2014-10-02T19:16:26Z jtza8 quit (Remote host closed the connection)
2014-10-02T19:17:45Z ehu: cliki back up
2014-10-02T19:18:32Z Shinmera: \o/
2014-10-02T19:22:35Z knosys quit (Quit: WeeChat 0.4.2)
2014-10-02T19:25:13Z paddymahoney joined #lisp
2014-10-02T19:27:16Z svetlyak40wt quit (Read error: Connection reset by peer)
2014-10-02T19:27:57Z kobain quit (Read error: Connection timed out)
2014-10-02T19:28:15Z kobain joined #lisp
2014-10-02T19:28:54Z normanrichards joined #lisp
2014-10-02T19:29:29Z kobain quit (Max SendQ exceeded)
2014-10-02T19:29:48Z kobain joined #lisp
2014-10-02T19:29:57Z stassats joined #lisp
2014-10-02T19:30:21Z kobain quit (Max SendQ exceeded)
2014-10-02T19:30:39Z kobain joined #lisp
2014-10-02T19:30:56Z svetlyak40wt joined #lisp
2014-10-02T19:31:39Z kobain quit (Max SendQ exceeded)
2014-10-02T19:32:01Z paddymahoney quit (Ping timeout: 260 seconds)
2014-10-02T19:33:46Z normanrichards quit (Client Quit)
2014-10-02T19:39:44Z jtza8 joined #lisp
2014-10-02T19:39:59Z farhaven joined #lisp
2014-10-02T19:39:59Z alexherbo2 quit (Read error: Connection reset by peer)
2014-10-02T19:43:32Z paddymahoney joined #lisp
2014-10-02T19:46:36Z marvimias changed the topic of #lisp to: Common Lisp, the #1=(programmable . #1#) programming language <http://cliki.net/> <http://paste.lisp.org/new> logs:<http://ccl.clozure.com/irc-logs/lisp/>|contact op if muted|common-lisp.net migration 2014-09-22@09:00UTC (http://bit.ly/1mmCw6o)|SBCL 1.2.4, yason 0.6.7, Drakma 1.3.10
2014-10-02T19:46:48Z marvimias left #lisp
2014-10-02T19:46:53Z marvimias joined #lisp
2014-10-02T19:47:00Z marvimias: lets say we try to make a strong artificial intellegence by creating a code that replicates itself and randomly modifies the code in random spots in its replication. It may take a long time and allot of the times there would be crashes, or whatever, but eventually you would get a artifical intellegence that could potentially want to take over and delete the world or just want hugs, but an operating system emulator should both take ca
2014-10-02T19:47:00Z marvimias: re of the artificial intellegence and the crashes, just make sure to not connect to the internet. Am i right or is it not possible?
2014-10-02T19:48:11Z stassats: are you trying to reinvent genetic algorithms?
2014-10-02T19:52:28Z slyrus quit (Ping timeout: 244 seconds)
2014-10-02T19:52:28Z arenz quit (Ping timeout: 260 seconds)
2014-10-02T19:52:35Z resttime joined #lisp
2014-10-02T19:53:51Z Karl_Dscc quit (Remote host closed the connection)
2014-10-02T19:54:04Z kobain joined #lisp
2014-10-02T19:54:14Z Grue`: marvimias: you can't create anything useful solely from randomness
2014-10-02T19:54:32Z slyrus joined #lisp
2014-10-02T19:54:58Z kobain quit (Client Quit)
2014-10-02T19:55:35Z kobain joined #lisp
2014-10-02T19:55:36Z Shinmera: Infinite monkeys!
2014-10-02T19:56:26Z Grue`: are theoretical, and Shakespeare is practical
2014-10-02T19:58:25Z Shinmera: Simple models are too tempting.
2014-10-02T19:58:45Z kobain quit (Client Quit)
2014-10-02T19:59:09Z pjb: It's easy, you just have to write a good fitness function.
2014-10-02T20:00:09Z moyamo joined #lisp
2014-10-02T20:00:22Z kobain joined #lisp
2014-10-02T20:00:53Z moyamo left #lisp
2014-10-02T20:00:56Z kobain quit (Max SendQ exceeded)
2014-10-02T20:01:14Z kobain joined #lisp
2014-10-02T20:01:46Z angavrilov quit (Remote host closed the connection)
2014-10-02T20:01:48Z kobain quit (Max SendQ exceeded)
2014-10-02T20:02:21Z kobain joined #lisp
2014-10-02T20:02:26Z kobain quit (Changing host)
2014-10-02T20:02:27Z kobain joined #lisp
2014-10-02T20:02:33Z normanrichards joined #lisp
2014-10-02T20:03:41Z kobain quit (Max SendQ exceeded)
2014-10-02T20:03:58Z kobain joined #lisp
2014-10-02T20:05:02Z kobain quit (Read error: Connection reset by peer)
2014-10-02T20:05:22Z tankrim joined #lisp
2014-10-02T20:06:47Z someone quit (Quit: ZNC - http://znc.in)
2014-10-02T20:06:52Z janmuffino quit (Ping timeout: 246 seconds)
2014-10-02T20:11:53Z fmu quit (Quit: End of line)
2014-10-02T20:12:23Z fmu joined #lisp
2014-10-02T20:12:57Z svetlyak40wt quit (Remote host closed the connection)
2014-10-02T20:13:36Z s0meone joined #lisp
2014-10-02T20:14:47Z s0meone is now known as someone
2014-10-02T20:17:16Z stassats: everytime i try all i get is Christopher Marlowe
2014-10-02T20:17:24Z dim: have the monkeys write the fitness function, rught?
2014-10-02T20:18:47Z tadni` is now known as tadni
2014-10-02T20:19:12Z pt1 joined #lisp
2014-10-02T20:19:48Z Hache_ quit (Remote host closed the connection)
2014-10-02T20:19:51Z nydel: yay my tarot package is getting fun! loaded in all the cards, functional draw-spread objects with optional tcl/tk side-effect gui ... now i get to write some sort of AI to make sense of the cards drawn. fun!
2014-10-02T20:21:30Z nydel: lisp is the #1 high-level programming language for occult pseudo-scientific research!
2014-10-02T20:22:02Z stassats: lisp is occult itslef
2014-10-02T20:22:33Z ThomasH: I've always liked my magic 8-ball function
2014-10-02T20:22:36Z nydel: stassats: isn't it? join my project. read: do it instead of me. need a competent programmer.
2014-10-02T20:23:51Z nydel: right now i have simple archetypal ideas of all the cards i got from aleister crowley. the words are simple enough that i think if i get wordnet involved i could pseudo-AI some interesting analytical results from a 3/10-card-spread.
2014-10-02T20:23:53Z work_op joined #lisp
2014-10-02T20:24:41Z nydel: need a few extra relational databases in place but it can work. science!
2014-10-02T20:24:54Z stassats: i'd rather be solving the issue of world hunger
2014-10-02T20:25:44Z nydel: stassats: so, what, like, a virtual pizza restaurant game for mobile phone using mocl?
2014-10-02T20:25:48Z ggole: Try "food".
2014-10-02T20:26:04Z ThomasH: My magic 8-ball function uses SVREF, RANDOM, and a vector of string responses. (declare (ignore query)). It's probably just as insightful.
2014-10-02T20:26:33Z stassats: nydel: something like logistics problems in food delivery could be a start
2014-10-02T20:26:53Z nydel: ThomasH: does your randomize stuff for your 8-ball just use built-in make-random-state stuff?
2014-10-02T20:27:22Z nydel: because i'm not happy with my draw function, it's not technically functional because of how i'm pulling random numbers.
2014-10-02T20:27:40Z nydel: would love to see how other pseudo-fortune-telling things are getting their random data.
2014-10-02T20:27:49Z stassats: why would it be functional?
2014-10-02T20:27:52Z ThomasH: nydel: (svref #(... responses ...) (random number-of-responses)) That's all.
2014-10-02T20:27:55Z nydel: stassats: that sounds like some pure maths stuff. aka super sexy.
2014-10-02T20:28:40Z nydel: stassats: as in why should it need to be? or what do you mean
2014-10-02T20:29:05Z akkad: mocl improved at all?
2014-10-02T20:29:13Z stassats: why is there a question about it being functional?
2014-10-02T20:29:36Z stassats: akkad: nope, still too expensive
2014-10-02T20:29:40Z Grue`: pseudo-randomly shuffling a deck of cards is a hard problem because the number of rng states is usually less than the number of of possible shufflings
2014-10-02T20:30:01Z chase_gray joined #lisp
2014-10-02T20:30:36Z nydel: akkad: short answer: in my humblest, no.
2014-10-02T20:32:04Z nydel: stassats: well aside from that my (draw) modifies something outside itself [the way random works] it is functional programming. has a domain and range.
2014-10-02T20:32:25Z nydel: Grue`: rng states?
2014-10-02T20:33:45Z fortitude: Grue`: wouldn't a fisher-yates shuffle works just as well?
2014-10-02T20:33:45Z pierre1_ quit (Ping timeout: 272 seconds)
2014-10-02T20:34:00Z fortitude: then you're only talking about the number of cards, not the number of permutations
2014-10-02T20:34:18Z gravicappa quit (Remote host closed the connection)
2014-10-02T20:35:53Z oGMo: Grue`: that makes little sense :p
2014-10-02T20:35:57Z Patzy quit (Ping timeout: 260 seconds)
2014-10-02T20:36:08Z Grue`: its a pigeonhole principle problem in any case, once you start with a certain seed the algorithm is deterministic
2014-10-02T20:36:27Z Patzy joined #lisp
2014-10-02T20:36:48Z oGMo: if you mean the number of starting states, it's irrelevant; if you mean the range of a given number from the RNG, you only need 2
2014-10-02T20:37:03Z oGMo: less and it's not really a rng anymore ;)
2014-10-02T20:38:05Z nydel: my draw function is line 4 of https://github.com/nydel/cl-tarot/blob/master/tarot.lisp and while it has a set domain and range it is technically not functional programming yet.
2014-10-02T20:38:11Z oGMo: Grue`: yes, trivially taking 52 choices from the RNG will not generate all possible shufflings; that is irrelevant .. but you don't necessarily need to pick the first 52, etc
2014-10-02T20:38:20Z stassats: nydel: why does it have to be functional programming?
2014-10-02T20:39:17Z stassats: protip: (if draw draw (draw 10)) => (or draw (draw 10))
2014-10-02T20:39:34Z dim: is there a function like last that returns the last element rather than the last cons cell?
2014-10-02T20:39:51Z stassats: dim: (car (last ...))
2014-10-02T20:39:56Z dim: yeah, ok
2014-10-02T20:40:00Z simulacrum quit (Remote host closed the connection)
2014-10-02T20:40:14Z dim: first/last gets on my nerves I guess
2014-10-02T20:40:39Z stassats: last has a second argument
2014-10-02T20:40:41Z stassats: that's why
2014-10-02T20:40:46Z nydel: stassats: it doesn't necessarily but i would rather
2014-10-02T20:40:51Z pjb: dim: (defun last-car (x &optional (n 1)) (car (last x n)))
2014-10-02T20:41:19Z pjb: s/last-car/nth-from-end/ :-)
2014-10-02T20:42:32Z Grue`: well your draw function is not biased to any number, but it *does* have unbounded running time
2014-10-02T20:42:48Z stassats: nydel: and the datastructure for cards, (1 . (1 "wands" "fire" #P"images/wands1.png")), is pretty terrible
2014-10-02T20:43:02Z ltbarcly quit (Quit: Computer has gone to sleep.)
2014-10-02T20:43:05Z Grue`: though it's not that significant with low num and deck size
2014-10-02T20:43:32Z stassats: which is then accessed like (integerp (first list)) (integerp (second list)) (stringp (third list)) (stringp (fourth list)) (pathnamep (fifth list))
2014-10-02T20:43:40Z stassats: and yet, you are worried about "functional"
2014-10-02T20:44:05Z cmack` joined #lisp
2014-10-02T20:44:09Z stassats: as well as stuff like (ql:quickload '(:bordeaux-threads :ltk))
2014-10-02T20:44:33Z nydel: oh hah that's not going to be that way. i have yet to do the CLOS part
2014-10-02T20:44:46Z dim: pjb: butlast-car
2014-10-02T20:45:05Z stassats: nydel: are you deliberately making it hard to modify then?
2014-10-02T20:45:17Z gingerale quit (Ping timeout: 245 seconds)
2014-10-02T20:45:19Z ThomasH: thelast
2014-10-02T20:45:20Z Grue`: you could at least start with a struct
2014-10-02T20:45:32Z nydel: stassats: that's a really good question. if you're talking about adding alternative decks etc.
2014-10-02T20:45:32Z stassats: nydel: (bt:make-thread (lambda () (&summon-window) :name "cl-tarot tcl/tk threaded window 0010")) has misplaced parenthesis and an LAMBDA is unnecessary at all
2014-10-02T20:45:39Z Grue`: though everyone else hates structs here so take my advie with a grain of salt
2014-10-02T20:45:40Z cmack quit (Ping timeout: 260 seconds)
2014-10-02T20:45:55Z pierre1_ joined #lisp
2014-10-02T20:45:56Z stassats: i love structures
2014-10-02T20:46:45Z nydel: stassats: i'm failing to see how a lambda is unnecessary there.. obviously i don't disagree i'm just not yet seeing it..
2014-10-02T20:47:01Z dim: I really like structures too
2014-10-02T20:47:08Z ltbarcly_ joined #lisp
2014-10-02T20:47:15Z chase_gray quit (Quit: ERC Version 5.3 (IRC client for Emacs))
2014-10-02T20:47:33Z stassats: nydel: it should be (bt:make-thread #'&summon-window :name "cl-tarot tcl/tk threaded window 0010")
2014-10-02T20:47:49Z Vivitron`` joined #lisp
2014-10-02T20:48:46Z nydel: stassats: yes yes it should shouldn't it. oh maybe you can help me with a question i have had trouble asking about standard formatting in function naming
2014-10-02T20:49:14Z nydel: if i have a function that does something like make an object, and a function that does nothing but call the first function but actually add it to a database or whatever
2014-10-02T20:49:55Z nydel: see how i'm naming stuff (&thing) for the one without side effect and (thing) for when it does have a side-effect
2014-10-02T20:50:05Z nydel: how is that usually done, is there an agreed-upon method
2014-10-02T20:50:37Z ThomasH: People that use common lisp agree on nothing
2014-10-02T20:50:54Z nydel: oh the lambda was for when there were tcl events to handle. they will come back.
2014-10-02T20:50:56Z ThomasH: thing would be side-effect free, thing* or nthing would be destructive
2014-10-02T20:50:57Z stassats: nydel: there is no need to denote side effects in CL
2014-10-02T20:51:20Z jkaye joined #lisp
2014-10-02T20:51:21Z ltbarcly joined #lisp
2014-10-02T20:51:44Z Vivitron quit (Ping timeout: 260 seconds)
2014-10-02T20:51:52Z nydel: stassats: so you wouldn't make a functional-create-a-person then a side-effect-create-a-person-and-add-it-to-rel-db
2014-10-02T20:52:18Z stassats: nope
2014-10-02T20:52:32Z stassats: i would have a generic ADD-TO-DB and MAKE-PERSON
2014-10-02T20:52:47Z ltbarcly_ quit (Ping timeout: 245 seconds)
2014-10-02T20:52:53Z nydel: (ha your brevity skills topple mine)
2014-10-02T20:53:02Z nydel: ok i wonder why i'm doing that.
2014-10-02T20:53:14Z sheilong joined #lisp
2014-10-02T20:53:17Z nydel: if not simple incompetence.
2014-10-02T20:53:21Z hardenedapple quit (Quit: WeeChat 1.0.1)
2014-10-02T20:53:45Z slyrus_ joined #lisp
2014-10-02T20:55:06Z Vivitron`` quit (Read error: Connection reset by peer)
2014-10-02T20:55:18Z ltbarcly quit (Client Quit)
2014-10-02T20:55:27Z nydel: mostly i'm using the project on which i happen to be working as example, and everything outside tarot.lisp is messy because i plan to redesign.
2014-10-02T20:55:32Z slyrus quit (Ping timeout: 250 seconds)
2014-10-02T20:55:36Z slyrus_ is now known as slyrus
2014-10-02T20:55:59Z Vivitron joined #lisp
2014-10-02T20:56:03Z stassats: your code doesn't look like it's written with a redesign in mind
2014-10-02T20:56:24Z Grue`: i think in scheme they mark side-effect functions with ! at the end, but in CL there's no distinction for such things
2014-10-02T20:56:25Z stassats: what with the main datastructure being a list and not having any accessors
2014-10-02T20:56:29Z nydel: everything outside tarot is, gui.lisp is a mess
2014-10-02T20:56:58Z Grue`: a convention for macros+spec forms vs functions would've been useful maybe but there's no such thing either
2014-10-02T20:57:07Z nydel: well about cards.lisp & the main data there, i thought it would be /easier/ to add onto if cards and decks were class objects
2014-10-02T20:57:29Z stassats: and where is the licence for the card images?
2014-10-02T20:57:36Z ahungry_ quit (Quit: leaving)
2014-10-02T20:58:08Z nydel: ty putting a license in images/
2014-10-02T20:58:19Z ThomasH: REVERSE / NREVERSE ... isn't that a convention?
2014-10-02T20:58:37Z stassats: REMOVE / DELETE, is that a convention?
2014-10-02T20:59:05Z ggherdov quit (Ping timeout: 272 seconds)
2014-10-02T20:59:29Z Ven quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
2014-10-02T20:59:49Z ThomasH: There is a convention, it shows up in some places in the standard
2014-10-02T20:59:53Z Grue`: yeah but you wouldn't name a function NDO-THING because that would be dumb
2014-10-02T21:00:02Z ThomasH: like the one I listed
2014-10-02T21:00:02Z nydel: haven't done much with graphics before, trying to figure the correct CC license for a folder of png/images
2014-10-02T21:00:09Z stassats: is SORT a convention?
2014-10-02T21:00:23Z stassats: nydel: did you draw them?
2014-10-02T21:00:54Z nydel: stassats: no you socratic sob lol, pamela coleman smith drew them after images described by arthur edward waite.
2014-10-02T21:01:24Z stassats: so, the correct licence is the one she chose
2014-10-02T21:01:34Z stassats: if none, then they are copyrighted and you cannot use them
2014-10-02T21:02:26Z nydel: the pure drawings are kept common so long as the Golden Dawn is mentioned i believe. it's the "radiant rider/waite" and "universal rider/waite" that are under us games something
2014-10-02T21:03:09Z nydel: gotta go digging for the correct facts and citations there.
2014-10-02T21:03:13Z stassats: so, consult with your lawyer
2014-10-02T21:04:13Z stassats: your images have © 1971 US Games, by the way
2014-10-02T21:04:49Z Fare joined #lisp
2014-10-02T21:05:39Z nydel: i'm pretty sure i can find that these are not those images (rider/waite) but the pure coleman/waite .. assuming i can't, would it mean i can't use them at all for an open-source project?
2014-10-02T21:06:06Z Shinmera: You can use them if you get permission to do so or if the license allows you to.
2014-10-02T21:06:28Z stassats: just draw your own
2014-10-02T21:06:42Z nydel: how does anyone use them? can't i invoke fair use or something?
2014-10-02T21:06:43Z Shinmera: Otherwise you'll most likely have to wait until ~2070 or summat for the copyright to expire.
2014-10-02T21:06:57Z stassats: no, fair use doesn't apply here at all
2014-10-02T21:06:59Z akkad: Allegro create smaller bins than LW?
2014-10-02T21:08:34Z lisper29 joined #lisp
2014-10-02T21:09:26Z nydel: ringing US Games. ha.
2014-10-02T21:09:26Z Vivitron quit (Read error: Connection reset by peer)
2014-10-02T21:09:55Z Vivitron joined #lisp
2014-10-02T21:09:59Z innertracks joined #lisp
2014-10-02T21:10:11Z nydel: (sometimes when i have to do something like this, the company ends up giving me money, so, yeah, we'll see!)
2014-10-02T21:10:59Z robot-beethoven joined #lisp
2014-10-02T21:10:59Z Vivitron quit (Read error: Connection reset by peer)
2014-10-02T21:11:53Z Vivitron joined #lisp
2014-10-02T21:11:55Z ggherdov joined #lisp
2014-10-02T21:13:48Z Vivitron`` joined #lisp
2014-10-02T21:13:48Z Vivitron quit (Read error: Connection reset by peer)
2014-10-02T21:15:29Z nydel: ah. as i thought. https://en.wikipedia.org/wiki/File:RWS_Tarot_01_Magician.jpg
2014-10-02T21:15:30Z Vivitron`` quit (Read error: Connection reset by peer)
2014-10-02T21:15:47Z stassats quit (Ping timeout: 272 seconds)
2014-10-02T21:17:35Z ltbarcly joined #lisp
2014-10-02T21:17:54Z ozzloy_ is now known as ozzloy
2014-10-02T21:18:02Z serichsen joined #lisp
2014-10-02T21:18:05Z ozzloy quit (Changing host)
2014-10-02T21:18:05Z ozzloy joined #lisp
2014-10-02T21:18:26Z knosys joined #lisp
2014-10-02T21:19:04Z serichsen: Good evening!
2014-10-02T21:20:21Z lisper29 quit (Ping timeout: 246 seconds)
2014-10-02T21:22:54Z ThomasH: Hello serichsen
2014-10-02T21:23:03Z lisper29` joined #lisp
2014-10-02T21:26:57Z mishoo_ quit (Ping timeout: 245 seconds)
2014-10-02T21:26:57Z hiyosi quit (Ping timeout: 245 seconds)
2014-10-02T21:30:56Z Lycurgus quit (Quit: This computer has gone to sleep)
2014-10-02T21:31:31Z MouldyOldBones quit (Remote host closed the connection)
2014-10-02T21:33:00Z MouldyOldBones joined #lisp
2014-10-02T21:33:13Z JuanitoJons joined #lisp
2014-10-02T21:34:00Z innertracks quit (Ping timeout: 246 seconds)
2014-10-02T21:38:14Z paroneay` joined #lisp
2014-10-02T21:38:37Z clog quit (Ping timeout: 245 seconds)
2014-10-02T21:39:36Z backupthrick quit (Ping timeout: 258 seconds)
2014-10-02T21:40:36Z paroneayea quit (Remote host closed the connection)
2014-10-02T21:40:55Z backupthrick joined #lisp
2014-10-02T21:41:22Z nydel quit (Remote host closed the connection)
2014-10-02T21:42:03Z JuanitoJons quit (Ping timeout: 246 seconds)
2014-10-02T21:42:08Z jreynoso_ joined #lisp
2014-10-02T21:45:04Z tadni quit (Quit: Brb.)
2014-10-02T21:45:19Z Fare quit (Ping timeout: 272 seconds)
2014-10-02T21:45:21Z fridim__ quit (Ping timeout: 258 seconds)
2014-10-02T21:47:14Z c107 joined #lisp
2014-10-02T21:47:44Z tadni joined #lisp
2014-10-02T21:47:47Z askatasuna quit (Ping timeout: 245 seconds)
2014-10-02T21:50:10Z serichsen quit (Quit: Bye)
2014-10-02T21:50:27Z mac_ified quit (Ping timeout: 246 seconds)
2014-10-02T21:55:44Z pt1 quit (Remote host closed the connection)
2014-10-02T21:57:12Z Shinmera quit (Quit: しつれいしなければならないんです。)
2014-10-02T21:58:03Z Fare joined #lisp
2014-10-02T21:59:48Z Fare quit (Client Quit)
2014-10-02T22:00:48Z antonv joined #lisp
2014-10-02T22:00:49Z billstclair quit (Read error: Connection reset by peer)
2014-10-02T22:01:01Z billstclair joined #lisp
2014-10-02T22:01:19Z ltbarcly quit (Quit: Computer has gone to sleep.)
2014-10-02T22:03:09Z phao joined #lisp
2014-10-02T22:03:50Z clog joined #lisp
2014-10-02T22:04:19Z slyrus quit (Ping timeout: 272 seconds)
2014-10-02T22:04:44Z ehu quit (Ping timeout: 244 seconds)
2014-10-02T22:06:56Z _xyjprc_ joined #lisp
2014-10-02T22:09:34Z Bicyclidine joined #lisp
2014-10-02T22:09:50Z jtza8 quit (Remote host closed the connection)
2014-10-02T22:11:34Z Svetlana quit (Quit: re-connecting)
2014-10-02T22:11:41Z Lycurgus joined #lisp
2014-10-02T22:11:57Z mrSpec quit (Remote host closed the connection)
2014-10-02T22:12:11Z ggole quit
2014-10-02T22:12:21Z _xyjprc_ quit (Remote host closed the connection)
2014-10-02T22:13:45Z tadni quit (Read error: Connection reset by peer)
2014-10-02T22:14:09Z oleo is now known as Guest6399
2014-10-02T22:14:18Z tadni joined #lisp
2014-10-02T22:14:20Z nonamae quit (Ping timeout: 260 seconds)
2014-10-02T22:15:53Z oleo__ joined #lisp
2014-10-02T22:15:59Z knosys quit (Quit: WeeChat 0.4.2)
2014-10-02T22:17:41Z Guest6399 quit (Ping timeout: 272 seconds)
2014-10-02T22:17:48Z knosys joined #lisp
2014-10-02T22:22:09Z EvW quit (Ping timeout: 258 seconds)
2014-10-02T22:23:57Z hiyosi joined #lisp
2014-10-02T22:28:30Z hiyosi quit (Ping timeout: 244 seconds)
2014-10-02T22:30:29Z innertracks joined #lisp
2014-10-02T22:30:50Z SrPx joined #lisp
2014-10-02T22:30:53Z SrPx: is anyone aware of a fast lisp implementation with hash-consing?
2014-10-02T22:31:37Z kuzy000_ quit (Ping timeout: 260 seconds)
2014-10-02T22:32:35Z White_Flame: implementing it on top of a fast implementation that doesn't have it seems to be fruitful
2014-10-02T22:32:37Z pjb: SrPx: that sounds like an oxymoron.
2014-10-02T22:32:57Z pjb: SrPx: besides, since Common Lisp conses are mutable, it's not applicable.
2014-10-02T22:33:08Z pjb: (you may try #lisp-lab for other lisps).
2014-10-02T22:33:49Z SrPx: pjb: why an oxymoron
2014-10-02T22:33:53Z sz0 joined #lisp
2014-10-02T22:34:39Z pjb: Because it takes time to hash all the conses…
2014-10-02T22:35:29Z pjb: Well, more than hash them, to uniquify them.
2014-10-02T22:35:55Z pjb: If you are presented: (1 . #some-cons#) (1 . #some-cons#)  are they the "same"?
2014-10-02T22:36:10Z SrPx: pjb: but I don't mean fast as in, "faster than CL", just as in, "as fast as one could get". i.e., a mature implementation
2014-10-02T22:36:37Z pjb: If you assume that #some-cons# is already interned, then ok, you can easily compare them. But if it's possible that they're not already interned, or even if they different but mutable, they now can be the same, or not.
2014-10-02T22:36:45Z SrPx: pjb: yes if (hash 1 (ptr #same-cons#)) is the same
2014-10-02T22:37:00Z ltbarcly joined #lisp
2014-10-02T22:37:01Z SrPx: pjb: I mean in a language with no immutability
2014-10-02T22:37:08Z SrPx: I know, I am in the wrong channel, I'm sorry
2014-10-02T22:37:14Z SrPx: no mutability*
2014-10-02T22:37:21Z pjb: Ok.
2014-10-02T22:41:15Z nydel joined #lisp
2014-10-02T22:46:23Z sz0 quit
2014-10-02T22:47:58Z byte48 joined #lisp
2014-10-02T22:49:03Z jreynoso_ quit (Quit: Saliendo)
2014-10-02T22:49:59Z Jesin quit (Quit: Leaving)
2014-10-02T22:50:22Z Jesin joined #lisp
2014-10-02T22:54:46Z jkaye quit (Remote host closed the connection)
2014-10-02T22:54:58Z bgs100 joined #lisp
2014-10-02T22:55:19Z jkaye joined #lisp
2014-10-02T22:58:07Z innertracks quit (Quit: innertracks)
2014-10-02T22:59:30Z jkaye quit (Ping timeout: 244 seconds)
2014-10-02T23:00:45Z cmack`` joined #lisp
2014-10-02T23:01:10Z vaporatorius quit (Remote host closed the connection)
2014-10-02T23:02:24Z LiamH quit (Quit: Leaving.)
2014-10-02T23:02:24Z cmack` quit (Ping timeout: 260 seconds)
2014-10-02T23:04:09Z zeitue quit (Ping timeout: 244 seconds)
2014-10-02T23:05:13Z White_Flame: SrPx: one thing we've hit with manual hash-consing/interning/flyweighting is that weak references tend to put a fair amount of load on GC cycles
2014-10-02T23:05:49Z White_Flame: but it's completely doable on top of a host language
2014-10-02T23:06:12Z White_Flame: especially if it's not a pure functional language, you're going to be wrapping that in policy or APIs anyway
2014-10-02T23:08:17Z lduros quit (Ping timeout: 244 seconds)
2014-10-02T23:09:00Z freaksken quit (Ping timeout: 272 seconds)
2014-10-02T23:09:45Z lisper29` left #lisp
2014-10-02T23:10:03Z normanrichards quit
2014-10-02T23:13:22Z svetlyak40wt joined #lisp
2014-10-02T23:13:45Z SrPx: White_Flame: "we" ?
2014-10-02T23:13:50Z SrPx: White_Flame: there is nothing existing, then...?
2014-10-02T23:14:19Z White_Flame: I doubt anything in popular use uses hash-consing
2014-10-02T23:14:26Z White_Flame: as a fundamental implementation feature
2014-10-02T23:14:57Z SrPx: I'm not sure how I could implement that on top of an existing language
2014-10-02T23:15:07Z SrPx: White_Flame: why so?
2014-10-02T23:15:09Z White_Flame: but it's not a hard problem to create your own (hash-cons a d) function
2014-10-02T23:15:11Z fortitude quit (Quit: leaving)
2014-10-02T23:15:31Z SrPx: I read a paper it costs only like 2x slowdown, and you gain a lot (fast maps, O(1) equality, etc)
2014-10-02T23:15:36Z White_Flame: SrPx: tremendous size & speed implications
2014-10-02T23:16:08Z White_Flame: and it gains you a lot only in certain symbolic processing that tends to do a lot of deep equality matching
2014-10-02T23:16:15Z SrPx: ... how? It is just like 2 or 3 additional operations per cons... and keeping a hash, which shouldn't be much bigger than your heap anyway
2014-10-02T23:16:16Z White_Flame: it's not a magic "go fast" feature
2014-10-02T23:16:43Z White_Flame: define "operations", because you're certainly not taking asm level
2014-10-02T23:17:02Z SrPx: I don't want it for "go fast", I just thought it would be a great tool to keep 2 programs synchronized between a client-server system
2014-10-02T23:17:19Z zeitue joined #lisp
2014-10-02T23:17:33Z White_Flame: a cons takes up 2 words.  Since each exists in a hash bucket list, plus the hasing tables themselves, you're in the range of doubling your heap
2014-10-02T23:17:42Z SrPx: the point is, I'm not sure how I could implement it without reinventing the whole memory management, which I would certainly do really poorly :(
2014-10-02T23:18:14Z SrPx: White_Flame: doubling is acceptable imo, I was actually looking for something up to 5x slower
2014-10-02T23:18:25Z svetlyak40wt quit (Ping timeout: 272 seconds)
2014-10-02T23:18:27Z SrPx: the problem is that coding it myself it would probably be 1000 slower or something
2014-10-02T23:18:49Z White_Flame: it's hard to know what the overal speed hit will be
2014-10-02T23:18:55Z White_Flame: it depends on your ratio of consing to comparison
2014-10-02T23:19:06Z White_Flame: s/comparison/deep comparison/
2014-10-02T23:19:27Z White_Flame: but surely writing (hash-cons a d) and maintaining your own stock hash tables isn't difficult
2014-10-02T23:19:43Z White_Flame: of course, you'd have to have versions of mapcar or whatever you use also consing with that function
2014-10-02T23:19:47Z SrPx: there is also automatic memoization ... even sub expressions such as (+ (f 1 3) (f 1 3)) are memorized ... is that all taken in account?
2014-10-02T23:19:58Z White_Flame: it's relatively tedious, but not difficult, and likely not a large task
2014-10-02T23:20:20Z SrPx: hmm perhaps
2014-10-02T23:20:27Z White_Flame: memoization is a separate problem
2014-10-02T23:20:47Z White_Flame: as that's function call caching, as opposed to allocation value caching
2014-10-02T23:22:04Z SrPx: I just mean, if you have memorization in a memory level, what stops you from including it in the graph reducer? it is just a matter of `compute(x) = if known_result(x) then return known_result(x) else ...`
2014-10-02T23:22:32Z White_Flame: you mean at compile-time?
2014-10-02T23:22:38Z SrPx: so that you never have to reduce 2 expr twice
2014-10-02T23:22:43Z SrPx: no, on the runtime
2014-10-02T23:23:18Z White_Flame: I don't quite see the link between hash consing and memoization
2014-10-02T23:23:30Z White_Flame: it would make comparing your parameter list faster in the memoization cache hit test
2014-10-02T23:23:42Z White_Flame: but doesn't perform any step of memoization itself that I see
2014-10-02T23:24:20Z SrPx: see, in a language with referential transparency, each expression has a unique reduction, such as `(+ 7 7) → 14`. When your computation boils down to finding the reduction of a given expression, then, in a hash-consed environment, you never have to reduce an expression twice, since you can just cache the result of each computation
2014-10-02T23:24:47Z hiyosi joined #lisp
2014-10-02T23:25:18Z White_Flame: that describes the work that memoization does
2014-10-02T23:25:30Z SrPx: yes exactly
2014-10-02T23:25:51Z White_Flame: yes, you could combine the two, but memoization still would have to be added to your function call semantics
2014-10-02T23:26:08Z White_Flame: and at this stage, you might as well write your own compiler
2014-10-02T23:26:34Z White_Flame: at least DSL->HLL
2014-10-02T23:26:39Z kirin` quit (Ping timeout: 272 seconds)
2014-10-02T23:27:11Z stardiviner joined #lisp
2014-10-02T23:27:13Z SrPx: I've done that, actually, but it turned out to be quite slow (obviously) in comparison to what we have around... stuff like `(sum (range 0 50000))` taking 3 secs to complete, where GHC takes 0.05ms lol
2014-10-02T23:27:23Z kirin` joined #lisp
2014-10-02T23:27:24Z SrPx: and I'm not really a C/compiler writer expect to know how to improve :(
2014-10-02T23:27:28Z SrPx: expert*
2014-10-02T23:27:34Z Bicyclidine: not sure why you'd introduce a question about referential transparency as "hash-consing", which is some ancient lispm thing
2014-10-02T23:27:37Z White_Flame: but if you call that twice, how long does the 2nd run take?
2014-10-02T23:27:38Z SrPx: that's why I thought someone more competent could've gotten better results
2014-10-02T23:27:44Z White_Flame: I presume haskell doesn't do hash-consing
2014-10-02T23:27:56Z SrPx: White_Flame: well it is instant
2014-10-02T23:28:04Z Bicyclidine: oh, i guess haskell people call it that
2014-10-02T23:28:08Z White_Flame: right, so there's your benefit of your hash consing + memoization experiment
2014-10-02T23:28:37Z White_Flame: takes longer to run, but much faster to re-run
2014-10-02T23:28:53Z White_Flame: hence my original comment about ratio between consing & comparison
2014-10-02T23:29:01Z paul0`` joined #lisp
2014-10-02T23:29:04Z SrPx: no, but the point is, I don't need it for the benefits of the memorization, the main motivation was that I could keep 2 computer memory synchronized easily (since I can compute diffs on the go)
2014-10-02T23:29:28Z hiyosi quit (Ping timeout: 244 seconds)
2014-10-02T23:29:28Z SrPx: but I'm not sure if paying 100x slowdown is worth not having to have the work of synchronizing things using sockets etc manually
2014-10-02T23:29:31Z SrPx: in a game, that is
2014-10-02T23:29:54Z SrPx: well
2014-10-02T23:29:59Z White_Flame: um, what about this absolves you from using sockets?
2014-10-02T23:30:04Z SrPx: I don't know. never mind
2014-10-02T23:30:47Z SrPx: White_Flame: if I open 2 applications in different computers, they are automatically synchronized at memory level (I included that on the runtime, together with the diff on the go)
2014-10-02T23:30:58Z SrPx: so I don't have to code sockets when creating a new game, for example
2014-10-02T23:31:22Z White_Flame: in what language?
2014-10-02T23:32:09Z SrPx: ...? in the runtime I made, it is just scheme or something like that
2014-10-02T23:32:13Z SrPx: there are just cons and numbers
2014-10-02T23:32:26Z paul0` quit (Ping timeout: 272 seconds)
2014-10-02T23:32:48Z SrPx: but games are very numerically heavy by nature, so such a slowdown makes it unpractical anyway
2014-10-02T23:33:36Z SrPx: I'm just not sure what should I do, if I keep trying to improve the performance of this thing by learning assembly or something... if I try to plug it on top of an existing functional language... or if I just give up of not having to write sockets on my future games
2014-10-02T23:33:45Z White_Flame: ok, so you have a custom lisp family implementation
2014-10-02T23:34:10Z White_Flame: if you were to start using another implementation that had hash-consing built-in, you wouldn't have the memory sync, so I don't understand where the original question fits in
2014-10-02T23:34:44Z White_Flame: game time & state synchronization is hard, and full-memory sync doesn't seem to be a viable approach
2014-10-02T23:35:00Z Bicyclidine: what kind of computer is this running on
2014-10-02T23:35:47Z rme quit (Quit: rme)
2014-10-02T23:35:47Z rme quit (Quit: rme)
2014-10-02T23:37:00Z SrPx: White_Flame: actually I would, I could just fork the compiler. it is really simple to do
2014-10-02T23:37:15Z SrPx: Bicyclidine: on my macbook, why?
2014-10-02T23:37:25Z SrPx: White_Flame: but yea, I see your point
2014-10-02T23:37:38Z Bicyclidine: i'm having a hard time reconciling full memory synchronization with not knowing assembly on a modern computer
2014-10-02T23:38:00Z SrPx: Bicyclidine: maybe that is why it is not working, lol.
2014-10-02T23:38:06Z Bicyclidine: like do you just... copy over whole pages... i'm confused
2014-10-02T23:38:18Z White_Flame: how big is your memory footprint, and how often do you send it?
2014-10-02T23:38:35Z Bicyclidine: and how do you send memory between computers if not through a network protocol like sockets
2014-10-02T23:38:46Z stardiviner quit (Ping timeout: 272 seconds)
2014-10-02T23:38:59Z Bicyclidine: and what does this have to do with referential transparency, i don't think you can just copy a haskell process's memory elsewhere and expect it to work
2014-10-02T23:39:43Z SrPx: Bicyclidine: the point is, when the runtime is hash-consed as a whole, the memory, 1. becomes very compact, so it eases the transfer load. 2. you always know when something new is appended to the memory just in time. so you don't have to ever calculate the diff. if your memory has a length of 100kb at a second, and 101kb at the next second, you know that extra kb is exactly what you have to send
2014-10-02T23:40:12Z White_Flame: how does garbage collection tie into this, and do you already have weak references?
2014-10-02T23:40:12Z SrPx: Bicyclidine: ...? I mean, I use sockets on the runtime implementation, then I'm free from using it when I code an application using it
2014-10-02T23:40:30Z SrPx: White_Flame: I don't even have a GC, I worked on this on a weekend :(
2014-10-02T23:40:38Z Bicyclidine: this just all sounds like something that would happen in the 70s, it's crazy
2014-10-02T23:40:40Z White_Flame: hash consing will require weak referencs
2014-10-02T23:40:49Z SrPx: what do you mean?
2014-10-02T23:40:51Z Bicyclidine: i didn't know anybody wrote programs like that any more
2014-10-02T23:40:59Z SrPx: Bicyclidine: what do you mean too?
2014-10-02T23:41:33Z Bicyclidine: okay so here's one thing, you do understand that if you're relying on "appending" memory you can't actually reclaim memory you've used, so you can't have a GC at all, unless you complicate the diffs
2014-10-02T23:42:09Z Bicyclidine: this is just, it doesn't seem like a stable way to do anything.
2014-10-02T23:42:16Z oleo__ is now known as oleo
2014-10-02T23:42:39Z SrPx: Bicyclidine: I'm not just appending, there is a stack of available memory cells. when I clean a cell, I add it to that stack. Which is the sketch of the implementation of the GC which I didn't do yes. And yes, I have no idea how practical is that, probably garbage
2014-10-02T23:43:13Z White_Flame: if all your values & cells are equal-sized, then it's reasonable
2014-10-02T23:43:29Z urandom__ quit (Quit: Konversation terminated!)
2014-10-02T23:43:39Z White_Flame: however, delta scanning has to be a lot more intelligent (or brute force sweep the whole heap) in order to detect reuse of cells
2014-10-02T23:44:04Z SrPx: that is a point too, White_Flame . the fact all cells are equal sized mean I don't have arrays nor unboxed values. I guess that automatically makes my runtime garbage for any kind of numerical computation, right? since I maximize the cache miss
2014-10-02T23:44:37Z White_Flame: it all depends on how you lay it out
2014-10-02T23:44:49Z White_Flame: but again, delta calculation is not simple when there's a GC involved
2014-10-02T23:44:56Z Bicyclidine: maybe i'm naïve here, but tying yourself to a specific model of memory, allocation, gc, etc. just so you can avoid using sockets sounds nuts to me
2014-10-02T23:45:07Z White_Flame: the most naive way would be to put a generation counter or dirty bit field on each slot
2014-10-02T23:45:36Z White_Flame: or, if you're immutable, each allocation would add itself to a dirty list
2014-10-02T23:45:58Z SrPx: Bicyclidine: it is not just that, to be honest, there are many, many things that such a language would do to improve my productivity
2014-10-02T23:46:06Z SrPx: Bicyclidine: if it existed, that is
2014-10-02T23:46:35Z SrPx: White_Flame: I'm not sure what you are talking about, delta calculation?
2014-10-02T23:46:38Z White_Flame: programmer productivity is orthogonal (and at times antithetical) to game-style runtime efficiency
2014-10-02T23:46:43Z Bicyclidine: the deltas you have to send.
2014-10-02T23:46:49Z White_Flame: SrPx: calculating what changed since you last synced
2014-10-02T23:47:14Z Bicyclidine left #lisp
2014-10-02T23:47:27Z SrPx: the deltas I have to send are pretty easy, as I said, whenever I `cons` a cell that isn't on the hash, I append it to the delta, and whenever I clean a cell, I append it to the delta-removeds
2014-10-02T23:47:35Z SrPx: I don't get the prob ?
2014-10-02T23:47:51Z White_Flame: okay, that's not what you described before
2014-10-02T23:48:06Z SrPx: my bad!
2014-10-02T23:48:19Z SrPx: I just gave an example, though
2014-10-02T23:49:02Z White_Flame: so since you're developing at the level of your own runtime, I don't see what the problem is with adding hash-consing yourself
2014-10-02T23:49:04Z SrPx: how expensive would it be to hire someone (a freelancer, I don't know) to take my code and optimize it as much as he can? any idea?
2014-10-02T23:49:23Z SrPx: White_Flame: none, except my stuff is slow... that is why I wanted something someone else did :(
2014-10-02T23:49:24Z White_Flame: if you want quality optimization, you're going to be spending real money
2014-10-02T23:49:34Z SrPx: hm...
2014-10-02T23:49:46Z SrPx: :(
2014-10-02T23:49:47Z White_Flame: and your design requirements themselves might be infeasible to get the game performance you desire
2014-10-02T23:49:55Z SrPx: fair enough
2014-10-02T23:50:46Z SrPx: at least some guideline ? I'm doing this without any sort of guidance. maybe a tutorial explaining how a very good CL implementation works would give some insight. I don't know
2014-10-02T23:50:54Z SrPx: damn I really wish someone did that before
2014-10-02T23:50:55Z White_Flame: in writing games, you need to have a very holistic view of where time is spent.  You can't try to black-box away things under runtime-heavy systems, unless you're good at writing optimizing compilers and such
2014-10-02T23:51:26Z Vutral: well
2014-10-02T23:51:30Z Longlius joined #lisp
2014-10-02T23:51:35Z Vutral: you can do elegant preprocessing/metaprogramming
2014-10-02T23:51:41Z Vutral: code generation etc
2014-10-02T23:51:48Z White_Flame: right, which I tend to consider compiler tech
2014-10-02T23:51:57Z White_Flame: if you can transform your desires into optimized high level code
2014-10-02T23:51:58Z Vutral: experimented with such kind much
2014-10-02T23:52:07Z Vutral: yes exactly
2014-10-02T23:52:15Z Vutral: many people tell me its too complex or too much work
2014-10-02T23:52:19Z Vutral: but the results are very nice
2014-10-02T23:52:31Z White_Flame: yes, we've heavily used codegen since the 90s
2014-10-02T23:52:57Z Vutral: sometimes i have code which optimizes the source level
2014-10-02T23:53:02Z Vutral: using runtime data
2014-10-02T23:53:22Z Vutral: and the instrumentation stuff can be removed for a release
2014-10-02T23:53:25Z innertracks joined #lisp
2014-10-02T23:53:37Z Vutral: stock markets seem to crash
2014-10-02T23:53:38Z SrPx: okay I lost it
2014-10-02T23:53:39Z White_Flame: yep, good ol profiling & heuristics
2014-10-02T23:54:03Z SrPx: what is your suggestion, I don't get it
2014-10-02T23:54:07Z White_Flame: which is nice in languages like Lisp since you can recompile function versions at runtime
2014-10-02T23:54:10Z Vutral: anyway even profiling and heuristics seem to be something many young coders dont know
2014-10-02T23:54:33Z White_Flame: SrPx: no real suggestion.  Play with your tech, optimize it to your game needs, not to some generalized ideal
2014-10-02T23:55:13Z White_Flame: Measure to see how much hash-consing reduces bandwidth vs adds CPU load
2014-10-02T23:56:25Z SrPx: I see
2014-10-02T23:56:42Z SrPx: so you are really certain that there is not at all anything existing I can use?
2014-10-02T23:57:03Z |3b|: hiding networking behind some sort of shared memory space seems like it would limit types of games quite a bit
2014-10-02T23:57:22Z SrPx: also, if I do decide to continue it myself, do you think I can get better results by implementing on top of an existing language, as you said? White_Flame . I guess that could be great, I just don't know how it could work
2014-10-02T23:57:28Z |3b|: (in addition to the usual problem that networking abstractions leak)
2014-10-02T23:57:43Z White_Flame: You're already implementing it on top of C++ or something, presumedly
2014-10-02T23:57:55Z SrPx: |3b|: why so? Other than the fact I'm alone on that, I don't see an inherent problem on the idea, do you?
2014-10-02T23:58:00Z wizzo quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
2014-10-02T23:58:19Z |3b|: well, first question is can players make simultaneous moves? if so, how do you reconcile conflicts?
2014-10-02T23:58:27Z White_Flame: SrPx: the advantages of hash-consing are only in very particular computation styles.
2014-10-02T23:58:33Z SrPx: |3b|: I was thinking something among the lines of "views", there clients have a limited view of your memory ("symbols of interest")
2014-10-02T23:58:52Z karswell` quit (Read error: Connection reset by peer)
2014-10-02T23:58:57Z |3b|: then there is the question of bandwidth
2014-10-02T23:59:06Z pillton: |3b|: I liked your videos in your latest blog post.
2014-10-02T23:59:12Z White_Flame: whoa, you don't yet know what information you're going to be sharing and how?
2014-10-02T23:59:38Z White_Flame: I was under the impression that you were sending deltas and maintaining shared game state already
2014-10-02T23:59:52Z |3b|: most realtime games put a bunch of effort into domain-specific data compression, so just "copy any random data that changed" won't compete well