2014-12-28T00:00:09Z oleo quit (Quit: Verlassend)
2014-12-28T00:00:30Z dim: anyway, gn!
2014-12-28T00:02:51Z zacharias quit (Ping timeout: 272 seconds)
2014-12-28T00:04:43Z sindikat quit (Quit: Page closed)
2014-12-28T00:06:03Z logand: html/css/js might be awful but the real problem is keeping the ui up-to-date, this is a general problem with any gui toolkit, handling events and updating everything properly;  the nice thing about the plain html ui is that one can gc old ui and draw a new screen, then the "keep up-to-date" problem is gone
2014-12-28T00:06:33Z stassats: gui toolkits have such a problem?
2014-12-28T00:06:39Z logand: every
2014-12-28T00:06:50Z stassats: never seen it
2014-12-28T00:07:10Z jumblerg quit (Quit: My Mac has gone to sleep. ZZZzzz…)
2014-12-28T00:07:11Z logand: you need to write code to handle a button event
2014-12-28T00:07:37Z stassats: ok, you usually do
2014-12-28T00:07:38Z logand: whatever that event is meant to do needs to be reflected in the ui
2014-12-28T00:07:39Z _m___ joined #lisp
2014-12-28T00:08:06Z logand: so you need to write code to update the state of the ui
2014-12-28T00:08:38Z logand: and this update code can be rather complex
2014-12-28T00:09:00Z stassats: it can be simple, what's the point?
2014-12-28T00:09:04Z Shinmera: You can have the awful model HTML has in any toolkit you want by just rebuilding the entire UI to something else every time you click a thing.
2014-12-28T00:09:34Z Shinmera: But usually toolkits give you the choice for less stupid ways of managing things, which is a good thing.
2014-12-28T00:09:49Z logand: it is much simpler if you can afford to "rebuild the entire ui"
2014-12-28T00:10:15Z stassats: this is the strangest argument for html
2014-12-28T00:10:17Z logand: i.e. if you make it fast enough that users dont get annoyued
2014-12-28T00:10:25Z Shinmera: you can do that in any toolkit
2014-12-28T00:10:30Z Shinmera: it won't be any less retarded
2014-12-28T00:10:45Z Zhivago: Shin: Clicking doen't require a reload.
2014-12-28T00:10:49Z logand: it is not inherently html thing, but html kind of brings it naturally
2014-12-28T00:11:00Z oleo joined #lisp
2014-12-28T00:11:10Z Shinmera: Zhivago: he is talking about "plain html ui"
2014-12-28T00:11:12Z stassats: Shinmera: people expect things to be slow and clunky in web browser, so you can get away with such trickery
2014-12-28T00:11:13Z logand: iirc smalltalk switched from mvc to something similar
2014-12-28T00:11:27Z Shinmera: Zhivago: so yes, a click is a reload.
2014-12-28T00:12:31Z logand: it doesnt have to be slow
2014-12-28T00:12:46Z logand: web browsers are very fast at redrawing ui
2014-12-28T00:13:25Z Shinmera: My experience tells me otherwise
2014-12-28T00:13:32Z Shinmera: but whatever, believe what you want
2014-12-28T00:13:38Z Shinmera: I'm off to sleep.
2014-12-28T00:13:43Z Shinmera quit (Quit: しつれいしなければならないんです。)
2014-12-28T00:14:09Z zajn quit (Remote host closed the connection)
2014-12-28T00:14:15Z stassats: the whole premise seems strange to me
2014-12-28T00:14:15Z antonv quit (Ping timeout: 244 seconds)
2014-12-28T00:14:28Z stassats: why do you have to redraw everything, even in web browsers
2014-12-28T00:14:54Z Zhivago: Not if you're stuck in the 90s, I guess.
2014-12-28T00:16:13Z logand: because it is much easier to draw the current state than to bring the old state up-to-date
2014-12-28T00:16:18Z Dynasty quit (Quit: bye)
2014-12-28T00:16:22Z wbooze joined #lisp
2014-12-28T00:16:50Z Bicyclidine quit (Ping timeout: 244 seconds)
2014-12-28T00:17:16Z stassats quit (Remote host closed the connection)
2014-12-28T00:17:20Z Bicyclidine joined #lisp
2014-12-28T00:17:30Z stassats joined #lisp
2014-12-28T00:17:55Z logand: there is the saying: there are two hard things in cs; 1) naming things; 2) cache invalidation; 3) off by one errors
2014-12-28T00:18:01Z stassats: logand: easier for what?
2014-12-28T00:18:09Z Bicyclidine quit (Client Quit)
2014-12-28T00:18:19Z Bicyclidine joined #lisp
2014-12-28T00:18:19Z logand: and the "keep ui up-to-date" problem is the ad 2)
2014-12-28T00:18:43Z stassats: never encountered such a problem and never seen it mentioned, oh well, i most not do enough user interfaces
2014-12-28T00:18:58Z logand: if you have ui, then you need to write code to 1) draw it; 2) to keep it up-to-date
2014-12-28T00:19:08Z logand: the second point gets really messy
2014-12-28T00:19:36Z stassats: not the way i'm used to doing it
2014-12-28T00:19:59Z logand: well it's too abstract without an example
2014-12-28T00:20:19Z stassats: i have access to modern UI frameworks, including html/js
2014-12-28T00:20:32Z stassats: there's never such a problem
2014-12-28T00:20:44Z logand: i havent seen a nice ui framework yet
2014-12-28T00:21:20Z stassats: well, the way you're describing how you want to use it, no wonder
2014-12-28T00:21:41Z KrazyCod3r joined #lisp
2014-12-28T00:22:28Z KrazyCod3r left #lisp
2014-12-28T00:23:09Z logand: i want to write a "simple" lisp program and not to worry about updating some variables in a modern ui framework
2014-12-28T00:23:19Z innertracks quit (Quit: innertracks)
2014-12-28T00:23:58Z logand: these framework usually mean, that some "state variable" is duplicated somewhere in the framework and needs to be updated appropriately
2014-12-28T00:25:16Z attila_lendvai: projectured has a really nice proof of concept about how to write gui's. it's basically a generalized REPL, and it's lazy and incremental. for now the examples are all about document editing, but the concept is general.
2014-12-28T00:26:02Z attila_lendvai: http://projectured.org/ https://www.youtube.com/user/projectured
2014-12-28T00:26:06Z stassats: logand: you updated based on some external or internal factor
2014-12-28T00:26:21Z stassats: redrawing everything on each action is a sure way to kill performance
2014-12-28T00:30:35Z munksgaard quit (Ping timeout: 256 seconds)
2014-12-28T00:31:28Z kcj joined #lisp
2014-12-28T00:33:41Z hiroakip quit (Ping timeout: 244 seconds)
2014-12-28T00:34:09Z pjb: I concur.
2014-12-28T00:34:19Z CrazyM4n quit (Remote host closed the connection)
2014-12-28T00:35:58Z urandom_1 quit (Quit: Konversation terminated!)
2014-12-28T00:41:28Z Hexstream: logand: With dataflow (some hipsters call it "functional reactive programming" I think), "draw it" and "keep it up-to-date" is basically the same thing.
2014-12-28T00:47:39Z logand: yeah, but the point is, if you can afford to redraw the ui without killing performance; you can avoid all that complexity of dataflow engine (like cells)
2014-12-28T00:49:01Z logand: because you dont need to propagate any changes; you simply discard old ui and draw new one
2014-12-28T00:49:26Z nyef: ... Okay, just watched one of the projectured videos. Something about literate programming with testing.
2014-12-28T00:50:06Z nyef: And it's kindof interesting, but at the same time it gives a definite impression of "toy problem".
2014-12-28T00:51:06Z Zhivago: Angular takes an intetesting mipoint.
2014-12-28T00:51:42Z attila_lendvai: nyef: it's a general gui framework that uses functional reactive programming to optimize a general pipeline of transformations from the document to the display device and from the input devices towards the document. the nice thing is how well the otherwise small transformations combine without the complexity of laziness leaking into them
2014-12-28T00:52:33Z stassats: that's buzzwordy enough
2014-12-28T00:54:13Z zygentoma quit (Quit: KVIrc 4.2.0 Equilibrium http://www.kvirc.net/)
2014-12-28T00:54:27Z Hexstream: Oh, I thought only the clojure and haskell guys called it "functional reactive programming" instead of just "dataflow". (Seems like I was wrong.)
2014-12-28T00:55:12Z stassats: i'm happy with dysfunctional apathetic programming, thank you
2014-12-28T00:55:22Z Zhivago: Well, dataflow is usually procedural.
2014-12-28T00:57:52Z nisscrooge quit (Changing host)
2014-12-28T00:57:52Z nisscrooge joined #lisp
2014-12-28T00:58:10Z nisscrooge is now known as nisstyre
2014-12-28T00:59:08Z linux_dream joined #lisp
2014-12-28T00:59:23Z logand: my thoughs are somewhere like "synchronous reactive programming" where the clock is defined by user events
2014-12-28T00:59:49Z admg quit (Quit: Bye)
2014-12-28T01:01:26Z logand: attila_lendvai: how do you compute the updates?  hu.dwim.computed-class?
2014-12-28T01:03:39Z pjb quit (Ping timeout: 244 seconds)
2014-12-28T01:04:09Z logand: Hexstream: yeah; but you need a complicated code to do this "is basically the same thing";  but if one things about the problem differently, suddenly there is no code needed for that
2014-12-28T01:04:14Z attila_lendvai: logand: yes (althought it's only levente meszaros working on projectured. we used to work together at intentsoft on this problem a few years ago, but these days I only brainstorm with him a little every once in a while)
2014-12-28T01:04:39Z kyl__ is now known as kyl___
2014-12-28T01:08:47Z Hexstream: logand: I don't mind "complicated code" as much when it's just part of a platform shared by applications instead of in the applications themselves, especially if this code is behind proper interfaces so that it can be refactored without touching the applications and "business logic" themselves...
2014-12-28T01:09:12Z Xach left #lisp
2014-12-28T01:11:25Z logand: Hexstream: i dont like "complicated code" in general, always looking for simplicity, so this is kind of important point :-)
2014-12-28T01:13:06Z gambyte joined #lisp
2014-12-28T01:15:19Z logand: attila_lendvai: still in kazachstan?
2014-12-28T01:15:49Z attila_lendvai: not currently
2014-12-28T01:15:52Z pjb joined #lisp
2014-12-28T01:16:18Z gambyte quit (Quit: Leaving)
2014-12-28T01:16:41Z Hexstream: logand: My main point is that counting platform code separately from application code makes for better accounting, while conflating the two to say that a technique requires more code and makes for more complicated code is not so great...
2014-12-28T01:18:10Z logand: depends what do you have to maintain;  every dependency sucks; esp a complex dependency
2014-12-28T01:19:02Z logand: you can count platform code separately, but if it changes, you need to updated your app
2014-12-28T01:19:17Z Bicyclidine quit (Ping timeout: 240 seconds)
2014-12-28T01:19:19Z Hexstream: logand: I don't necessarily mind dependencies that much, as long as they're explicit and warranted.
2014-12-28T01:19:31Z stassats: how are web browsers any less complicated?
2014-12-28T01:19:59Z Hexstream: logand: Not if you have the aforementioned well-defined interfaces. You can aggressively refactor the platform while changing no or very little application code.
2014-12-28T01:20:12Z logand: they are not, but there are certain things that one can pretty much count on
2014-12-28T01:20:23Z stassats: Hexstream: just like the backqoute?
2014-12-28T01:20:38Z Zhivago: Someone else pays for the browser.
2014-12-28T01:20:46Z logand: haha good point
2014-12-28T01:21:45Z Hexstream: stassats: SBCL continually makes tons and tons of major changes to the platform that I never care about insofar as they don't break my code. I think it says something about the backquote change that suddenly tons and tons of my code is broken.
2014-12-28T01:22:08Z stassats: or about your code
2014-12-28T01:22:31Z Hexstream: Going from cons-walkability to cons-inwalkability is a major interface change.
2014-12-28T01:22:31Z stassats: well, maybe you were happy with badly pretty printed backqoutes
2014-12-28T01:22:42Z Bicyclidine joined #lisp
2014-12-28T01:23:43Z Hexstream: stassats: I didn't mind them because they were advanced corner cases that I never actually reached in practice, whereas cons-walkability for me is a basic fundamental thing that even my simplest code (maybe you'd say my most simplistic code) uses liberally.
2014-12-28T01:23:46Z stassats: with your own ` reader-macro and pprint-dispatch, you can roll out portable backqoute readers and printers
2014-12-28T01:23:47Z logand: "explicit and warranted" dependencies is very optimistic
2014-12-28T01:24:31Z fantazo quit (Quit: Verlassend)
2014-12-28T01:24:46Z Hexstream: logand: I don't know what the fuck you're doing if most of your dependencies are not explicit and warranted... Well, NIH means I have finer granularity for that I guess.
2014-12-28T01:25:50Z Hexstream: stassats: Yes, but then I need to tell everyone that my libraries don't work with CL backquote because SBCL broke it and so they must use some particular backquote implementation that I know how to walk.
2014-12-28T01:26:00Z gambyte joined #lisp
2014-12-28T01:26:12Z stassats: you keep telling that SBCL broke it
2014-12-28T01:26:22Z Hexstream: I mean, even if "knowing how to walk" that particular implementation is just as easy as "recurse into conses as I always did".
2014-12-28T01:26:30Z Hexstream: stassats: It keeps being true.
2014-12-28T01:27:01Z stassats: maybe that's why nobody considers your complaints seriously
2014-12-28T01:27:03Z Hexstream: stassats: I don't like to devolve into euphemisms.
2014-12-28T01:27:16Z attila_lendvai: using cons cells to represent program code was a bad enough idea, and you're sticking to it with teeth and nails...
2014-12-28T01:27:18Z hiroakip joined #lisp
2014-12-28T01:27:19Z stassats: pretty much all the consensus is that there's no problem in SBCL
2014-12-28T01:27:36Z logand: Hexstream: ok, i probably misunderstood what do you mean by "explicit and warranted"; but for me is important "stable and robust" or something in that sense
2014-12-28T01:27:39Z Hexstream: stassats: I don't think anyone would take me any more seriously if I used euphemisms instead of just saying that it's broken.
2014-12-28T01:28:06Z stassats: it just becomes Hexstream-broken, not broken broken
2014-12-28T01:28:15Z attila_lendvai: broken is an implicit value judgment
2014-12-28T01:28:17Z stassats: and i checked /whoami, it's not Hexstream, so i care less
2014-12-28T01:28:37Z Hexstream: attila_lendvai: In my case it's quite explicit...
2014-12-28T01:29:13Z attila_lendvai has just updated the sbcl integration of hu.dwim.reader to deal with this in a backwards compatible way
2014-12-28T01:29:37Z stassats: for example, (lambda (b) (declare ((eql -7) b) (optimize debug)) (lambda (x) (logior x b))), now, who will say that this is not broken?
2014-12-28T01:29:42Z Hexstream: stassats: I'm a bit more comfortable about saying that it's broken now that there's a clear consensus in the community that it "isn't" and that the issue is a bit more familiar and that the positions and who hold them are known.
2014-12-28T01:29:58Z stassats: it violates the standard, not just "it would be nice"
2014-12-28T01:30:28Z Hexstream: stassats: I have yet to see a convincing explanation that it "violates the standard".
2014-12-28T01:30:33Z logand: attila_lendvai: if you make it to berlin, it would be nice to catch up :-)
2014-12-28T01:31:04Z stassats: Hexstream: guilty until proven innocent, get me a line where it says that it is standard
2014-12-28T01:32:52Z Hexstream: stassats: I'm not saying that the standard clearly says that cons-walking is an acceptable technique (though that has been strongly established in practice for decades), I'm saying that nothing says that it's acceptable to hide user-supplied code inside implementation-defined objects.
2014-12-28T01:33:47Z stassats: does anything say it is unacceptable?
2014-12-28T01:34:03Z Bicyclidine: this historical consensus based on nothing and nobody is pretty awesome.
2014-12-28T01:34:27Z stassats: how can i start fixing something if it isn't demonstrated to be a bug?
2014-12-28T01:34:51Z stassats: because the structure thing fixed a bug, printing backqoutes
2014-12-28T01:35:27Z Bicyclidine: macros are defined as taking and returning forms. forms are basically anything. not much of a jump to macros being allowed to take and return whatever they please.
2014-12-28T01:35:47Z stassats: i can't revert it, and i really tried fixing it some time ago to print things, and i came to the same conclusion, only using structures, the same as Douglas did
2014-12-28T01:36:00Z eudoxia joined #lisp
2014-12-28T01:36:55Z stassats: '```(,',',plet/fast ,',kernel ,@body) => ``,',',PLET/FAST
2014-12-28T01:37:00Z stassats: that's what the old SBCL produced
2014-12-28T01:37:04Z stassats: do you want that?
2014-12-28T01:37:44Z Bicyclidine: that's some scary code
2014-12-28T01:38:10Z Hexstream: stassats: Sure, I recognize that making an implementation of backquote that is both correct and simple may well be impossible. But to quote myself elsewhere:
2014-12-28T01:38:18Z Hexstream: "Breaking backquote to simplify implementation is like amputating limbs so we can use a simpler heart that doesn't need to pump blood to extremities."
2014-12-28T01:38:58Z eudoxia: hahaha
2014-12-28T01:38:58Z Bicyclidine: that analogy would work great if you were talking to anybody who thought it was broken, i guess.
2014-12-28T01:39:04Z stassats: Hexstream: so, yeah, using quotes like that doesn't bring your point across
2014-12-28T01:40:47Z logand quit (Ping timeout: 322 seconds)
2014-12-28T01:41:16Z Hexstream: I think it's appropriate given that the new backquote implementation is simpler but makes code that I need to walk unreachable in a way that is fairly incapacitating.
2014-12-28T01:41:18Z nell quit (Quit: WeeChat 1.1-rc1)
2014-12-28T01:43:18Z stassats: well, as i said, as i side benefit it catches programs making unportable assumptions
2014-12-28T01:43:23Z Hexstream: While the old backquote may have produced incorrect results for things like '```(,',',plet/fast ,',kernel ,@body) which I never write (seriously, are there more than ten Common Lispers who need to write code like this?)
2014-12-28T01:43:23Z nikki93 quit (Remote host closed the connection)
2014-12-28T01:43:53Z Bicyclidine: that's kind of a humorous thing to say given the aforementioned only you think this is broken aspect.
2014-12-28T01:44:17Z stassats: it's a test case
2014-12-28T01:44:32Z stassats:  '``(,',plet/fast ',kernel ,@body) => ``(,',PLET/FAST ,,'`',KERNEL ,@BODY)
2014-12-28T01:44:43Z Bicyclidine: i'd do plambda differently, personally. like have (plambda 3 (values p:0 p:2)) => (lambda (p:0 p:1 p:2) (declare (ignorable p:0 p:1 p:2)) (values p:0 p:2)), say. (plambda (3) ...) would give it a &rest. i'm sure this is irrelevant.
2014-12-28T01:45:17Z Jameser` quit (Ping timeout: 252 seconds)
2014-12-28T01:45:44Z stassats: just define lambda-parameters-limit of p: symbols
2014-12-28T01:46:10Z Hexstream: Going to do the dishes...
2014-12-28T01:46:55Z Bicyclidine: Or use p:0 instead of :0 and therefore allow symbol macroletting the things.
2014-12-28T01:47:07Z Bicyclidine: i mean there are a lot of routes here not relying on really dumb code walker.s
2014-12-28T01:47:10Z Karl_Dscc joined #lisp
2014-12-28T01:50:36Z stassats: is it me or using numbers to denote variables is not very clear?
2014-12-28T01:50:38Z hiyosi joined #lisp
2014-12-28T01:50:58Z Bicyclidine: it's not. it's for really small functions or whatever. not my thing.
2014-12-28T01:51:19Z nyef: Coming from the perspective of PostgreSQL prepared statements? It can be as clear as mud at times.
2014-12-28T01:51:24Z Bicyclidine: *using numbers to denote variables is not clear. plambda is for really small functions
2014-12-28T01:52:00Z stassats: that must save so much typing
2014-12-28T01:52:19Z gambyte quit (Quit: Leaving)
2014-12-28T01:53:16Z gambyte joined #lisp
2014-12-28T01:53:21Z nyef: Especially if you customize your editing environment so that you have an easy keystroke to create a lambda, putting the cursor within the arglist.
2014-12-28T01:53:49Z Bicyclidine: stassats should upgrade that apl reader macro suite to compete
2014-12-28T01:55:05Z stassats proceeds to read http://c2.com/cgi/wiki?BadVariableNames
2014-12-28T01:55:13Z stassats: some amusing choices there
2014-12-28T01:57:35Z stassats: c2.com/cgi/wiki?UncleBobsNamingConventions in particular
2014-12-28T01:59:15Z gambyte quit (Quit: Leaving)
2014-12-28T01:59:31Z gambyte joined #lisp
2014-12-28T01:59:33Z Bicyclidine: more like prose, heh.
2014-12-28T01:59:44Z stassats: should fit right into LOOP
2014-12-28T02:01:05Z vaporatorius quit (Remote host closed the connection)
2014-12-28T02:01:49Z gambyte quit (Client Quit)
2014-12-28T02:02:12Z gambyte joined #lisp
2014-12-28T02:02:33Z hiroakip quit (Ping timeout: 244 seconds)
2014-12-28T02:03:27Z eudoxia quit (Quit: Leaving)
2014-12-28T02:03:45Z gambyte quit (Client Quit)
2014-12-28T02:03:59Z gambyte joined #lisp
2014-12-28T02:06:29Z Quadrescence joined #lisp
2014-12-28T02:08:01Z gambyte quit (Client Quit)
2014-12-28T02:08:17Z gambyte joined #lisp
2014-12-28T02:10:11Z theseb quit (Quit: Leaving)
2014-12-28T02:10:40Z innertracks joined #lisp
2014-12-28T02:14:12Z gambyte quit (Quit: Leaving)
2014-12-28T02:14:32Z gambyte joined #lisp
2014-12-28T02:17:46Z gambyte quit (Client Quit)
2014-12-28T02:18:04Z gambyte joined #lisp
2014-12-28T02:18:13Z Hexstream: Bicyclidine: I just happened to be particularly banking on the cons-walking strategy since it allowed for very simple implementations of macros that incidentally didn't expand any code such that the macroexpansions were much more high-level and clearer.
2014-12-28T02:19:24Z gambyte quit (Client Quit)
2014-12-28T02:19:53Z nyef: ... Wait, what's the problem with doing the macroexpansion?
2014-12-28T02:20:18Z Hexstream: nyef: All the high-level code turns into lower-level code?...
2014-12-28T02:20:28Z Hexstream: When you macroexpand-1.
2014-12-28T02:21:14Z Hexstream: I really love it when doing macroexpand-1 only expands the macro call I want to expand, not every macro invocation therein recursively.
2014-12-28T02:21:29Z soggybread: Hexstream: http://paste.lisp.org/display/144937 ?
2014-12-28T02:22:21Z stassats: closure only has 5 parameters?
2014-12-28T02:22:24Z Bicyclidine: Hexstream: i could do the thing i said in like a few lines, though. and the macroexpansion would just be a lambda. i don't understand.
2014-12-28T02:22:26Z stassats: clojure
2014-12-28T02:22:26Z Hexstream: soggybread: What about &rest?
2014-12-28T02:22:31Z soggybread: [almost] :)
2014-12-28T02:22:47Z Hexstream: soggybread: It's a bit like the penny gap...
2014-12-28T02:24:05Z Hexstream: Bicyclidine: It also just happens that that kind of cons-walking is used by newbies in particular, except that as someone more experienced I knew the limitations of the technique and how to avoid them, and I also read the relevant parts of the CLHS multiple times. The SBCL backquote change is... clisp-like.
2014-12-28T02:24:13Z zophy quit (Quit: Leaving)
2014-12-28T02:24:45Z Hexstream: So I guess that explains why I'm the only one complaining.
2014-12-28T02:25:28Z nyef: Yes, you're just about the only one affected by a change to a behavior that everyone else stayed far, far away from relying on.
2014-12-28T02:25:33Z Bicyclidine: not explicitly illegal, and now used by newbies in particular (though i kind of doubt this). this isn't a very convincing case, y'know?
2014-12-28T02:25:34Z stassats: newbies do codewalking?
2014-12-28T02:25:45Z zRecursive joined #lisp
2014-12-28T02:25:56Z nyef: stassats: They might if they read PG and/or LoL?
2014-12-28T02:26:47Z nyef: My attitude is "if you feel the need to do codewalking you're either writing a compiler or you're doing something wrong."
2014-12-28T02:27:27Z stassats: just ir1-convert it and then walk it
2014-12-28T02:27:30Z nyef: (I still don't know what SB-WALKER is for, but that's because it seems to be used by PCL, and I don't understand PCL at all.)
2014-12-28T02:27:34Z Bicyclidine: well, i don't really agree with that, but in this case it seems like something wrong, fo sho
2014-12-28T02:27:45Z Hexstream: Bicyclidine: I mean that newbies may use this technique because they don't know better and haven't even read the CLHS yet, whereas I found more informed uses for the technique and saw some advantages that others didn't see and appreciate, so my complaints appear more ignorant than they really are...
2014-12-28T02:27:48Z stassats: nyef: presumably for finding call-next-method
2014-12-28T02:27:58Z nyef: ... But why is that NECESSARY?
2014-12-28T02:28:13Z stassats: to save or not to save the arguments or something
2014-12-28T02:28:26Z Bicyclidine: Hexstream: no, no, i'm sure you understand the limitations, but then when anybody brings them up you kind of ignore that so it's pretty confusing.
2014-12-28T02:28:33Z stassats: why not use IR?
2014-12-28T02:28:50Z Bicyclidine: sbcl's expansion of defmethod is pretty scary.
2014-12-28T02:28:51Z stassats: because it is _P_CL?
2014-12-28T02:28:52Z Hexstream: nyef: My attitude to full semantic walking is "don't do it unless you absolutely have to, it's fraught with complexities".
2014-12-28T02:29:18Z nyef: But... Yeah. Why does PCL need to know if it needs to save the arglist? Push that to the compiler, already!
2014-12-28T02:29:26Z towodo joined #lisp
2014-12-28T02:29:52Z nyef: Hexstream: If you're doing any sort of semantic walking, you're either implementing a language or you're doing something wrong.
2014-12-28T02:30:00Z stassats: nyef: you try finding a person who understands both the compiler and pcl
2014-12-28T02:31:22Z Hexstream: And I also tend to avoid doing "unportable" things, which full semantic walking is one, so cons-walking seemed to be a "safe" portable alternative, that was just too fucking convenient. So imagine my surprise when the conservative portable thing was... Hexstream-broken.
2014-12-28T02:31:44Z Jubb joined #lisp
2014-12-28T02:32:21Z nyef: stassats: ... Krystof?
2014-12-28T02:33:02Z Hexstream: nyef: DSLs are kind of a "specialty" of mine, at least insofar as I spend most of my time working on or thinking about those.
2014-12-28T02:33:20Z Hexstream: Which is also a very major reason I was brought to Common Lisp in the first place...
2014-12-28T02:33:36Z Hexstream: Bicyclidine: What limitations have I ignored?
2014-12-28T02:34:02Z Bicyclidine: well, a while ago stassats mentioned code using an (eql -7) type declaration, presumably versus your negator gizmo
2014-12-28T02:34:20Z nyef: Heh. My path to common lisp was via emulation and a quest for programmer effectiveness/efficiency.
2014-12-28T02:34:46Z stassats: i forgot my path
2014-12-28T02:35:32Z Hexstream: Bicyclidine: I didn't understand that example, but anyway my "walk to change numbers to negative numbers" example from months ago was to demonstrate intended operational behavior, it wasn't meant as an example of relevant use-case...
2014-12-28T02:38:44Z nyef: Hexstream: Relevant use-cases are a lot more useful than contrived examples.
2014-12-28T02:39:04Z Karl_Dscc quit (Remote host closed the connection)
2014-12-28T02:39:10Z attila_lendvai quit (Quit: Leaving.)
2014-12-28T02:40:55Z Hexstream: nyef: Well, bubble-operator-upwards and positional-lambda are certainly (at least to me) relevant use-cases for cons-walking.
2014-12-28T02:41:37Z nyef: stassats: Backing up a step, while I'm not sure that I understand the compiler all that well, I think that I'm starting to get to a point where I'm likely to start trying to figure out the MOP and possibly some of the PCL internals.
2014-12-28T02:42:08Z stassats: nyef: my project idea is to get IR1 and convert it back to s-exps, just to better understand it
2014-12-28T02:42:21Z stassats: and then i want to change fopcompile to work on IR1
2014-12-28T02:42:29Z nyef: Hmm...
2014-12-28T02:42:37Z nyef: That has some possibilities, really.
2014-12-28T02:42:55Z Bicyclidine: Hexstream: so is there a huge issue with adding a numeric parameter and using non-keywords to do the same thing instead of walking
2014-12-28T02:42:59Z Hexstream: And the primary use-case of positional-lambda is not having to name "duplicate" variable names, like when you do (mapcar (lambda (foo bar) ...) foos bars) (especially for long variable names, and even more so for "doubly plural" names)
2014-12-28T02:43:23Z stassats: because it really is duplicating some work, and performs double macro expansion (triple until recently)
2014-12-28T02:43:29Z Hexstream: Bicyclidine: positional-lambda will automatically add ignored variables if there are "gaps" in the numbering.
2014-12-28T02:43:43Z nyef: IR1, and toplevel forms especially, is where my understanding of the compiler breaks down.
2014-12-28T02:44:17Z stassats: i'm getting all kinds of epiphanies each time i try to look at it, not yet enough for a full picture
2014-12-28T02:44:21Z Bicyclidine: Hexstream: yes, i was giving up on that. it doesn't seem that important.
2014-12-28T02:44:28Z nyef: I'm reminded that CMUCL has, or used to have, an IR1-level interpreter.
2014-12-28T02:45:00Z linux_dream quit (Quit: Leaving)
2014-12-28T02:45:06Z Bicyclidine: plus macros with weird argument conventions like that, i don't like em. like defmethod. boo
2014-12-28T02:45:09Z Hexstream: Bicyclidine: Well, that's a really important feature to me. I like "point-free" programming. (Sometimes called "pointless" by some.)
2014-12-28T02:45:48Z stassats: positional-lambda can be done with doing macroexpansion
2014-12-28T02:45:57Z Bicyclidine: You like point-free programming so you made a thing to ease writing functions based on variables...
2014-12-28T02:46:07Z stassats: unlike bubble-wrap
2014-12-28T02:47:27Z Bicyclidine: also what does specifying an argument count even have to do with pointfreeness. gh
2014-12-28T02:47:29Z gambyte joined #lisp
2014-12-28T02:47:36Z Hexstream: Bicyclidine: The point is, I don't have to explicitly name and/or ignore those variables.
2014-12-28T02:47:53Z nyef: ls
2014-12-28T02:47:55Z Bicyclidine: is this really what you think point free programming is
2014-12-28T02:47:58Z nyef: Oops. Wrong window. (-:
2014-12-28T02:48:03Z stassats: nyef: no such file or directory
2014-12-28T02:48:30Z nyef: stassats: Odd, I could have sworn that my cwd was ~/src/lisp/sbcl/sbcl-git/src/pcl/.
2014-12-28T02:48:38Z Hexstream: Bicyclidine: Not sure if I was formally correct in my use of the term "point-free", I just mean that positional-lambda makes writing some trivial "forwarding", "adapting" (whatever you want to call them) closures much more concise and convenient.
2014-12-28T02:48:47Z Bicyclidine: perl is point-free because you can use $_ without declaring it! wow
2014-12-28T02:49:02Z Bicyclidine: Hexstream: i'm talking about adding a number. it's, like, two more characters. i'm pretty baffled right now.
2014-12-28T02:49:58Z Hexstream: Bicyclidine: What about &rest? What about ignored variables? What about concision? positional-lambda supports all of that and more, all at once.
2014-12-28T02:50:45Z Bicyclidine: (1) i said you could put the number in a list to indicate that there should be a rest (2) declare them all ignorable, the code is less than a line anyway (3) what
2014-12-28T02:50:48Z Hexstream: Bicyclidine: You're trying to evaluate an original idea in the abstract, and of course that's really hard.
2014-12-28T02:51:06Z stassats: just expand the macros
2014-12-28T02:51:12Z stassats: you will get your conses
2014-12-28T02:51:26Z Hexstream: Yes, and the macroexpand-1 will be low-level shit.
2014-12-28T02:51:38Z stassats: what do you care?
2014-12-28T02:51:53Z stassats: just find your :1 and flush it
2014-12-28T02:51:57Z nyef: ... I almost never use macroexpand or macroexpand-1.
2014-12-28T02:52:18Z Bicyclidine: or you could just have them all take rest. or have pfirst = (lambda (&rest a) (first a)), psecond = (lambda (&rest a) (second a)), etc. or so many other things that don't cause bizarre arguments about the historical context of bla bla bla
2014-12-28T02:52:18Z Hexstream: Well, I use it through slime. Regularly.
2014-12-28T02:52:37Z Dynasty joined #lisp
2014-12-28T02:52:53Z nyef: I guess that they might be more useful when exploring someone else's code, but for my own work they are rarely useful.
2014-12-28T02:52:53Z Bicyclidine: i don't even like point-free programming and plambda being it is a pretty depressing thing you've said, man
2014-12-28T02:53:57Z Hexstream: Bicyclidine: That's cool and all but your lack of enthusiasm and understanding isn't a compelling argument.
2014-12-28T02:55:05Z dagnachew quit (Remote host closed the connection)
2014-12-28T02:55:49Z Hexstream: Bicyclidine: You seem to assume I came up with the specific design of positional-lambda with no thought in an afternoon. I had been thinking about what I wanted and what I didn't want for years before.
2014-12-28T02:56:14Z stassats: but how does positional-lambda need clear conses?
2014-12-28T02:56:24Z Ven quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
2014-12-28T02:56:55Z Hexstream: And a lot of that came from not using LOOP and thus using mapping operators more, and thus all these fucking trivial lambdas with the goddamn "duplicated" variable names and ignored variables and stuff.
2014-12-28T02:57:11Z stassats: oh yeah, how is loopless coming on?
2014-12-28T02:57:19Z Bicyclidine: You don't understand what I'm saying either, your design requirements are completely ridiculous as far as I'm concerned, and I've put you on ignore so please don't bother telling me more about them.
2014-12-28T02:57:59Z Hexstream: stassats: Well, watch this space: http://worknotes.hexstreamsoft.com/libraries/metaprojects/loopless2/
2014-12-28T02:59:34Z Hexstream: Bicyclidine: That's great, that solves a lot of problems all at once. You seemed more interested in being demeaning than giving relevant arguments and actually trying to understand anyway.
2014-12-28T03:00:28Z Hexstream: stassats: I mean, nothing interesting there, but whenever there's something interesting going on about Loopless 2, that would be there.
2014-12-28T03:00:40Z nyef: ... If I'm going to consider trying to figure out how PCL works is there any better reference than AMOP?
2014-12-28T03:01:26Z Bicyclidine: i don't think AMOP says very much about PCL?
2014-12-28T03:01:44Z nyef: Written by some of the same people, IIRC.
2014-12-28T03:02:09Z Bicyclidine: Yeah, but AMOP's implementation, closette, is completely different. no constructors, doesn't have PCL's caching, nuthin.
2014-12-28T03:02:22Z innertracks quit (Quit: innertracks)
2014-12-28T03:03:10Z Hexstream: stassats: positional-lambda needs clear conses because of this: https://github.com/Hexstream/positional-lambda/blob/master/main.lisp#L178
2014-12-28T03:03:16Z Bicyclidine: they wrote a few papers on some aspects. beach probably has good refs. i don't know if they covered the weirder parts of method lambdas, though
2014-12-28T03:04:07Z nell joined #lisp
2014-12-28T03:04:24Z stassats: Hexstream: because of what?
2014-12-28T03:04:39Z zeitue joined #lisp
2014-12-28T03:04:52Z Hexstream: Because it needs to walk the conses and find the relevant positional symbols and "special forms"?
2014-12-28T03:05:45Z stassats: it can do that on expanded code
2014-12-28T03:06:06Z Hexstream: Is there an easy portable way of doing that?
2014-12-28T03:07:17Z stassats: sure
2014-12-28T03:07:18Z Hexstream: I mean, I would still lose the high-levelness of macroexpansions and lack of dependencies, but it's something to consider I guess...
2014-12-28T03:07:37Z stassats: what high-levelness of macroexpansions?
2014-12-28T03:08:22Z stassats: ah, you wan to keep using keywords?
2014-12-28T03:08:23Z Hexstream: Well, if I use some really high-level macro inside a positional-lambda, and I macroexpand the positional-lambda, with my current approach, the call to the high-level macro wouldn't be expanded.
2014-12-28T03:08:47Z nyef: If that situation comes up, your functions are too large.
2014-12-28T03:09:14Z stassats: but it's a bit sad that you spend years thinking on such a thing as a LAMBDA wrapping macro
2014-12-28T03:09:16Z nyef: Bicyclidine: Hence my question.
2014-12-28T03:09:40Z Hexstream: stassats: It's not the only thing I thought about during all those years.
2014-12-28T03:09:51Z nyef: Bicyclidine: ISTR that there's a paper on some of the things that PCL does, but I don't remember what paper it was... or if I have a copy locally or not.
2014-12-28T03:11:22Z Hexstream: stassats: It's tiny timeslices spent across many years... Some annoyances come up again and again, and then thoughts gradually crystallize on what the problem is, and then it starts crystallizing on possible solutions, and then on a particular solution, then a specific design...
2014-12-28T03:12:33Z ivan\ quit (Ping timeout: 252 seconds)
2014-12-28T03:13:06Z Hexstream: If 2015 doesn't turn out to be an abject failure like 2014 was (at least relative to my fairly enthusiastic expectations), then I'll have addressed most of my concerns with Common Lisp by the end of the year and then I can start working on my Second-System Effect dynamic web framework...
2014-12-28T03:13:15Z stassats: with code walking you can avoid (plambda `(:1 ,:2)) == [:1 will be erroneously replaced]
2014-12-28T03:14:27Z Hexstream: stassats: Yes, but I don't really care about this particular case, using full code-walking just for it (well, ignoring backquotegate) seems a bit much.
2014-12-28T03:15:31Z stassats: so, your current solution doesn't work on some implementations and doesn't work on all code?
2014-12-28T03:15:52Z stassats: but it's aesthetically clean
2014-12-28T03:16:03Z stassats: too bad reality isn't aesthetically clean
2014-12-28T03:16:30Z ivan\ joined #lisp
2014-12-28T03:17:20Z Hexstream: It's not meant to be aesthetically clean, just practical. Like reality. (Well, reality can be fairly impractical, but I mean...)
2014-12-28T03:17:49Z stassats: clearly, Common Lisp is just not suited for this
2014-12-28T03:19:35Z nyef: Oh, wow. There's a FIXME-comment in PCL to the effect of "don't use the walker, make the compiler do it". (-:
2014-12-28T03:19:56Z stassats: but the compiler is a walker
2014-12-28T03:20:19Z nyef: Yes, but we shouldn't need a separate walker for PCL.
2014-12-28T03:21:03Z Hexstream: I think it's easy to understand why compiler writers don't care about doing a fully semantic code-walk while macroexpanding fucking everything, they are the last stage in the pipeline anyway so they need the most low-level representation anyway.
2014-12-28T03:24:36Z BitPuffin quit (Ping timeout: 264 seconds)
2014-12-28T03:24:43Z nogart quit (Quit: leaving)
2014-12-28T03:26:38Z Zamenhoff joined #lisp
2014-12-28T03:29:53Z innertracks joined #lisp
2014-12-28T03:31:24Z Zamenhoff left #lisp
2014-12-28T03:42:01Z theseb joined #lisp
2014-12-28T03:51:05Z towodo quit (Quit: towodo)
2014-12-28T04:01:06Z theos joined #lisp
2014-12-28T04:03:18Z nell quit (Quit: WeeChat 1.1-rc1)
2014-12-28T04:03:24Z zajn joined #lisp
2014-12-28T04:09:33Z MrWoohoo quit (Quit: ["Textual IRC Client: www.textualapp.com"])
2014-12-28T04:14:53Z stassats quit (Ping timeout: 240 seconds)
2014-12-28T04:20:27Z theos quit (Remote host closed the connection)
2014-12-28T04:23:08Z theos joined #lisp
2014-12-28T04:23:33Z theos quit (Read error: Connection reset by peer)
2014-12-28T04:23:45Z Beetny joined #lisp
2014-12-28T04:27:41Z theos joined #lisp
2014-12-28T04:31:20Z beach joined #lisp
2014-12-28T04:31:30Z beach: Good morning everyone!
2014-12-28T04:31:40Z nyef: Hello beach.
2014-12-28T04:32:07Z nyef: beach: How far did you get with respect to input editing with your various CLIM things?
2014-12-28T04:32:37Z beach: nyef: CLIMatis?  Not done yet.
2014-12-28T04:33:06Z beach: But it should be fully functional in McCLIM.
2014-12-28T04:33:08Z nyef: ... Has it even been started?
2014-12-28T04:33:38Z beach: No, input editing has not been started in CLIMatis.
2014-12-28T04:33:56Z zyaku quit (Ping timeout: 244 seconds)
2014-12-28T04:34:55Z beach: nyef: You seem to be busy lately, with McCLIM, CLOS, etc.  Just catching up with the logs now.
2014-12-28T04:35:19Z beach: s/McCLIM/CLIM/
2014-12-28T04:35:55Z nyef: Mostly idly puttering about, with a large bit of trying to figure out how CLIM input processing works.
2014-12-28T04:36:09Z beach: Ah, I see.
2014-12-28T04:36:23Z beach: I don't fully understand it.
2014-12-28T04:38:36Z nyef: Mmm. And I'm partly at the level of "mine eyes glazeth over" with some of the higher-level stuff, combined with "wait, what? why does THAT have an input buffer?" and a dash of "what were they THINKING with this text-style mapping rubbish?"
2014-12-28T04:39:21Z beach: What would you have done instead of text-style mappings?
2014-12-28T04:39:57Z nyef: I don't know, but it seems as though it's one of the less-well-thought-out parts of the spec.
2014-12-28T04:40:18Z beach: Hmm, it hasn't been on my lest so far.
2014-12-28T04:41:58Z zRecursive quit (Remote host closed the connection)
2014-12-28T04:42:50Z nyef: clim make-device-font-text-style
2014-12-28T04:42:53Z nyef: Hrm.
2014-12-28T04:42:56Z nyef: Damnit, specbot!
2014-12-28T04:43:11Z beach: I think it was removed.
2014-12-28T04:43:31Z nyef: http://bauhh.dyndns.org:8000/clim-spec/11-3.html#_597
2014-12-28T04:45:35Z nyef: The whole CHARACTER-SET bit seems sketchy to begin with.
2014-12-28T04:45:59Z beach: That's true.
2014-12-28T04:46:32Z beach: The spec predates widespread use of Unicode I suppose.
2014-12-28T04:46:49Z beach: Who says we are not making progress?
2014-12-28T04:47:23Z nyef: And then consider the interactions between TEXT-STYLE-MAPPING and (SETF TEXT-STYLE-MAPPING) and numeric text-style sizes.
2014-12-28T04:47:46Z nyef: And that's before you start getting into host (device?) fonts.
2014-12-28T04:48:25Z beach: I think the device stuff was supposed to be used only in exceptional situations.
2014-12-28T04:48:29Z beach: I may be wrong of course.
2014-12-28T04:48:32Z theseb quit (Quit: Leaving)
2014-12-28T04:48:57Z nyef: No, that's about right, but it needs to work in order to do basic configuration.
2014-12-28T04:49:59Z nyef: Oh, and consider MERGE-TEXT-STYLES with a relative size on the one side and a numeric size on the other.
2014-12-28T04:50:01Z beach: I think the idea was that the programmer works with these abstract text styles and the CLIM implementer decides on the mapping.
2014-12-28T04:50:35Z beach: Yeah, OK.  I can grant you that one as well.
2014-12-28T04:50:38Z nyef: Yes, but there's also an explicit override which is somewhat sketchy.
2014-12-28T04:51:18Z nyef: And this isn't even input processing, this is just text output.
2014-12-28T04:52:12Z beach: Sure.  It is over-engineered.  Like many other things in the spec.
2014-12-28T04:52:44Z beach: I thought you meant the basic idea of text styles.  I don't see a problem with that.
2014-12-28T04:53:34Z nyef: Yeah, the basic idea, as usual, seems pretty okay. It's the details that trip the entire thing up.
2014-12-28T04:53:54Z beach: Agreed, then.
2014-12-28T04:57:46Z nyef: Anyway, the reason that I was digging into all of this was to try and figure out how to kick NQ-CLIM together enough to be useful for more than the simple maze-running demo that I started with.
2014-12-28T04:58:29Z beach: Excellent!
2014-12-28T04:58:42Z nyef: Excellent -- IF it comes together.
2014-12-28T04:59:06Z beach: To me it is great that you are even thinking about it.
2014-12-28T05:00:56Z nyef: ... And it suddenly occurs to me that I've been looking at this All Wrong. My first step should be OUTPUT streams, not INPUT.
2014-12-28T05:01:26Z beach: Those are easier I think.
2014-12-28T05:01:48Z nyef: The first cut would get me working text output, plus font mapping. The second cut gets me OUTPUT-RECORD objects.
2014-12-28T05:02:12Z beach: "cut"?
2014-12-28T05:02:58Z nyef: ... I think that the term dates back to splicing a film reel or audio tape together as an editing pass.
2014-12-28T05:03:08Z beach: In CLIMaits, I got rid of the distinction between output record, sheet, design and what have you.
2014-12-28T05:03:20Z beach: Oh, that kind of cut.  OK.
2014-12-28T05:03:31Z nyef: That is, literally cutting a film of some sort with a razor blade and taping the bits together.
2014-12-28T05:03:38Z beach: Right.
2014-12-28T05:04:34Z beach: I haven't done stream output yet in CLIMatis, but I think it will be easy, given what I did already.
2014-12-28T05:05:14Z nyef: Yeah, I've already done stream output to the display once, though that was more on the OpenGL / GLX side.
2014-12-28T05:06:32Z rk[ohio] quit (Ping timeout: 245 seconds)
2014-12-28T05:07:08Z beach: Stream output is basically keeping a cursor and defining how the tree of output records is modified when you "print" something.
2014-12-28T05:07:12Z nyef: Now, if only the input editor made sense to me...
2014-12-28T05:07:37Z beach: For what it's worth, I can't figure it out either.
2014-12-28T05:07:53Z beach: I think the people who understood it, already knew about "classic CLIM".
2014-12-28T05:08:07Z nyef: For what it's worth, http://www.nhplace.com/kent/PS/Ambitious.html seems to be relevant.
2014-12-28T05:09:03Z nyef: But that doesn't include the whole interaction with presentations.
2014-12-28T05:10:34Z beach: I am reading it...
2014-12-28T05:13:32Z nyef: The basic idea seems to be to start from that style of "rubout handling" and arrange for its apotheosis.
2014-12-28T05:14:04Z beach: Yes, I remember knowing this at some point, but given my very bad memory, I need to understand it again.
2014-12-28T05:14:09Z rk[ohio] joined #lisp
2014-12-28T05:15:40Z ggole joined #lisp
2014-12-28T05:19:00Z beach: OK, I think I remember it now.
2014-12-28T05:19:36Z vinleod joined #lisp
2014-12-28T05:20:10Z Quadrescence: ( ͡° ͜ʖ ͡°)
2014-12-28T05:20:10Z beach: But wasn't there also a problem with presentations? If the user clicks on some object, doesn't the entire object become part of the input, as opposed to its corresponding sequence of characters?
2014-12-28T05:20:35Z nyef: Yes, presentations (and ACCEPT) is where things start getting really twisted.
2014-12-28T05:20:38Z beach: Then, if part of a presentation is erased, it has to be unparsed.
2014-12-28T05:20:45Z tesuji joined #lisp
2014-12-28T05:20:58Z beach: Right.
2014-12-28T05:21:07Z nyef: Umm... I don't know that that latter is supposed to be possible.
2014-12-28T05:21:23Z beach: I am pretty sure it is.
2014-12-28T05:21:24Z rk[ohio] quit (Ping timeout: 250 seconds)
2014-12-28T05:21:32Z nyef: Consider ACCEPTing an object that doesn't have a printable representation.
2014-12-28T05:21:56Z beach: It is always PRINT-able.
2014-12-28T05:22:00Z nyef: Such as a #<some-class-without-a-print-object-method>.
2014-12-28T05:22:03Z beach: The question is whether it is READable.
2014-12-28T05:22:06Z nyef: Err... A READable, yeah.
2014-12-28T05:22:18Z nyef: It's coming up on half past midnight here. (-:
2014-12-28T05:22:18Z beach: I have no idea what happens then.
2014-12-28T05:22:23Z chu quit (Ping timeout: 240 seconds)
2014-12-28T05:22:36Z beach: Maybe it works only if there is an unparser for it?
2014-12-28T05:22:40Z beach: I am just guessing.
2014-12-28T05:22:59Z psy joined #lisp
2014-12-28T05:24:20Z beach: You know, rather than trying to understand the spec, it would probably be easier to figure out what effect you would like and then specify how to accomplish it.
2014-12-28T05:24:27Z chu joined #lisp
2014-12-28T05:24:57Z chu is now known as Guest79953
2014-12-28T05:25:59Z nyef: That might be true, except that I don't KNOW what effect I want.
2014-12-28T05:26:28Z beach: Hmm.  OK.
2014-12-28T05:27:31Z beach: Well, it's clear that the Pitman article is a software-engineering issue so that the READ primitives don't have to deal with rubout handling.
2014-12-28T05:27:57Z nyef: Yeah, pretty much.
2014-12-28T05:28:18Z rk[ohio] joined #lisp
2014-12-28T05:28:24Z Guest79953 is now known as mwsb
2014-12-28T05:28:28Z mwsb quit (Changing host)
2014-12-28T05:28:29Z mwsb joined #lisp
2014-12-28T05:28:50Z nyef: It looks like ACCEPT bounces to ACCEPT-1 on a stream, which bounces to a "presentation method" ACCEPT on the presentation type, which does the actual "parsing" bit.
2014-12-28T05:29:18Z beach: Sounds right.
2014-12-28T05:29:26Z nyef: I'm not sure at this point which part calls WITH-INPUT-EDITING or whatever it's called.
2014-12-28T05:29:26Z beach: It also seems clear that some incremental parsing is desired (that can be undone by rubout) presumably in order to handle things like completion and highlighting.
2014-12-28T05:29:45Z nyef: That, and dealing with parse errors.
2014-12-28T05:29:58Z beach: Sure.
2014-12-28T05:32:26Z beach: I also recall that the entire original input editor in McCLIM was replaced by DREI (as much of Climacs as was needed for input editing) at some point.
2014-12-28T05:33:01Z nyef: ... Am I going to have to call my input editor "VIER"?
2014-12-28T05:33:01Z beach: ... which suggests that it was generalized to multi-line input.
2014-12-28T05:33:42Z beach: Sure, VIER is still a reasonable acronym.  Vier Is Emacs Really.
2014-12-28T05:34:18Z beach: It gets harder after that.
2014-12-28T05:34:50Z nyef: ... I don't even know my German numbers past vier. (-:
2014-12-28T05:35:01Z beach: Oh! :)
2014-12-28T05:35:21Z nyef: Except maybe for eight. Ocht or Ochs?
2014-12-28T05:35:42Z beach: Acht.
2014-12-28T05:35:48Z nyef: See?
2014-12-28T05:35:52Z beach: I see.
2014-12-28T05:36:31Z nyef: I knew it was a cognate. Finding which external-format to use is still a bit tricky. (-:
2014-12-28T05:36:54Z beach: Heh.
2014-12-28T05:37:15Z rk[ohio] quit (Ping timeout: 272 seconds)
2014-12-28T05:37:45Z beach: SIEBEN: Sieben Is Emacs But ...
2014-12-28T05:37:51Z beach: That one is doable.
2014-12-28T05:42:57Z dkcl quit (Read error: Connection reset by peer)
2014-12-28T05:44:02Z rk[ohio] joined #lisp
2014-12-28T05:47:02Z jusss joined #lisp
2014-12-28T05:47:29Z nyef: The other side that I'm looking at is what would be involved in implementing the CLIM input editor in a terminal environment.
2014-12-28T05:47:45Z innertracks quit (Quit: innertracks)
2014-12-28T05:47:48Z LiamH quit (Quit: Leaving.)
2014-12-28T05:49:37Z rk[ohio] quit (Ping timeout: 256 seconds)
2014-12-28T05:50:24Z _m___ quit (Remote host closed the connection)
2014-12-28T05:51:50Z nyef: Is WITH-INPUT-EDITING called from within ACCEPT, or should ACCEPT be called from within WITH-INPUT-EDITING?
2014-12-28T05:53:46Z nyef: Hrm. Looks like ACCEPT-1 is responsible for calling WITH-INPUT-EDITING.
2014-12-28T05:56:22Z rk[ohio] joined #lisp
2014-12-28T05:56:25Z Hexstream left #lisp
2014-12-28T05:56:26Z Sgeo quit (Read error: Connection reset by peer)
2014-12-28T05:56:27Z _m___ joined #lisp
2014-12-28T05:56:40Z Sgeo joined #lisp
2014-12-28T06:05:58Z rk[ohio] quit (Ping timeout: 255 seconds)
2014-12-28T06:06:14Z theseb joined #lisp
2014-12-28T06:06:51Z MrWoohoo joined #lisp
2014-12-28T06:11:18Z akkad joined #lisp
2014-12-28T06:13:39Z rk[ohio] joined #lisp
2014-12-28T06:14:34Z jusss quit (Remote host closed the connection)
2014-12-28T06:15:39Z akkad: http://paste.lisp.org/display/144938 finally got gzip to read in while parsing json. I imagine it can be optimized quiet a bit
2014-12-28T06:19:46Z pppp2 joined #lisp
2014-12-28T06:22:46Z psy quit (Quit: Leaving)
2014-12-28T06:24:24Z vinleod quit (Quit: ["Textual IRC Client: www.textualapp.com"])
2014-12-28T06:30:57Z ASau joined #lisp
2014-12-28T06:31:01Z theseb quit (Quit: Leaving)
2014-12-28T06:34:23Z enitiz quit (Ping timeout: 240 seconds)
2014-12-28T06:39:36Z ndrei joined #lisp
2014-12-28T06:40:50Z nyef: Okay, it's almost quarter of two. Time for me to get some sleep. Tomorrow it may be time for me to re-evaluate my current approach to unit-testing stuff.
2014-12-28T06:40:56Z nyef quit (Quit: G'night all)
2014-12-28T06:41:36Z zRecursive joined #lisp
2014-12-28T06:41:56Z drdanmaku quit (Quit: Connection closed for inactivity)
2014-12-28T06:43:57Z hvxgr quit (Ping timeout: 240 seconds)
2014-12-28T06:45:54Z innertracks joined #lisp
2014-12-28T06:47:19Z Bicyclidine quit (Ping timeout: 245 seconds)
2014-12-28T06:52:47Z nikki93 joined #lisp
2014-12-28T06:56:57Z ASau quit (Ping timeout: 245 seconds)
2014-12-28T06:57:53Z ASau joined #lisp
2014-12-28T07:10:16Z mrSpec joined #lisp
2014-12-28T07:11:19Z akkad: night
2014-12-28T07:14:05Z Bicyclidine joined #lisp
2014-12-28T07:14:48Z hvxgr joined #lisp
2014-12-28T07:19:49Z pppp2 quit (Read error: Connection reset by peer)
2014-12-28T07:20:48Z someon joined #lisp
2014-12-28T07:33:26Z devll joined #lisp
2014-12-28T07:34:13Z tadni quit (Remote host closed the connection)
2014-12-28T07:35:51Z tadni joined #lisp
2014-12-28T07:40:57Z dkcl joined #lisp
2014-12-28T07:43:00Z zRecursive quit (Ping timeout: 258 seconds)
2014-12-28T07:46:21Z Quadrescence quit (Quit: Leaving)
2014-12-28T07:47:47Z dfox quit (Ping timeout: 245 seconds)
2014-12-28T07:50:34Z innertracks quit (Quit: innertracks)
2014-12-28T07:53:23Z ASau quit (Ping timeout: 240 seconds)
2014-12-28T07:56:41Z CrazyM4n joined #lisp
2014-12-28T07:57:57Z pnpuff joined #lisp
2014-12-28T08:00:24Z dfox joined #lisp
2014-12-28T08:02:19Z dfox quit (Read error: No route to host)
2014-12-28T08:02:41Z pnpuff left #lisp
2014-12-28T08:05:30Z bgs100 quit (Quit: bgs100)
2014-12-28T08:06:15Z zRecursive joined #lisp
2014-12-28T08:07:21Z Vutral quit (Ping timeout: 272 seconds)
2014-12-28T08:08:04Z ASau joined #lisp
2014-12-28T08:11:32Z dfox joined #lisp
2014-12-28T08:13:38Z hitecnologys quit (Quit: ZNC - http://znc.in)
2014-12-28T08:14:35Z hitecnologys joined #lisp
2014-12-28T08:16:57Z Vutral joined #lisp
2014-12-28T08:21:49Z beach: Hmm, so (loop for nil from 1 to 5 ...) is legal.  Who would have thunk?
2014-12-28T08:29:30Z oldk joined #lisp
2014-12-28T08:32:03Z pnpuff joined #lisp
2014-12-28T08:33:11Z hiroakip joined #lisp
2014-12-28T08:33:35Z jtza8 joined #lisp
2014-12-28T08:34:19Z tadni quit (Remote host closed the connection)
2014-12-28T08:43:27Z psy joined #lisp
2014-12-28T08:44:17Z oldk quit (Read error: Connection reset by peer)
2014-12-28T08:47:12Z tadni joined #lisp
2014-12-28T08:48:39Z pppp2 joined #lisp
2014-12-28T08:50:52Z ASau quit (Ping timeout: 240 seconds)
2014-12-28T08:51:37Z tadni quit (Remote host closed the connection)
2014-12-28T08:51:59Z tadni joined #lisp
2014-12-28T08:55:03Z kapil__ joined #lisp
2014-12-28T08:56:07Z Shinmera joined #lisp
2014-12-28T08:56:29Z protist joined #lisp
2014-12-28T08:56:51Z Shinmera: beach: I don't want to imagine who would have thought that that was legal.
2014-12-28T08:57:31Z Grue`: but nil can be substituted for unused variables in loop destructuring, so it's logical
2014-12-28T08:57:32Z beach: Shinmera: Well, it is a direct consequence of the specification.  Whether that was intended or not is debatable of course.
2014-12-28T08:57:52Z zRecursive quit (Remote host closed the connection)
2014-12-28T08:58:22Z Grue`: (loop for nil from foo downto blah) instead of (loop repeat (- foo blah +1)) or something
2014-12-28T08:58:41Z Ethan- joined #lisp
2014-12-28T09:03:57Z sol__ joined #lisp
2014-12-28T09:06:57Z pt1 joined #lisp
2014-12-28T09:10:43Z pnpuff left #lisp
2014-12-28T09:13:38Z zajn quit (Remote host closed the connection)
2014-12-28T09:14:41Z beach: I think the LOOP specification must be one of the worst parts of the Common Lisp HyperSpec.  It definitely deserves a cleanup in Common Lisp version 2.
2014-12-28T09:14:49Z milosn quit (Ping timeout: 252 seconds)
2014-12-28T09:14:55Z yenda joined #lisp
2014-12-28T09:15:31Z akkad: cltlv2? eta?
2014-12-28T09:15:59Z beach: I mean, I know that a specification is not meant to be pedagogical, but things like that could have been mentioned explicitly.
2014-12-28T09:16:18Z CrazyM4n quit (Quit: sleep)
2014-12-28T09:17:01Z vaporatorius joined #lisp
2014-12-28T09:17:50Z manuel__ joined #lisp
2014-12-28T09:18:41Z Shinmera: beach: FORMAT could also use a once-over
2014-12-28T09:19:04Z beach: Shinmera: Perhaps.  Though I didn't have nearly as much problems with it as I have had with LOOP.
2014-12-28T09:19:17Z Shinmera: Sure.
2014-12-28T09:19:18Z beach: s/problems/trouble/
2014-12-28T09:20:32Z fantazo joined #lisp
2014-12-28T09:20:36Z yenda quit (Ping timeout: 250 seconds)
2014-12-28T09:22:06Z Dynasty quit (Quit: ChatZilla 0.9.91.1 [Firefox 34.0.5/20141126041045])
2014-12-28T09:24:45Z gravicappa joined #lisp
2014-12-28T09:25:32Z jtza8 quit (Ping timeout: 244 seconds)
2014-12-28T09:28:12Z yenda joined #lisp
2014-12-28T09:32:48Z wbooze quit (Read error: Connection reset by peer)
2014-12-28T09:33:24Z devll quit (Remote host closed the connection)
2014-12-28T09:37:22Z beach: Shinmera: Speaking of which, did you see what eudoxia did in terms of specifying an API for manipulating documents?
2014-12-28T09:39:13Z psy quit (Ping timeout: 265 seconds)
2014-12-28T09:39:18Z beach: Shinmera: https://github.com/CommonDoc/common-doc
2014-12-28T09:40:05Z Shinmera: He basically did what I would've done if I just went to code after thinking about it for five minutes, which is something I want to avoid doing.
2014-12-28T09:40:22Z beach: Ah, OK.
2014-12-28T09:40:44Z beach: I haven't looked at it very closely yet.
2014-12-28T09:40:57Z Shinmera: It's mostly just a bunch of class definitions for common document elements.
2014-12-28T09:40:59Z beach: It seems to be a bunch of classes using Dylan naming conventions.
2014-12-28T09:41:04Z Shinmera: Yes.
2014-12-28T09:41:08Z munksgaard joined #lisp
2014-12-28T09:45:50Z pppp2 quit (Read error: Connection reset by peer)
2014-12-28T09:46:42Z Shinmera: The core difficulty in the project to me seems to be how to unify modification/transformation of the document from the initial "read" to the final "print" to be usable for all different sets of limitations in both input and output
2014-12-28T09:47:04Z Shinmera: Which is not addressed in any way whatsoever in what eudoxia wrote so far
2014-12-28T09:47:15Z beach: True.
2014-12-28T09:47:25Z beach: Also not addressed in CCLDoc as far as I can tell.
2014-12-28T09:47:30Z Shinmera: Yes.
2014-12-28T09:48:24Z Shinmera: One thing I'm still struggling to incorporate is the usage of 'functions' in the input so to speak, since those need to be representable in the document somehow, but still have to be ambiguous enough to account for all different kinds of the same thing you can have in different formats.
2014-12-28T09:49:04Z Shinmera: Because if that's not part of the model, any parser has to implement an intermediate format that then compiles down to the document, which is stupid as it would create a huge duplication in effort.
2014-12-28T09:49:25Z beach: What kind of 'functions' do you mean here?
2014-12-28T09:49:38Z Shinmera: Same for the output, as certain output formats don't support some types of blocks, so transformations to other, equivalent constructs need to be available somehow.
2014-12-28T09:50:12Z Shinmera: beach: You could imagine a markup language similar to TeX where things expand to other constructs, rather than being a direct construct themselves.
2014-12-28T09:50:29Z beach: Oh, I see.  Macro-like things?
2014-12-28T09:50:32Z Shinmera: Yes
2014-12-28T09:50:45Z beach: Let me contemplate what you just said for a minute...
2014-12-28T09:51:14Z beach: Why do such things need to be part of the specification of the document structure?
2014-12-28T09:51:37Z Shinmera: Because otherwise any parser needs an intermediate format that's either a mix of the document structure and something of their own, or something completely of their own.
2014-12-28T09:52:03Z Shinmera: It also means that you can't re-use components that would provide such "expanders" in other parsers/projects.
2014-12-28T09:52:19Z beach: I had imagined letting input/output processors define new classes and new methods specialized to those classes.
2014-12-28T09:52:29Z Shinmera: Right
2014-12-28T09:52:49Z Shinmera: but that still means we need to specify at least some protocol according to which these things are expanded and modified.
2014-12-28T09:52:54Z beach: So, the document definition needs to have rules about what can be a "child" of what else.
2014-12-28T09:53:08Z beach: Yes, I can see that.
2014-12-28T09:53:43Z beach: ... and tell the creator of the input processor what methods need to be supplied on the some new class that it needs.
2014-12-28T09:53:47Z Blaguvest joined #lisp
2014-12-28T09:53:59Z beach: s/on the some/on some/
2014-12-28T09:54:01Z Shinmera: As I said, the same goes for the output, since some constructs we may declare as "standard" might not be available and need to be constructed through other constructs for that particular output format.
2014-12-28T09:54:37Z beach: Sure.
2014-12-28T09:55:09Z Shinmera: I haven't been able to figure out a nice way of specifying such a protocol yet, hence why I haven't started with any code so far.
2014-12-28T09:55:21Z beach: Fair enough.
2014-12-28T09:57:09Z beach: So do you think that typical input processors will not contain any macro functionality, and that they would instead add new classes to the structure that they need to indicate to the document processing system how to manage?
2014-12-28T09:58:16Z pppp2 joined #lisp
2014-12-28T09:58:18Z beach: I mean, that way, the input would be preserved in a structured way, so as to allow maximum flexibility later on.
2014-12-28T09:58:36Z Ainieco joined #lisp
2014-12-28T09:58:38Z Ainieco: hello
2014-12-28T09:58:53Z beach: ... whereas an input processor with a some macro functionality would lose some information when "macros" are expanded.
2014-12-28T09:58:59Z beach: Hello Ainieco.
2014-12-28T09:59:02Z yenda quit (Ping timeout: 265 seconds)
2014-12-28T10:00:41Z Shinmera: My thought so far is as follows: Any parser constructs an AST out of the document that is a direct mirror. That AST is done in our document format. That way parsing really only really has to care about lexing. Then, any component in our format might have one or more ways of being "expanded" and anyone can add new expansions to a component. You then direct which kinds of output components you can provide in your
2014-12-28T10:00:43Z Shinmera: output and the system either figures out automatically which expansions to pick due to the necessary constraints on target components, or through some user guidance in selecting the proper expansions.
2014-12-28T10:01:25Z beach: Sounds great to me.
2014-12-28T10:01:40Z Shinmera: Right, yes, that's basically what you meant but a bit more specific.
2014-12-28T10:01:43Z beach: Some CLOS multiple dispatch might come in handy.
2014-12-28T10:02:13Z beach: Like output processors that specialize both on the construct and the type of output.
2014-12-28T10:02:29Z axion: i have an abstraction library with a defmethod. it is called this using all arguments. i now want to write a high-level :after method using only some of the arguments. is there a better way than (declare (ignore argument))? i don't want my users to deal with this.
2014-12-28T10:03:50Z Shinmera: beach: indeed. As I said, I haven't been able to think of a good, specific way of doing this, but the general idea is worked out.
2014-12-28T10:04:13Z beach: Shinmera: It sounds like you have the right ideas, which is a good start.
2014-12-28T10:04:24Z Shinmera: As usual in CL there's so many ways to go about it, that finding the right one is the issue. :)
2014-12-28T10:04:34Z beach: Indeed.
2014-12-28T10:05:11Z tharugrim quit (Ping timeout: 256 seconds)
2014-12-28T10:06:17Z Shinmera: The really nice thing about this is that we would get a system similar to TeX' packages, but portable for all input/outputs
2014-12-28T10:06:23Z tharugrim joined #lisp
2014-12-28T10:07:00Z beach: Shinmera: I am beginning to understand where you are going with this.
2014-12-28T10:07:02Z beach: Very nice.
2014-12-28T10:07:19Z zadock joined #lisp
2014-12-28T10:07:30Z beach: So for output, are you also thinking that each type of output (PDF, whatever) would have a subset of the document classes etc that it can handle, and that there will be specified translators from the full set to a subset for each type of output?
2014-12-28T10:07:44Z Shinmera: That's the idea, yes.
2014-12-28T10:07:54Z beach: Got it.
2014-12-28T10:08:02Z Shinmera: If the system can't find any way to get the right target component set it'll have to error.
2014-12-28T10:08:32Z beach: Yes, and client code that needs a new type of output will have to supply methods on specified generic functions, right?
2014-12-28T10:09:10Z Shinmera: Well, that's already a bit more specific than I'm willing to go right now
2014-12-28T10:09:13Z Shinmera: But generally, yes.
2014-12-28T10:09:19Z beach: OK.
2014-12-28T10:10:11Z beach: Would this also be the mechanism to handle "semantic markup"?
2014-12-28T10:10:23Z Shinmera: I'm glad we finally talked about this, things are getting a bit clearer in my head too.
2014-12-28T10:10:35Z Shinmera: I'm not sure what you mean by that
2014-12-28T10:11:09Z beach: Like, client code would define new constructs for whatever they think is important, and the general mechanism would translate those to "italic" or whatever.
2014-12-28T10:11:52Z beach: ... like when the Common Lisp standard defines \lambda-list-keyword{...}.
2014-12-28T10:11:54Z Shinmera: In that simple case I'd say you just subclass the "italic" markup.
2014-12-28T10:12:22Z beach: Hmm.  Not necessarily a good idea, since it might be bold on some other output devices, our underlined on some others.
2014-12-28T10:12:23Z Shinmera: But if you don't want to subclass you'd provide an expander function that turns it into an italic component, yes.
2014-12-28T10:12:46Z beach: OK, I see.
2014-12-28T10:12:52Z Shinmera: Well, what exactly it is in this case is a question of what the user wants
2014-12-28T10:13:13Z beach: As long as the other way is available too, no problem.
2014-12-28T10:13:19Z Shinmera: If he really only wants an alias, then subclassing would be it.
2014-12-28T10:13:31Z beach: Yes, I understand.
2014-12-28T10:14:37Z beach: I am looking forward to seeing your progress.  Your ideas sound very exciting.
2014-12-28T10:15:05Z Shinmera: They are, but I'm trying to hold my excitement back so I don't run into exactly what eudoxia did.
2014-12-28T10:15:53Z beach: I understand.
2014-12-28T10:16:23Z beach: Now that I know what you have in mind, I'll give it some thought myself and try to give you some input.
2014-12-28T10:16:56Z Shinmera: I also still have Radiance to worry about, but I just cleared the last big conundrum in its design (that was stuck for over half a year) yesterday, so hopefully I'll have more time for this soon.
2014-12-28T10:17:31Z beach: Wow, that sounds like great progress as well.
2014-12-28T10:17:48Z Shinmera: It is a big relief, yes.
2014-12-28T10:18:12Z Shinmera: What's left now is some janitorial things and writing the full specification for it. After that it'll finally be release-ready.
2014-12-28T10:18:57Z Shinmera: I hope that during this I finally figure out how to describe it accurately without having to resort to buzzwords :)
2014-12-28T10:19:25Z josemanuel joined #lisp
2014-12-28T10:19:41Z beach: Heh, that would be nice! :)
2014-12-28T10:21:52Z pnpuff joined #lisp
2014-12-28T10:22:18Z defaultxr quit (Quit: gnight)
2014-12-28T10:22:43Z beach: axion: A lot of what you wrote does not make sense.  What is a "library with a defmethod"?  Is that all there is to the library, a single DEFMETHOD form?  You wrote "it is called this using all arguments", but that sentence is not grammatical.  Furthermore, every time something is called, all arguments are of course used (passed) to whatever is called.  And, you can't call a "defmethod", nor a method.  You can call a generic functi
2014-12-28T10:22:43Z beach: So you need to explain a bit more.
2014-12-28T10:23:12Z bulloLisp quit (Quit: ERC Version 5.3 (IRC client for Emacs))
2014-12-28T10:23:17Z Shinmera: beach: your message got cut off at "You can call a generic functi"
2014-12-28T10:23:18Z Ainieco: i still don't quite understand why is test there if it's "real" hash table http://www.lispworks.com/documentation/HyperSpec/Body/f_mk_has.htm, per my understanding hash table works by computing hash for key and then getting value by hash
2014-12-28T10:23:22Z Ainieco: so why test is there? why should it care if two values are equal using user provided function, it doesn't makes sense to me(it would if it accepted user provided *hashing* function, not test)
2014-12-28T10:23:47Z beach: axion: You can call a generic function.  So you need to explain a bit more.
2014-12-28T10:23:55Z Shinmera: Ainieco: how would you make a hash table for strings if the test were fixed to eql?
2014-12-28T10:24:34Z beach: Ainieco: It is used to compare keys, not values in the table.
2014-12-28T10:24:44Z Ainieco: Shinmera: i'll compute hash for string which will be integer of something and go from there
2014-12-28T10:24:50Z Grue`: Ainieco: there are different hash functions for various :test values
2014-12-28T10:25:02Z manuel__ quit (Quit: manuel__)
2014-12-28T10:25:04Z beach: Ainieco: Two keys can give the same hash value, so the library needs to distinguish between them.
2014-12-28T10:25:32Z Shinmera: Ainieco: So you want everyone who ever wants a string hash table to write their own hashing function? Harsh.
2014-12-28T10:25:58Z axion: beach: nevermind. i resorted to using keywords in the generic function, and just using an empty &key specifier instead of unused arguments in the methods
2014-12-28T10:26:30Z beach: OK.
2014-12-28T10:27:22Z Ainieco: beach: it's kind of fuzzy to me, if it gives same hash values it should treat it as same objects, why test is further?
2014-12-28T10:27:34Z Ainieco: test it*
2014-12-28T10:27:47Z Shinmera: Equality is difficult.
2014-12-28T10:28:27Z Ainieco: Shinmera: 1 = 1 easy :), equal hash - equal data, why complicate it?
2014-12-28T10:28:27Z soggybread: Ainieco: every hash function has hash collisions (by universal property of hash functions) - so different values will give same hash values
2014-12-28T10:28:40Z Shinmera: Anarch: because "a" not always = "a"
2014-12-28T10:28:43Z Grue`: eql hash of string "abcd" is different from eql hash of separately created string "abcd"
2014-12-28T10:28:43Z Ainieco: soggybread: not every, there is perfect hash functions
2014-12-28T10:28:45Z gambyte quit (Quit: Leaving)
2014-12-28T10:28:46Z Shinmera: *Ainieco
2014-12-28T10:29:12Z Grue`: but equal hash produces identical results
2014-12-28T10:32:44Z Grue`: also the domain of hash function is always larger than the set of its values, so by pigeonhole principle there must be collisions
2014-12-28T10:34:38Z beach: Ainieco: That's not how it works.  Hash functions have "collisions" (unless we talk perfect hashing) so that several objects have the same hash code.  To distinguish between different keys with the same hash value, you need to know how to compare them.
2014-12-28T10:34:40Z Ainieco: okay, if it used for resolving collisions why can't i use eql for string->whatever hash having that hash contains 'a' and 'b' keys and there is no collisions?
2014-12-28T10:34:41Z mvilleneuve joined #lisp
2014-12-28T10:36:41Z soggybread: Ainieco: how do you know there is no collisions given non-perfect hash function?
2014-12-28T10:37:37Z soggybread: Ainieco: You can query table for value 'c' which collides with 'a' or 'b'
2014-12-28T10:39:36Z Ainieco: soggybread: it doesn't collides, i don't believe that say sbcl has such hashing function iml that makes 'a' and 'b' collide, there is no point in such hash table becuase it's O(N)
2014-12-28T10:40:33Z Ainieco: gonna look at how it's implemented there since it looks like i'm too dumb to understand explanations :)
2014-12-28T10:41:18Z soggybread: Ainieco: it will always collide, that's the point of hashing
2014-12-28T10:41:57Z soggybread: Ainieco: you just come up with numbers that give you sufficiently low probability of collision and it works
2014-12-28T10:42:07Z hiyosi quit (Quit: Textual IRC Client: www.textualapp.com)
2014-12-28T10:42:38Z hiyosi joined #lisp
2014-12-28T10:42:47Z hiyosi quit (Client Quit)
2014-12-28T10:42:57Z soggybread: Ainieco: see what beach wrote, read about hash functions
2014-12-28T10:45:09Z soggybread: even better, Grue` about domains/values
2014-12-28T10:49:53Z Ainieco: it just struck me as odd because in every other language you either have to implement your own hash function for key type or it's given for free(like in ruby) and i never saw anyone bothering comparing colliding keys
2014-12-28T10:50:26Z Shinmera: But in CL it is given for free with the test arg??
2014-12-28T10:51:57Z zadock quit (Ping timeout: 250 seconds)
2014-12-28T10:51:59Z Ainieco: Shinmera: yup, and that is odd :) because it's not like in every other 2 category of hash table impls i've seen
2014-12-28T10:52:13Z Shinmera: I don't see how that is odd at all.
2014-12-28T10:52:39Z soggybread: Ainieco: "Two objects refer to the same hash key when their hash value is identical and the two objects are eql? to each other."
2014-12-28T10:52:53Z soggybread: Ainieco: "A user-defined class may be used as a hash key if the hash and eql? methods are overridden to provide meaningful behavior. By default, separate instances refer to separate hash keys."
2014-12-28T10:53:06Z soggybread: so, it just uses some default operator
2014-12-28T10:53:12Z soggybread: and CL gives you choice
2014-12-28T10:53:40Z soggybread: (quotes from ruby doc)
2014-12-28T10:54:25Z pnpuff left #lisp
2014-12-28T10:55:34Z Grue`: most languages have less comparison operators than CL
2014-12-28T10:55:42Z soggybread: Ainieco: do you have an answer to "why do you need define not only 'hash' method but also 'eql?' method?" ;)
2014-12-28T10:56:13Z zadock joined #lisp
2014-12-28T10:56:21Z Grue`: like, python has only "==" and "is" and only has hashtable for ==
2014-12-28T11:03:29Z gabriel_laddel quit (Ping timeout: 258 seconds)
2014-12-28T11:04:01Z nikki93_ joined #lisp
2014-12-28T11:04:35Z PaleFire joined #lisp
2014-12-28T11:04:38Z Ainieco: soggybread: nope, having equality function + hash function still doesn't make much sense because hashing function is a mean to provide distinct keys for distinct things
2014-12-28T11:04:41Z Ainieco: and if it's not perfect hashing there will be collisions, same with other equality functions, if :test is there for fallback then why don't we have fallback for fallback
2014-12-28T11:04:45Z Ainieco: when :test finds multiple things(collides), maybe having :test1, :test2, :test3, :testN will provide more choice?
2014-12-28T11:05:01Z josemanuel quit (Quit: Saliendo)
2014-12-28T11:05:09Z Ainieco just too stupid to understand
2014-12-28T11:06:27Z manuel__ joined #lisp
2014-12-28T11:07:51Z nikki93 quit (Ping timeout: 272 seconds)
2014-12-28T11:11:11Z Karl_Dscc joined #lisp
2014-12-28T11:13:20Z soggybread: Ainieco: http://pastebin.com/NZQHPrz0 my first ruby program :)
2014-12-28T11:16:27Z pnpuff joined #lisp
2014-12-28T11:17:46Z gabriel_laddel joined #lisp
2014-12-28T11:17:54Z gabriel_laddel quit (Changing host)
2014-12-28T11:17:54Z gabriel_laddel joined #lisp
2014-12-28T11:18:00Z Ainieco: soggybread: thank you for patience! reading this http://en.wikipedia.org/wiki/Hash_table#Collision_resolution one currently to shrug off that cofusion of mine around hashes
2014-12-28T11:19:01Z Ainieco: yay! i finally got it
2014-12-28T11:19:17Z Ainieco: it just clicked
2014-12-28T11:19:19Z soggybread: Ainieco: you just need to understand that when you are have large possible domain of values used as keys (e.g. all possible "strings") and limited and much smaller range of possible hash values (64bit integer), you will always have collisions
2014-12-28T11:19:24Z soggybread: Ainieco: yay :)
2014-12-28T11:19:34Z Ainieco: soggybread: Grue` beach Shinmera thank you guys a lot!
2014-12-28T11:19:41Z zadock quit (Ping timeout: 250 seconds)
2014-12-28T11:20:13Z oleo is now known as Guest96167
2014-12-28T11:20:35Z Ainieco: really impressed how kind and patiently your tolerated my ignorance
2014-12-28T11:21:04Z munksgaard quit (Ping timeout: 250 seconds)
2014-12-28T11:21:59Z oleo__ joined #lisp
2014-12-28T11:22:36Z munksgaard joined #lisp
2014-12-28T11:23:31Z Shinmera: As long as you aren't annoying, you'll find that lots of people will gladly help out.
2014-12-28T11:23:37Z Guest96167 quit (Ping timeout: 265 seconds)
2014-12-28T11:24:40Z oleo__ quit (Read error: Connection reset by peer)
2014-12-28T11:25:29Z oleo__ joined #lisp
2014-12-28T11:25:49Z oleo__ is now known as oleo
2014-12-28T11:27:16Z munksgaard quit (Ping timeout: 244 seconds)
2014-12-28T11:29:31Z Gmind joined #lisp
2014-12-28T11:32:53Z wbooze joined #lisp
2014-12-28T11:32:56Z manuel__ quit (Quit: manuel__)
2014-12-28T11:33:52Z zadock joined #lisp
2014-12-28T11:40:27Z pt1 quit (Remote host closed the connection)
2014-12-28T11:42:27Z ehu joined #lisp
2014-12-28T11:44:04Z hardenedapple joined #lisp
2014-12-28T11:47:39Z tadni quit (Remote host closed the connection)
2014-12-28T11:49:28Z pt1 joined #lisp
2014-12-28T11:49:35Z zadock quit (Ping timeout: 250 seconds)
2014-12-28T11:50:17Z hitecnologys quit (Ping timeout: 245 seconds)
2014-12-28T11:52:46Z tadni joined #lisp
2014-12-28T11:52:56Z hitecnologys joined #lisp
2014-12-28T11:57:28Z admg joined #lisp
2014-12-28T11:58:06Z tadni quit (Remote host closed the connection)
2014-12-28T11:59:57Z pt1 quit (Remote host closed the connection)
2014-12-28T12:00:34Z Beetny quit (Ping timeout: 255 seconds)
2014-12-28T12:04:13Z _m___ quit (Ping timeout: 252 seconds)
2014-12-28T12:08:49Z _m___ joined #lisp
2014-12-28T12:12:36Z Ainieco: why one might want to (:export #:my-fun) vs (:export :my-fun)?
2014-12-28T12:14:33Z Grue`: the first one doesn't intern the symbol my-fun into keywords package
2014-12-28T12:14:37Z mishoo joined #lisp
2014-12-28T12:14:45Z Zhivago: Some people dislike populating the keyword symbol space unneccesarily.
2014-12-28T12:16:28Z Ainieco: Zhivago: Grue` i think there was some practical advantage for first one because of slime, but i don't remember details
2014-12-28T12:16:56Z Grue`: so something like :my- wouldn't autocomplete to :my-fun
2014-12-28T12:17:31Z Ainieco: Grue`: i think it was somehow connected to code realoading, but i might be wrong, trying to find it now
2014-12-28T12:18:07Z Grue`: there should be no difference regarding the code itself
2014-12-28T12:19:21Z Ainieco: okay, must be false memory then, it was really long time since i last touched common lisp, i think it's 3 years already
2014-12-28T12:20:26Z ehu: Ainieco: any mention of #:my-fun is unequal to any other mention of #:my-fun because the symbol isn't interned, meaning an ad-hoc symbol is being created.
2014-12-28T12:22:20Z MutSbeta joined #lisp
2014-12-28T12:26:59Z Shinmera: In the case of defpackage it won't matter since it uses STRING on what you pass.
2014-12-28T12:27:56Z akkad: 92M of compressed json being read. sbcl: 53s, lw 64bit 82s, ccl 80s
2014-12-28T12:27:58Z psy joined #lisp
2014-12-28T12:28:22Z akkad: well 23k files of compressed json
2014-12-28T12:28:47Z pnpuff quit (Ping timeout: 252 seconds)
2014-12-28T12:28:49Z ehu: sounds like it'll depend a lot on the OS's ability to open files quickly too.
2014-12-28T12:29:08Z wasamasa: would you want to use an operating system that can't do that?
2014-12-28T12:29:30Z ehu: i'm talking about the timing measurements.
2014-12-28T12:29:39Z ehu: if any of these was on a different OS
2014-12-28T12:29:47Z ehu: the timings probably can't be compared.
2014-12-28T12:29:48Z akkad: 3->9 seconds of system time
2014-12-28T12:30:01Z ehu: ah. ok.
2014-12-28T12:30:22Z akkad: quite consistent but a crap benchmark no doubt.
2014-12-28T12:31:00Z kcj quit (Read error: Connection reset by peer)
2014-12-28T12:31:25Z ehu: depends on what you want to benchmark :-) If you're benchmarking the ability to read json, then no doubt it's an indicator.
2014-12-28T12:31:54Z akkad: well it's OSX as well and so I expect it to be slower in some areas
2014-12-28T12:33:59Z hiroakip quit (Ping timeout: 272 seconds)
2014-12-28T12:35:57Z edgar-rft quit (Quit: the consequences are unspecified)
2014-12-28T12:38:22Z angavrilov joined #lisp
2014-12-28T12:39:23Z tesuji quit (Ping timeout: 240 seconds)
2014-12-28T12:40:58Z zyaku joined #lisp
2014-12-28T12:43:29Z tesuji joined #lisp
2014-12-28T12:55:42Z enitiz joined #lisp
2014-12-28T12:57:00Z ASau joined #lisp
2014-12-28T12:57:41Z tesuji quit (Ping timeout: 244 seconds)
2014-12-28T13:04:03Z ASau quit (Quit: off)
2014-12-28T13:17:19Z Bicyclidine quit (Ping timeout: 245 seconds)
2014-12-28T13:18:17Z tesuji joined #lisp
2014-12-28T13:20:41Z eudoxia joined #lisp
2014-12-28T13:24:19Z mvilleneuve quit (Quit: This computer has gone to sleep)
2014-12-28T13:31:44Z ehu quit
2014-12-28T13:32:18Z _m___ quit (Remote host closed the connection)
2014-12-28T13:36:40Z akkad: https://gist.github.com/7674d6b4c51e7d75da5b bench crap
2014-12-28T13:44:13Z wbooze quit (Quit: none)
2014-12-28T13:45:23Z EvW joined #lisp
2014-12-28T13:47:44Z towodo joined #lisp
2014-12-28T13:49:09Z Bicyclidine joined #lisp
2014-12-28T13:51:37Z hiroakip joined #lisp
2014-12-28T13:54:06Z kcj joined #lisp
2014-12-28T13:55:57Z BitPuffin joined #lisp
2014-12-28T13:55:59Z PaleFire quit (Remote host closed the connection)
2014-12-28T13:56:31Z PaleFire joined #lisp
2014-12-28T14:01:05Z MoALTz_ quit (Quit: brb)
2014-12-28T14:01:20Z MoALTz joined #lisp
2014-12-28T14:02:59Z Patzy quit (Ping timeout: 244 seconds)
2014-12-28T14:03:58Z Patzy joined #lisp
2014-12-28T14:04:33Z egp_ quit (Remote host closed the connection)
2014-12-28T14:06:41Z akkad: what is used these days for resolve-host-ipaddr? clocc still used for port? or is it in quicklisp?
2014-12-28T14:10:10Z hiroakip quit (Remote host closed the connection)
2014-12-28T14:10:58Z bcoburn joined #lisp
2014-12-28T14:11:43Z bcoburn quit (Remote host closed the connection)
2014-12-28T14:11:59Z hiroakip joined #lisp
2014-12-28T14:14:02Z hekmek joined #lisp
2014-12-28T14:14:18Z zygentoma joined #lisp
2014-12-28T14:17:44Z Bicyclidine quit (Ping timeout: 245 seconds)
2014-12-28T14:18:44Z oudeis quit (Quit: This computer has gone to sleep)
2014-12-28T14:18:59Z oudeis joined #lisp
2014-12-28T14:19:16Z oudeis quit (Client Quit)
2014-12-28T14:19:34Z aleamb joined #lisp
2014-12-28T14:24:51Z bcoburn joined #lisp
2014-12-28T14:25:29Z huza joined #lisp
2014-12-28T14:27:02Z gabriel_laddel quit (Ping timeout: 258 seconds)
2014-12-28T14:27:46Z bcoburn_ joined #lisp
2014-12-28T14:27:54Z bcoburn_ quit (Client Quit)
2014-12-28T14:33:00Z k-dawg joined #lisp
2014-12-28T14:33:09Z gabriel_laddel joined #lisp
2014-12-28T14:33:18Z gabriel_laddel quit (Changing host)
2014-12-28T14:33:18Z gabriel_laddel joined #lisp
2014-12-28T14:36:24Z arpunk joined #lisp
2014-12-28T14:41:00Z gabriel_laddel quit (Remote host closed the connection)
2014-12-28T14:44:41Z Bicyclidine joined #lisp
2014-12-28T14:44:47Z ehu joined #lisp
2014-12-28T15:01:03Z akkad: net4cl/iolib/cl-async all work on some platforms/implementations, but not all of them.,
2014-12-28T15:02:06Z kcj quit (Read error: Connection reset by peer)
2014-12-28T15:02:31Z davorb joined #lisp
2014-12-28T15:03:49Z dkcl quit (Ping timeout: 256 seconds)
2014-12-28T15:06:26Z huza quit (Read error: Connection reset by peer)
2014-12-28T15:10:27Z dkcl joined #lisp
2014-12-28T15:12:17Z fe[nl]ix: akkad: what operating systems are you interested in ?
2014-12-28T15:12:27Z akkad: OSX
2014-12-28T15:12:47Z akkad: iolib depends on libfixposix, written by the same author it looks like.
2014-12-28T15:13:06Z bcoburn quit (Remote host closed the connection)
2014-12-28T15:13:19Z akkad: just falling back to implementation specific methods and #+sbcl/#+lispworks etc
2014-12-28T15:13:58Z pppp2 quit (Quit: Leaving)
2014-12-28T15:14:32Z pacon joined #lisp
2014-12-28T15:14:51Z loke_ joined #lisp
2014-12-28T15:16:33Z Gmind1 joined #lisp
2014-12-28T15:17:08Z nell joined #lisp
2014-12-28T15:17:26Z fantazo quit (Quit: Verlassend)
2014-12-28T15:17:54Z oudeis joined #lisp
2014-12-28T15:19:07Z paul0``` quit (Ping timeout: 256 seconds)
2014-12-28T15:19:37Z Gmind quit (Ping timeout: 240 seconds)
2014-12-28T15:19:37Z bcoburn joined #lisp
2014-12-28T15:21:39Z ehu quit (Ping timeout: 264 seconds)
2014-12-28T15:25:20Z LiamH joined #lisp
2014-12-28T15:25:59Z oudeis quit (Read error: Connection reset by peer)
2014-12-28T15:26:38Z ehu joined #lisp
2014-12-28T15:32:40Z oudeis joined #lisp
2014-12-28T15:34:42Z akkad: usocket::get-host-by-address appears to be the most portable thing I can find
2014-12-28T15:36:01Z fe[nl]ix: akkad: as fas as I know, iolib works on OSX
2014-12-28T15:36:44Z pt1 joined #lisp
2014-12-28T15:38:16Z dagnachew joined #lisp
2014-12-28T15:38:43Z Ethan- quit (Ping timeout: 258 seconds)
2014-12-28T15:41:52Z protist quit (Quit: Konversation terminated!)
2014-12-28T15:42:00Z Xach joined #lisp
2014-12-28T15:45:08Z hekmek quit (Quit: Verlassend)
2014-12-28T15:51:02Z oudeis quit (Ping timeout: 250 seconds)
2014-12-28T15:51:49Z oudeis joined #lisp
2014-12-28T15:52:02Z PaleFire quit (Remote host closed the connection)
2014-12-28T15:54:17Z oudeis quit (Read error: Connection reset by peer)
2014-12-28T15:55:46Z bullone joined #lisp
2014-12-28T15:55:55Z manuel__ joined #lisp
2014-12-28T15:58:12Z oudeis joined #lisp
2014-12-28T15:58:22Z pacon is now known as pacon2
2014-12-28T15:58:56Z pacon2 is now known as pacon3
2014-12-28T15:59:04Z pacon3 is now known as pacon4
2014-12-28T16:00:37Z pacon4 is now known as pacon
2014-12-28T16:00:52Z gravicappa quit (Ping timeout: 255 seconds)
2014-12-28T16:03:41Z eudoxia quit (Quit: Leaving)
2014-12-28T16:05:28Z pacon quit (Disconnected by services)
2014-12-28T16:05:55Z pacon joined #lisp
2014-12-28T16:06:12Z gravicappa joined #lisp
2014-12-28T16:06:31Z Adlai` joined #lisp
2014-12-28T16:07:51Z Adlai quit (Ping timeout: 250 seconds)
2014-12-28T16:08:58Z admg quit (Quit: Laptop gone to sleep...)
2014-12-28T16:09:16Z oudeis quit (Ping timeout: 265 seconds)
2014-12-28T16:09:43Z mvilleneuve joined #lisp
2014-12-28T16:11:21Z mrkkrp joined #lisp
2014-12-28T16:12:07Z attila_lendvai joined #lisp
2014-12-28T16:12:07Z attila_lendvai quit (Changing host)
2014-12-28T16:12:07Z attila_lendvai joined #lisp
2014-12-28T16:12:15Z Petit_Dejeuner_ joined #lisp
2014-12-28T16:12:44Z egp_ joined #lisp
2014-12-28T16:19:26Z k-dawg quit (Quit: This computer has gone to sleep)
2014-12-28T16:20:45Z dagnachew quit (Quit: WeeChat 1.0.1)
2014-12-28T16:20:50Z stassats joined #lisp
2014-12-28T16:24:12Z oudeis joined #lisp
2014-12-28T16:27:52Z ASau joined #lisp
2014-12-28T16:27:58Z EvW quit (Ping timeout: 244 seconds)
2014-12-28T16:29:19Z oudeis quit (Read error: Connection reset by peer)
2014-12-28T16:31:14Z kcj joined #lisp
2014-12-28T16:36:04Z oudeis joined #lisp
2014-12-28T16:36:14Z Adlai` is now known as adlai
2014-12-28T16:37:54Z pacon quit (Read error: No route to host)
2014-12-28T16:41:05Z pnpuff joined #lisp
2014-12-28T16:46:28Z antonv joined #lisp
2014-12-28T16:46:37Z oudeis quit (Ping timeout: 240 seconds)
2014-12-28T16:48:33Z oudeis joined #lisp
2014-12-28T16:50:35Z ehu quit (Ping timeout: 252 seconds)
2014-12-28T16:51:52Z rurumate joined #lisp
2014-12-28T16:51:55Z rurumate: I'm getting this error when doing M-x slime: unknown &KEY argument: :CODING-SYSTEM
2014-12-28T16:52:24Z rurumate: there is probably something wrong with my emacs/slime
2014-12-28T16:52:34Z stassats: what's in slime-lisp-implementations?
2014-12-28T16:52:37Z transfinite quit (Ping timeout: 256 seconds)
2014-12-28T16:52:37Z stassats: the emacs variable
2014-12-28T16:53:28Z stassats: hint: C-h v
2014-12-28T16:53:29Z rurumate: ((sbcl ("/usr/bin/sbcl") :coding-system utf-8-unix))
2014-12-28T16:53:50Z stassats: ok, and if you remove it?
2014-12-28T16:53:54Z ellis-a joined #lisp
2014-12-28T16:54:06Z Ven joined #lisp
2014-12-28T16:54:07Z rurumate: then there is a different error, one moment
2014-12-28T16:55:03Z Grue`: try without it, but with (setq slime-net-coding-system 'utf-8-unix)
2014-12-28T16:55:52Z stassats: slime no longer cares about the coding system
2014-12-28T16:56:19Z rurumate: http://pastebin.com/k8BcFdiR
2014-12-28T16:56:54Z stassats: rurumate: what slime version?
2014-12-28T16:56:55Z rurumate: I'm getting the same error, apparently iso-latin-1-unix is passed in from somewhere
2014-12-28T16:57:10Z stassats: it seems like you updated slime but didn't restart emacs
2014-12-28T16:57:21Z rurumate: 20100404.1
2014-12-28T16:57:32Z stassats: phew
2014-12-28T16:57:33Z stassats: that's old
2014-12-28T16:57:33Z fsvehla quit (Quit: fsvehla)
2014-12-28T16:57:59Z rurumate: I don't know why I have that old version, I just installed it from elpa yesterday
2014-12-28T16:58:10Z rurumate: M-x package-install slime
2014-12-28T16:58:24Z stassats: did you have it installed via apt-get or rpm?
2014-12-28T16:58:39Z rurumate: oddly swank-loader.lisp was missing after installation
2014-12-28T16:58:49Z stassats: that suggests that you did
2014-12-28T16:59:24Z stassats: can you do apt-get remove --purge slime?
2014-12-28T16:59:37Z rurumate: no, it was installed via emacs package-install
2014-12-28T16:59:45Z stassats: rurumate: for the first time?
2014-12-28T16:59:52Z rurumate: I can remove and reinstall using that mechanism, but I've already done that
2014-12-28T17:00:09Z stassats: you never had slime installed in any form?
2014-12-28T17:00:13Z rurumate: for the first time as far as I know
2014-12-28T17:00:14Z rurumate: I have cider
2014-12-28T17:00:17Z Grue`: is that the version its showing in the package manager?
2014-12-28T17:00:56Z pnpuff left #lisp
2014-12-28T17:01:00Z rurumate: package-list-packages shows slime version 20100404.1
2014-12-28T17:01:04Z Grue`: cause that version is so old, emacs package manager hasn't existed at the time
2014-12-28T17:01:34Z rurumate: I'll remove it again now, usind package-list-packages
2014-12-28T17:02:59Z rurumate: it's gone now, but it will be the same version if I reinstall via package-install
2014-12-28T17:03:14Z rurumate: I've done it just a few hours ago
2014-12-28T17:04:05Z stassats: i never used this package thing in emacs, package-list-packages doesn't even show slime for me
2014-12-28T17:04:19Z rurumate: it shows it when it's installed
2014-12-28T17:04:36Z rurumate: so should I install slime via apt-get?
2014-12-28T17:04:41Z stassats: no
2014-12-28T17:04:51Z stassats: quicklisp is the tried and true way
2014-12-28T17:05:20Z hiroakip quit (Ping timeout: 265 seconds)
2014-12-28T17:06:46Z rurumate: thanks stassats
2014-12-28T17:07:01Z ellis-a left #lisp
2014-12-28T17:07:13Z stassats: the only thing coding-system is used nowadays is for out of band REPL output streams
2014-12-28T17:07:23Z stassats: a non default feature
2014-12-28T17:07:34Z pt1 quit (Remote host closed the connection)
2014-12-28T17:07:44Z ASau quit (Ping timeout: 245 seconds)
2014-12-28T17:08:13Z kcj quit (Remote host closed the connection)
2014-12-28T17:11:50Z zyaku: rurumate: which elpa sites do you use? I use MELPA and my slime version is 20141224.705
2014-12-28T17:13:05Z dandersen is now known as dickle
2014-12-28T17:13:11Z dagnachew joined #lisp
2014-12-28T17:14:28Z dickle quit (Changing host)
2014-12-28T17:14:28Z dickle joined #lisp
2014-12-28T17:16:05Z Zamenhof joined #lisp
2014-12-28T17:18:34Z _5kg quit (Ping timeout: 250 seconds)
2014-12-28T17:20:26Z hiroakip joined #lisp
2014-12-28T17:21:19Z oudeis quit (Quit: This computer has gone to sleep)
2014-12-28T17:21:19Z dkcl quit (Read error: Connection reset by peer)
2014-12-28T17:21:19Z dickle quit (Read error: Connection reset by peer)
2014-12-28T17:21:31Z kapil__ quit (Quit: Connection closed for inactivity)
2014-12-28T17:24:29Z dandersen joined #lisp
2014-12-28T17:24:42Z dandersen quit (Changing host)
2014-12-28T17:24:42Z dandersen joined #lisp
2014-12-28T17:31:23Z EvW joined #lisp
2014-12-28T17:35:00Z urandom__ joined #lisp
2014-12-28T17:42:18Z admg joined #lisp
2014-12-28T17:43:04Z shka joined #lisp
2014-12-28T17:43:10Z shka: good evening
2014-12-28T17:43:41Z shka: does common lisp has any pointless discussions about tabs vs spaces around?
2014-12-28T17:44:02Z Bicyclidine: we mostly just do whatever emacs tells us to.
2014-12-28T17:44:11Z stassats: shka: just use spaces
2014-12-28T17:45:33Z rurumate: zyaku: great stuff, I was using marmalade, now the problem seems gont
2014-12-28T17:46:54Z shka: right
2014-12-28T17:47:14Z shka: since 99% of code i seen looked like just default emacs
2014-12-28T17:47:17Z MoALTz quit (Quit: Leaving)
2014-12-28T17:48:08Z stassats: well, the default emacs is to use tabs
2014-12-28T17:48:15Z zyaku: rurumate: Yeah, I've had problems with marmalade in the past. I'm glad that your issue is fixed.
2014-12-28T17:48:17Z stassats: i specifically have (setq-default indent-tabs-mode nil)
2014-12-28T17:51:18Z Grue`: Lisp style is to indent by 2 spaces, which is usually less than a tab
2014-12-28T17:52:36Z oudeis joined #lisp
2014-12-28T17:52:45Z nikki93_ quit (Remote host closed the connection)
2014-12-28T17:59:45Z innertracks joined #lisp
2014-12-28T18:00:36Z zajn joined #lisp
2014-12-28T18:00:42Z dagnachew quit (Quit: WeeChat 1.0.1)
2014-12-28T18:01:19Z Petit_Dejeuner_ quit (Ping timeout: 258 seconds)
2014-12-28T18:02:17Z _5kg joined #lisp
2014-12-28T18:02:54Z dagnachew joined #lisp
2014-12-28T18:04:00Z |3b|: lisp style is to indent according to context, which is usually not a multiple of some fixed amount like "2 spaces", so even if you change tab size you will still need to mix tabs/spaces
2014-12-28T18:04:19Z shka: uh
2014-12-28T18:04:27Z manuel__ quit (Quit: manuel__)
2014-12-28T18:04:34Z shka: i regret asking about that so let's quit the topic
2014-12-28T18:08:27Z ASau joined #lisp
2014-12-28T18:09:27Z nikki93 joined #lisp
2014-12-28T18:10:28Z juiko joined #lisp
2014-12-28T18:11:42Z ASau quit (Remote host closed the connection)
2014-12-28T18:12:45Z edgar-rft joined #lisp
2014-12-28T18:18:58Z Beltxarga joined #lisp
2014-12-28T18:22:17Z mvilleneuve quit (Quit: This computer has gone to sleep)
2014-12-28T18:27:23Z oudeis quit (Ping timeout: 272 seconds)
2014-12-28T18:29:12Z juiko quit (Read error: Connection reset by peer)
2014-12-28T18:29:51Z innertracks quit (Quit: innertracks)
2014-12-28T18:30:41Z spacebat quit (Ping timeout: 252 seconds)
2014-12-28T18:31:06Z spacebat joined #lisp
2014-12-28T18:33:33Z drdanmaku joined #lisp
2014-12-28T18:34:44Z nell quit (Quit: WeeChat 1.1-rc1)
2014-12-28T18:34:53Z flash- joined #lisp
2014-12-28T18:37:47Z atgreen quit (Ping timeout: 245 seconds)
2014-12-28T18:38:55Z posterdati300 quit (Quit: KVIrc 4.1.3 Equilibrium http://www.kvirc.net/)
2014-12-28T18:39:06Z innertracks joined #lisp
2014-12-28T18:41:34Z beach left #lisp
2014-12-28T18:44:29Z dagnachew quit (Quit: WeeChat 1.0.1)
2014-12-28T18:48:17Z tesuji quit (Ping timeout: 252 seconds)
2014-12-28T18:50:57Z zacharias joined #lisp
2014-12-28T18:51:02Z jumblerg joined #lisp
2014-12-28T18:51:24Z Beltxarga: hello, I'm looking for a way to send a raw HTTP packet (that I captured using Wireshark) to a webserver, using Common Lisp. Could anyone orient me?
2014-12-28T18:51:53Z stassats: http doesn't use packets
2014-12-28T18:52:07Z paul0``` joined #lisp
2014-12-28T18:52:27Z Beltxarga: sorry I'm a beginner in programming, AND networking :)
2014-12-28T18:52:43Z stassats: so, you have to describe in more detail what you are trying to do
2014-12-28T18:52:57Z Beltxarga: sure, no problem
2014-12-28T18:53:02Z BitPuffin quit (Ping timeout: 250 seconds)
2014-12-28T18:53:19Z p_l: you might want to replicate the stream containing the query from your pcap dump, but that means simply dumping it into text file, opening a socket to HTTP server and sending the stream over
2014-12-28T18:55:40Z Beltxarga: stassats: I would like to post a message on a forum that uses PHP. I did it using my web browser, and I captured the POST packet using Wireshark. Now I would like to replicate this programmatically using Common Lisp. I thought I could just feed this packet to something that would play the same role than my web browser. I might be wrong here.
2014-12-28T18:56:02Z stassats: minion: drakma
2014-12-28T18:56:03Z minion: drakma: No definition was found in the first 5 lines of http://www.cliki.net/drakma
2014-12-28T18:56:03Z hitecnologys: Beltxarga: you need to make HTTP request?
2014-12-28T18:56:17Z stassats: Beltxarga: use drakma, the http client
2014-12-28T18:57:01Z stassats: please don't spam
2014-12-28T18:58:33Z Beltxarga: stassats: oh no, I'm not spamming! I have been on this forum for 15 years :) I just want to explore Common Lisp. I have looked into drakma, but I'm not sure there is a way to feed it a raw 'packet'. If there is not, I guess I have to study how to pass the cookie, referer, parameters etc. right?
2014-12-28T18:58:52Z stassats: you wouldn't feed a raw packet, there's little sense in doing so
2014-12-28T18:59:07Z Beltxarga: hitecnologys: yes, I think so, a POST request
2014-12-28T18:59:29Z stassats: Beltxarga: show me the raw stream, i can show you how a drakma would look like
2014-12-28T18:59:42Z stassats: a drakma call
2014-12-28T18:59:57Z shka: Beltxarga: that is interesting
2014-12-28T19:00:10Z shka: i would expect novice hanging here for eyars
2014-12-28T19:00:15Z shka: *years
2014-12-28T19:00:25Z shka: welcome and happy hacking :)
2014-12-28T19:00:49Z Beltxarga: shka: thanks :) it's been quite straightforward actually so far, the community is great
2014-12-28T19:01:06Z Beltxarga: stassats: ok, thank you, I'm gonna export it
2014-12-28T19:02:05Z |3b| things if replaying the packet would successfully post, you probably shouldn't share it publicly (or else change login credentials after you do)
2014-12-28T19:02:15Z |3b|: *thinks
2014-12-28T19:02:37Z Beltxarga: yes |3b| I will probably just hide the cookie
2014-12-28T19:02:45Z hitecnologys: HTTP request might consist of more than one packet.
2014-12-28T19:02:47Z shka: btw, was anybody tried to use websocket lib?
2014-12-28T19:02:57Z hiroakip quit (Ping timeout: 240 seconds)
2014-12-28T19:03:07Z |3b| wrote one, but not used it much :/.
2014-12-28T19:03:14Z shka: :D
2014-12-28T19:03:31Z psy quit (Ping timeout: 256 seconds)
2014-12-28T19:04:03Z stassats: hitecnologys: we already established that http doesn't have any packets
2014-12-28T19:04:12Z shka: it is a bit pity that cl seems to be better suited for server side than any client side application
2014-12-28T19:04:40Z shka: yeah, http is stream based
2014-12-28T19:04:58Z hitecnologys: stassats: HTTP doesn't but TCP does. Since HTTP requests are translated to TCP packets, HTTP request might not be sent in one.
2014-12-28T19:05:22Z shka: this seems to be a fairly low level issue
2014-12-28T19:05:24Z p_l: shka: if you shell out money for LW, it becomes very suited for client-side too ;P
2014-12-28T19:05:56Z shka: p_l: give me few billions and i will make you state of art machine
2014-12-28T19:06:00Z Beltxarga: hitecnologys: in that case, if I'm not mistaken, a single 'packet' is sufficient to post a message on the forum
2014-12-28T19:06:01Z hitecnologys: shka: not really. If you capture HTTP requests with sniffer, you have to take that in count.
2014-12-28T19:06:16Z shka: hitecnologys: good point
2014-12-28T19:06:22Z Grue` quit (Remote host closed the connection)
2014-12-28T19:06:32Z stassats: you don't have to use tcp, but that's not the point
2014-12-28T19:06:49Z stassats: do we have to recite RFCs just to answer some simple questions?
2014-12-28T19:07:24Z hitecnologys: Probably not.
2014-12-28T19:07:28Z shka: p_l: steele concept of lisp chip seems to look extordinary
2014-12-28T19:07:47Z stassats: shka: there's very few reasons for lisp chips these days
2014-12-28T19:07:55Z bgs100 joined #lisp
2014-12-28T19:08:38Z shka: and it starts to look like register based machines have reached silicon limits
2014-12-28T19:08:39Z EvW quit (Ping timeout: 244 seconds)
2014-12-28T19:08:54Z shka: so maybe it's time to look for something different
2014-12-28T19:09:06Z shka: stassats: being cool is a perfectly fine reason ;-)
2014-12-28T19:09:25Z flash- quit (Ping timeout: 255 seconds)
2014-12-28T19:09:26Z stassats: it'll probably be hot, slow and inordinately expensive instead
2014-12-28T19:09:45Z stassats: never mind that there's no software for it
2014-12-28T19:10:31Z shka: why hot and slow?
2014-12-28T19:10:51Z Ven quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
2014-12-28T19:10:57Z stassats: "not cool"
2014-12-28T19:11:36Z stassats: it can't compete with established processes
2014-12-28T19:11:54Z shka: meeh
2014-12-28T19:11:57Z shka: :P
2014-12-28T19:12:18Z shka: obviously there are billions of dollars pumped into existing architectures
2014-12-28T19:12:21Z Beltxarga: stassats: actually I think I'm gonna study Drakma a bit more and come back with more specific questions
2014-12-28T19:14:28Z stassats: shka: those billions would better be spent on writing software
2014-12-28T19:14:35Z dagnachew joined #lisp
2014-12-28T19:17:10Z shka: stassats: and THEN you realize how much money ms spent on minecraft and skype ;]
2014-12-28T19:17:40Z stassats: those things are profitable
2014-12-28T19:18:24Z otwieracz: huh
2014-12-28T19:18:25Z dagnachew quit (Client Quit)
2014-12-28T19:18:39Z otwieracz: "microsoft", "skype" and "minecraft" on #lisp? :)
2014-12-28T19:19:02Z shka: otwieracz: that escalated quickly
2014-12-28T19:19:06Z otwieracz: :)
2014-12-28T19:19:19Z shka: stassats: i really don't think they are that profitable
2014-12-28T19:19:57Z shka: certainly $2.5 x 10^9 for a mojang was simply insane
2014-12-28T19:21:25Z Ven joined #lisp
2014-12-28T19:21:26Z otwieracz:  that will be cool to see prices everywhere written in scientific notation.
2014-12-28T19:22:05Z shka: well, i feel unease when writing billion
2014-12-28T19:22:17Z otwieracz: :)
2014-12-28T19:22:23Z shka: since not sure if speaker thinks in british or american english
2014-12-28T19:22:49Z otwieracz: Fun fact: here, in Poland, we have "milion", "miliard" and "bilion".
2014-12-28T19:22:59Z shka: i know bro, right :P
2014-12-28T19:23:09Z otwieracz: wait
2014-12-28T19:23:12Z shka: yup
2014-12-28T19:23:14Z otwieracz: I saw you on #lisp-pl, right?
2014-12-28T19:23:14Z otwieracz: ;)
2014-12-28T19:23:17Z shka: yeah
2014-12-28T19:23:19Z otwieracz: lol
2014-12-28T19:23:26Z otwieracz: Well.
2014-12-28T19:23:38Z otwieracz: I understand your concerns about billion :)
2014-12-28T19:23:47Z zajn quit
2014-12-28T19:23:53Z shka: anyway, assuming that we have 1 x 10^8 copies world wide
2014-12-28T19:24:06Z shka: it is still more than one thousand for every copy
2014-12-28T19:25:03Z Vivitron joined #lisp
2014-12-28T19:25:40Z nikki93 quit (Read error: Connection reset by peer)
2014-12-28T19:25:53Z nikki93 joined #lisp
2014-12-28T19:26:02Z jumblerg quit (Quit: My Mac has gone to sleep. ZZZzzz…)
2014-12-28T19:27:28Z nyef joined #lisp
2014-12-28T19:27:46Z nyef: Hello all.
2014-12-28T19:27:50Z dkcl joined #lisp
2014-12-28T19:27:52Z shka: nyef: hi
2014-12-28T19:28:05Z stassats: shka: you're saying that whatsapp was a better purchase?
2014-12-28T19:31:42Z shka: stassats: oh, that was insane as well
2014-12-28T19:32:58Z shka: it seems that us pumping giga$ into market simply inflated enormous bubble
2014-12-28T19:33:32Z shka: but that's other story
2014-12-28T19:34:35Z jumblerg joined #lisp
2014-12-28T19:35:16Z Ven quit (Quit: Textual IRC Client: www.textualapp.com)
2014-12-28T19:35:42Z shka: stassats: so, if it is worthy to simply throw away that kind of money into mud
2014-12-28T19:35:54Z shka: at least lisp machine could happen in the process :]
2014-12-28T19:35:59Z shka: lol
2014-12-28T19:39:58Z stassats: make lisp software first
2014-12-28T19:40:00Z Hexstream joined #lisp
2014-12-28T19:40:10Z stassats: intel makes good enough lisp machines
2014-12-28T19:41:29Z AeroNotix: shka: why don't we make Erlang machines?
2014-12-28T19:41:33Z AeroNotix: or Python machines?
2014-12-28T19:41:44Z AeroNotix: why is Lisp special in its need for a specific machine to run it?
2014-12-28T19:41:55Z shka: AeroNotix: intercal machines would be boss
2014-12-28T19:42:00Z towodo: the real distinction is pointer safety vs. none.
2014-12-28T19:42:04Z AeroNotix: It was, at one point, but that time has passed
2014-12-28T19:42:28Z shka: AeroNotix: because register based cpus are boring
2014-12-28T19:42:32Z shka: ;-)
2014-12-28T19:42:35Z AeroNotix: define boring
2014-12-28T19:42:54Z Hexstream: Widespread?
2014-12-28T19:44:08Z shka: AeroNotix: i can't define personal impressions, however i find assuming linear memory and assembly with loads of gotos a bit ugly concept
2014-12-28T19:44:24Z AeroNotix: shka: but compilers
2014-12-28T19:44:49Z cpc26_ joined #lisp
2014-12-28T19:45:54Z cpc26 quit (Ping timeout: 250 seconds)
2014-12-28T19:46:17Z cpc26 joined #lisp
2014-12-28T19:46:34Z hiroakip joined #lisp
2014-12-28T19:46:42Z shka: AeroNotix: i actually think that this may help to use parallel potential of cpu to a larger degree
2014-12-28T19:46:59Z AeroNotix: shka: design it and they will come, then
2014-12-28T19:47:12Z dagnachew joined #lisp
2014-12-28T19:49:59Z cpc26_ quit (Ping timeout: 256 seconds)
2014-12-28T19:50:11Z cpc26 quit (Client Quit)
2014-12-28T19:51:34Z manuel__ joined #lisp
2014-12-28T19:51:58Z shka: AeroNotix: so, where are my x10^9 dollars? ;-)
2014-12-28T19:53:05Z oudeis joined #lisp
2014-12-28T19:53:11Z rurumate quit (Ping timeout: 252 seconds)
2014-12-28T19:53:52Z towodo: https://en.wikipedia.org/wiki/Thinking_Machines
2014-12-28T19:54:13Z innertracks quit (Quit: innertracks)
2014-12-28T19:54:19Z rurumate joined #lisp
2014-12-28T19:54:41Z innertracks joined #lisp
2014-12-28T19:57:29Z nikki93_ joined #lisp
2014-12-28T19:57:42Z nikki93 quit (Read error: Connection reset by peer)
2014-12-28T19:57:50Z Ainieco quit (Remote host closed the connection)
2014-12-28T19:57:58Z dagnachew quit (Quit: WeeChat 1.0.1)
2014-12-28T19:58:23Z shka: towodo: so thinking machines were lispy as well?
2014-12-28T19:58:28Z shka: i didn't knew that
2014-12-28T19:58:45Z Petit_Dejeuner joined #lisp
2014-12-28T19:59:15Z towodo: started by MIT AI lab folks.  Guy Steele was there.  They were thinking along the lines indicated in this chat above
2014-12-28T19:59:45Z towodo: https://en.wikipedia.org/wiki/*Lisp
2014-12-28T20:00:49Z nyef: ... That got a mention in CLtL2, IIRC.
2014-12-28T20:02:30Z dagnachew joined #lisp
2014-12-28T20:03:09Z pt1 joined #lisp
2014-12-28T20:03:52Z raphaelss joined #lisp
2014-12-28T20:07:16Z cpc26 joined #lisp
2014-12-28T20:07:47Z shka: towodo: it really makes sense
2014-12-28T20:09:34Z pjb: stassats: p:0 is not a number, it's a symbol.
2014-12-28T20:09:45Z shka: ok folks, good night all
2014-12-28T20:09:52Z stassats: pjb: ok?
2014-12-28T20:10:12Z shka quit (Remote host closed the connection)
2014-12-28T20:10:37Z bool_ quit (Ping timeout: 272 seconds)
2014-12-28T20:10:56Z nell joined #lisp
2014-12-28T20:11:02Z sivoais quit (Ping timeout: 250 seconds)
2014-12-28T20:11:39Z bjorkintosh quit (Ping timeout: 258 seconds)
2014-12-28T20:15:15Z hugoduncan joined #lisp
2014-12-28T20:16:19Z hugod quit (Ping timeout: 272 seconds)
2014-12-28T20:17:13Z bool_ joined #lisp
2014-12-28T20:20:41Z EvW joined #lisp
2014-12-28T20:24:08Z defaultxr joined #lisp
2014-12-28T20:26:23Z ggole quit
2014-12-28T20:27:09Z CrazyM4n joined #lisp
2014-12-28T20:29:24Z _m___ joined #lisp
2014-12-28T20:29:53Z dagnachew quit (Remote host closed the connection)
2014-12-28T20:30:10Z Ven joined #lisp
2014-12-28T20:33:12Z pnpuff joined #lisp
2014-12-28T20:34:57Z nikki93_ quit (Read error: Connection reset by peer)
2014-12-28T20:35:13Z nikki93 joined #lisp
2014-12-28T20:36:42Z yenda joined #lisp
2014-12-28T20:37:27Z sivoais joined #lisp
2014-12-28T20:42:54Z dkcl quit (Read error: Connection reset by peer)
2014-12-28T20:43:00Z dickle joined #lisp
2014-12-28T20:44:35Z Blaguvest quit
2014-12-28T20:44:53Z raphaelss quit (Remote host closed the connection)
2014-12-28T20:45:15Z stassats quit (Ping timeout: 252 seconds)
2014-12-28T20:45:17Z innertracks quit (Quit: innertracks)
2014-12-28T20:45:43Z Ven quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
2014-12-28T20:45:45Z stassats joined #lisp
2014-12-28T20:48:19Z yenda quit (Read error: Connection reset by peer)
2014-12-28T20:48:34Z yenda joined #lisp
2014-12-28T20:50:02Z mrSpec quit (Remote host closed the connection)
2014-12-28T20:50:15Z munksgaard joined #lisp
2014-12-28T20:51:49Z yenda quit (Read error: Connection reset by peer)
2014-12-28T20:52:01Z yenda joined #lisp
2014-12-28T20:52:56Z yenda quit (Client Quit)
2014-12-28T20:54:59Z pt1 quit (Remote host closed the connection)
2014-12-28T20:55:41Z theseb joined #lisp
2014-12-28T21:01:29Z joneshf-laptop_ quit (Ping timeout: 258 seconds)
2014-12-28T21:03:59Z bjorkintosh joined #lisp
2014-12-28T21:09:34Z hardenedapple quit (Quit: WeeChat 1.0.1)
2014-12-28T21:11:34Z raphaelss joined #lisp
2014-12-28T21:11:46Z mrkkrp left #lisp
2014-12-28T21:15:20Z joneshf-laptop_ joined #lisp
2014-12-28T21:17:00Z dagnachew joined #lisp
2014-12-28T21:20:16Z stassats quit (Ping timeout: 258 seconds)
2014-12-28T21:20:18Z raphaelss quit (Quit: ERC Version 5.3 (IRC client for Emacs))
2014-12-28T21:20:22Z kristof joined #lisp
2014-12-28T21:20:31Z basichash joined #lisp
2014-12-28T21:21:04Z basichash: Not necessarily related to Lisp, but can someone explain the importance of logs in software in a general sense?
2014-12-28T21:21:38Z kristof: Logs provide a persistent way to tell users of software what happened, when, and potentially why
2014-12-28T21:21:47Z p_l: basichash: a lot depends on how and what you log
2014-12-28T21:22:49Z nyef: Users and/or developers/maintainers.
2014-12-28T21:22:50Z p_l: the most basic thing is telling what happened when, noting down errors as they come. Then post-mortem analysis. then as you go deeper you can have complex audit and tracing - some of it going to the point of being a tool for profiling, debugging
2014-12-28T21:23:51Z basichash: in a web application for example, should every user action be logged? e.g. authorizations, DB queries, etc
2014-12-28T21:23:56Z Gmind1 quit (Quit: Leaving.)
2014-12-28T21:24:24Z nyef: That's a bit situational.
2014-12-28T21:25:59Z H4ns: basichash: some people consider fine grained logging to be essential for debugging production problems.  i find obsessive logging to be more of a burden than a real help.  it is really a matter of personal preference.
2014-12-28T21:26:04Z Shinmera: Depends on what you want, how important it is, how trustworthy your logs are,  and a million other factors.
2014-12-28T21:26:36Z urandom__ quit (Ping timeout: 244 seconds)
2014-12-28T21:26:43Z urandom_1 joined #lisp
2014-12-28T21:26:47Z nyef: And there's also the question of granularity. It's one thing to log "so-and-so authenticated", and another to log "so-and-so authenticated, the DB query was blah-blah, and it took this long to execute, the system load was such-and-such on the DB server, such-and-such on the app server, and such-and-such on the proxy server, the lunar phase was gibbous waning, and the CPU temperature on the firewall was so-much."
2014-12-28T21:27:14Z pnpuff left #lisp
2014-12-28T21:27:28Z basichash: right so it's highly dependent on the situation
2014-12-28T21:27:38Z H4ns: i think that fine-grained logging is very valuable in environments where you cannot access the production system at all.
2014-12-28T21:27:39Z Shinmera: Also depending on what system you have you can combat that issue by using different logging levels and categories so you can filter the logs.
2014-12-28T21:27:40Z nyef: ("... and there is 172k of disk space remaining on the log server.")
2014-12-28T21:27:53Z H4ns: in less strictly controlled environments, it is burdensome.
2014-12-28T21:28:18Z jasom: fine-grained logging is also useful for hard-to-reproduce bugts
2014-12-28T21:28:31Z p_l: basichash: http://research.google.com/pubs/pub36356.html <--- I'd consider the approach provided there
2014-12-28T21:28:53Z basichash: cheers
2014-12-28T21:28:55Z p_l: basichash: fine-grained end-to-end tracing being switched on per-request/session/whatever by first server in the service
2014-12-28T21:29:18Z nyef: You also want to make value judgments like "these operations here don't go wrong, so don't bother to do more than the most superficial logging, but there's an intermittent fault over here, so log all of the I/O among every server for this..."
2014-12-28T21:29:32Z p_l: then all applications behind it getting a flag informing them of trace enable *and* a tag identifying the calling code
2014-12-28T21:29:55Z weedgoku joined #lisp
2014-12-28T21:30:07Z nyef: p_l: A well-dressed Tracy detective?
2014-12-28T21:30:17Z p_l: then you can grab the logs and correlate that "in cases like X, it triggers an error/spike in processing time/whatever in part B"
2014-12-28T21:30:20Z p_l: nyef: hahaha
2014-12-28T21:30:31Z agumonkey joined #lisp
2014-12-28T21:31:20Z jumblerg quit (Quit: My Mac has gone to sleep. ZZZzzz…)
2014-12-28T21:32:18Z innertracks joined #lisp
2014-12-28T21:32:49Z Ven joined #lisp
2014-12-28T21:33:37Z innertracks quit (Client Quit)
2014-12-28T21:35:26Z flash- joined #lisp
2014-12-28T21:36:02Z Jessin quit (Quit: Leaving)
2014-12-28T21:36:39Z AeroNotix: metrics are more useful than logs imho
2014-12-28T21:38:46Z ehu joined #lisp
2014-12-28T21:38:48Z kristof: Quantitative and qualitative data, both useful
2014-12-28T21:38:48Z p_l: AeroNotix: logs can carry metrics
2014-12-28T21:39:07Z kristof: I think Aeronotix is talking about event logs
2014-12-28T21:39:08Z AeroNotix: p_l: I'm talking specifically of things like graphite
2014-12-28T21:39:22Z jumblerg joined #lisp
2014-12-28T21:39:29Z agumonkey quit (Quit: ZNC - http://znc.in)
2014-12-28T21:39:40Z p_l: AeroNotix: Well, a metric by itself doesn't necessarily correlate
2014-12-28T21:39:58Z p_l: Dapper-like approach gives you a metric that also contains causal relation between different parts
2014-12-28T21:40:43Z agumonkey joined #lisp
2014-12-28T21:41:00Z AeroNotix: p_l: indeed, you need several to correlate any meaningful thing
2014-12-28T21:41:02Z innertracks joined #lisp
2014-12-28T21:41:44Z AeroNotix: p_l: and you need to make sure you do it properly. E.g. me and a couple of colleagues just spent about 2/3 months working up a very useful set of metrics and monitoring endpoints into our main application :)
2014-12-28T21:42:12Z tadni joined #lisp
2014-12-28T21:42:30Z p_l: AeroNotix: Dapper produced a graph that starts (all with timestamps, and possibly extra data/metrics) at the beginning of processing of external request and ends when all is done, providing info about who called what and when
2014-12-28T21:43:11Z AeroNotix: p_l: link to dapper?
2014-12-28T21:43:20Z p_l: http://research.google.com/pubs/pub36356.html
2014-12-28T21:43:26Z AeroNotix: thanks
2014-12-28T21:43:42Z p_l: it's a research paper, but it provides enough info to start work on a system that fits your environment
2014-12-28T21:44:34Z p_l: a quite simple idea, in the end
2014-12-28T21:44:46Z p_l: probably more work to *analyze* the results :D
2014-12-28T21:44:52Z innertracks quit (Client Quit)
2014-12-28T21:46:04Z MoALTz joined #lisp
2014-12-28T21:46:57Z AeroNotix: p_l: thanks I'll send this to my kindle
2014-12-28T21:47:49Z kcj joined #lisp
2014-12-28T21:49:14Z dagnachew quit (Quit: WeeChat 1.0.1)
2014-12-28T21:56:02Z psy joined #lisp
2014-12-28T21:57:08Z rurumate: I've created a file that contains a package declaration and some defuns. How do I (re)load it and invoke the defuns, from slime repl?
2014-12-28T21:57:18Z rurumate: the file: http://paste.lisp.org/display/144952
2014-12-28T21:57:54Z nyef: Umm... Are you missing an IN-PACKAGE form?
2014-12-28T21:58:07Z rurumate: maybe
2014-12-28T21:58:17Z nyef: And an :EXPORT term for the DEFPACKAGE might be in order as well...
2014-12-28T21:58:20Z rurumate: this my first shot at common lisp
2014-12-28T21:58:24Z Bicyclidine: C-c C-l in the file, or (load filename) int he repl
2014-12-28T21:58:32Z dagnachew joined #lisp
2014-12-28T21:59:23Z pjb: rurumate: you cannot reload it conformingly, since re-evaluating the defpackage form on the same package is not specified.
2014-12-28T22:00:07Z rurumate: so should I omit the defpackage then?
2014-12-28T22:01:02Z pjb: Well, in most implementations it works ok, so you can go ahead.
2014-12-28T22:01:21Z pjb: But this explains why it's customary to put the defpackage forms in a separate file.
2014-12-28T22:01:30Z pjb: So you may reload the other files without problem.
2014-12-28T22:01:30Z nyef: ... It's not specified?
2014-12-28T22:01:35Z nyef: clhs defpackage
2014-12-28T22:01:35Z specbot: http://www.lispworks.com/reference/HyperSpec/Body/m_defpkg.htm
2014-12-28T22:01:56Z pjb: "If the new definition is at variance with the current state of that package, the consequences are
2014-12-28T22:01:56Z pjb: undefined;"
2014-12-28T22:02:05Z nyef: Ah, "if the new definition is at variance with the current state..." yeah.
2014-12-28T22:02:07Z nyef: Hunh.
2014-12-28T22:02:26Z pjb: Ok, if you don't change the defpackage, I guess you can reload it.
2014-12-28T22:02:30Z nyef: That's spectacularly explicit, and explicitly not helpful.
2014-12-28T22:03:03Z pjb: You may use your own defpackage macro that does explicitely what you want in this case…
2014-12-28T22:03:26Z nyef: ... but would it integrate properly with asdf-package-system or whatever it's called?
2014-12-28T22:03:38Z Beetny_ joined #lisp
2014-12-28T22:03:46Z pjb: what?
2014-12-28T22:04:17Z nyef: The one where asdf uses defpackage forms at the top of each source file to come up with a dependency graph.
2014-12-28T22:04:17Z nikki93 quit (Ping timeout: 240 seconds)
2014-12-28T22:04:21Z nightshade427 quit (Ping timeout: 258 seconds)
2014-12-28T22:04:43Z pjb: good question. Does it use the source form, or the package themselves?
2014-12-28T22:04:52Z psy quit (Ping timeout: 245 seconds)
2014-12-28T22:04:59Z Hexstream: http://common-lisp.net/project/asdf/asdf/The-package_002dinferred_002dsystem-extension.html
2014-12-28T22:05:00Z keen__________16 joined #lisp
2014-12-28T22:05:33Z keen__________15 quit (Ping timeout: 244 seconds)
2014-12-28T22:06:48Z Dynasty joined #lisp
2014-12-28T22:06:53Z theseb quit (Quit: Leaving)
2014-12-28T22:09:51Z dim: any known implementation of the MSSQL protocol in CL? the mssql driver piggy backs on freetds (via cffi), and I've seen other drivers using ODBC, nothing like a CL implementation of the protocol... it doesn't seem out of reach (http://www.freetds.org/tds.html)
2014-12-28T22:10:26Z pjb: There's something for mysql, but I've never heard of one for mssql.
2014-12-28T22:10:28Z rurumate: why does (floor (/ 1 2)) print 0 and 1/2 in the repl? 0 should be enough?
2014-12-28T22:10:48Z pjb: rurumate: CL functions can return multiple values, and often do.
2014-12-28T22:11:07Z rurumate: you mean it returns a list?
2014-12-28T22:11:09Z pjb: Notice that you can also use (floor 1 2)
2014-12-28T22:11:13Z dim: pjb: there are two for mysql, I maintain the first one (qmynd) and cleaned the second one to load in more implementations than just Lispworks (artisan-mysql)
2014-12-28T22:11:36Z kristof: rurumate: Nope! You can pretend it returns only one, but you may *bind* the second value to a variable if you want to pretend it exists, too.
2014-12-28T22:12:09Z kristof: rurumate: This may seem the same as returning a list and then only checking the first value, but it's a matter of utility. Imagine you design a program where you return only one value, and everyone calls it expecting one value.
2014-12-28T22:12:13Z CrazyM4n quit (Quit: going to eat food)
2014-12-28T22:12:35Z kristof: rurumate: Down the road, you actually want to return TWO values for special cases. If you change it to returning a pair... you now have to modify EVERY SINGLE CALL SITE IN YOUR PROGRAM.
2014-12-28T22:13:11Z kristof: rurumate: If you use multiple return values, you merely have to modify the function definition, and whenever you want to use the special value, just use MULTIPLE-VALUE-BIND. Check the hyperspec on the documentation.
2014-12-28T22:13:16Z MutSbeta quit (Quit: Leaving.)
2014-12-28T22:14:02Z kristof: rurumate: This can also be optimized very, very well. In many cases, the multiple value is just thrown in another register somewhere (this is harder on register poor architectures like Intel).
2014-12-28T22:14:37Z nyef: Or ARM. Fifteen registers just isn't quite enough. /-:
2014-12-28T22:15:03Z kristof: You don't really need more registers given how fast cache is
2014-12-28T22:15:40Z dagnachew quit (Remote host closed the connection)
2014-12-28T22:15:57Z innertracks joined #lisp
2014-12-28T22:16:05Z kristof: That was with respect to Intel chips, I am aware that ARM has no cache :P
2014-12-28T22:16:13Z rurumate: thank you kristof I learned a lot today
2014-12-28T22:18:32Z kristof: rurumate: I had this awful discussion with someone in Haskell a while ago.
2014-12-28T22:18:58Z kristof: rurumate: *#haskell. I asked him why Haskell didn't have multiple return values. He said that unboxed tuples WERE multiple return values. It's about the call-site, dummy!
2014-12-28T22:19:10Z Shinmera: I find that multiple values aren't that often useful, but when they are, they are very much so.
2014-12-28T22:19:15Z kristof: ^
2014-12-28T22:19:35Z kristof: Shinmera: I find that Common Lisp has so many neat things *engineered* into it.
2014-12-28T22:19:37Z nyef: I'm suddenly reminded of the story of PG finally realizing why CL has keyword parameters.
2014-12-28T22:19:44Z kristof: lol
2014-12-28T22:19:48Z Shinmera: kristof: Indeed.
2014-12-28T22:20:04Z Shinmera: nyef: Consider me intrigued
2014-12-28T22:20:14Z kristof: Same
2014-12-28T22:21:18Z nyef: Hmm? C'mon, it was in one of his famous early essays, something about some small startup that got bought out by Yahoo.
2014-12-28T22:21:30Z kristof: nyef: I was trying to convince someone in #haskell how easy it was to add keyword parameters (minus &allow-other-keys) to the language because of the church-rosser theorem. No one cared.
2014-12-28T22:21:43Z Shinmera: I don't remember much about "Beating the Averages", if you're referring to that one.
2014-12-28T22:21:49Z nyef: That might be hte one.
2014-12-28T22:21:52Z Shinmera: tbh I don't remember much about any of his writings, but eh.
2014-12-28T22:22:08Z nyef: Most of his writings are not merely forgettable, but SHOULD be forgotten.
2014-12-28T22:22:26Z Bicyclidine: what do keywords have to do with church rosser, exactly
2014-12-28T22:24:10Z fantazo joined #lisp
2014-12-28T22:24:20Z kristof: Bicyclidine: I think if you don't allow other keys, then a keyword argument is just a name for the position of the argument. If all keys had a default value like NIL or NOT-SUPPLIED, then:
2014-12-28T22:25:15Z kristof: Bicyclidine: a function with parameters (f a b c) that is called as (f :a val :c other-val) can be rewritten at compile time as (f val NOT-SUPPLIED other-val)
2014-12-28T22:25:22Z Bicyclidine: it's a bit complicated since CL has useful things like ":foo 4 :foo 5" working. but yes.
2014-12-28T22:25:28Z Bicyclidine: i still don't know what that has to do with church rosser, though
2014-12-28T22:25:32Z kristof: Getting there!
2014-12-28T22:25:48Z Bicyclidine: especially since CL doesn't have church-rosser anyway. heh heh.
2014-12-28T22:25:49Z kristof: This is all fine and dandy, except someone brought up that it messes with partial evaluation and currying, which are gods to the Haskellite race.
2014-12-28T22:26:31Z kristof: But I think the church rosser theorem allows for out-of-order evaluation. So I rest my case.
2014-12-28T22:26:41Z rurumate quit (Quit: Lost terminal)
2014-12-28T22:27:26Z Bicyclidine: i think it's a bit simpler than that. haskell does partial application left to right, and you're complicating the argument order, so the semantics are slightly difficult.
2014-12-28T22:28:11Z gravicappa quit (Remote host closed the connection)
2014-12-28T22:28:16Z SSJweedgoku joined #lisp
2014-12-28T22:28:19Z kristof: It still does partial evaluation left and right. But it has nothing to do with the argument order defined at the function definition, now. Only at the call-site.
2014-12-28T22:28:48Z fantazo quit (Client Quit)
2014-12-28T22:28:56Z Jesin joined #lisp
2014-12-28T22:29:09Z kristof: *left to right
2014-12-28T22:29:48Z |3b|: partially applying a keyword arg when expanding them at call site sounds confusing
2014-12-28T22:30:15Z Bicyclidine: i mean, it's like you said church-rosser would let you do partial applications right to left. you could do partial applications right to left and all but you're still changing some semantics
2014-12-28T22:30:41Z kristof: No loss, there.
2014-12-28T22:31:14Z kyl___ is now known as kyl____
2014-12-28T22:31:37Z weedgoku quit (Ping timeout: 240 seconds)
2014-12-28T22:34:49Z dagnachew joined #lisp
2014-12-28T22:36:13Z hegel joined #lisp
2014-12-28T22:40:16Z nikki93 joined #lisp
2014-12-28T22:46:17Z mishoo quit (Ping timeout: 240 seconds)
2014-12-28T22:49:22Z flash-: Hello everyone.
2014-12-28T22:49:58Z flash-: I have a question about documentation. I normally hang out in #clasp, and I'm currently writing a wrapper for a C++ library.
2014-12-28T22:50:14Z stassats joined #lisp
2014-12-28T22:50:44Z flash-: Now I want to use the doxygen documentation of the C++ library to produce meaningful docstrings.
2014-12-28T22:52:00Z Bicyclidine: getting docstrings out of html sounds kind of annoying.
2014-12-28T22:53:04Z flash-: The doxygen comments obviously use commands like \param and \return. Is there a Common Lisp documentation system, that uses docstrings, but has a somewhat similar syntax, which would allow me to keep the specific information?
2014-12-28T22:53:47Z Shinmera: Bicyclidine: If it's regularly structured it shouldn't be hard with, say, lQuery.
2014-12-28T22:54:09Z Xach: flash-: no.
2014-12-28T22:54:12Z flash-: Bicyclidine: I'm getting the strings directly from the source code. The question is how do I best process them before putting them into the docstring place in the clasp binding.
2014-12-28T22:55:07Z nikki93 quit (Remote host closed the connection)
2014-12-28T22:56:08Z flash-: Xach: Well, that is unfortunate. What would you recommend me to do? Just keep in the doxygen syntax? At least the intention would be clear then.
2014-12-28T22:56:59Z Xach: flash-: Are you generating the CL source code automatically?
2014-12-28T22:59:04Z flash-: Not yet, but I plan to get there eventually. Currently I'm just hacking together some emacs functions that ease the process. The resulting code is not CL, though. It is C++, which, using drmeister's clbind results in a working package in clasp.
2014-12-28T22:59:10Z Zamenhof quit (Ping timeout: 258 seconds)
2014-12-28T22:59:19Z dagnachew quit (Quit: WeeChat 1.0.1)
2014-12-28T23:06:12Z dickle quit (Read error: Connection reset by peer)
2014-12-28T23:06:12Z dandersen quit (Read error: Connection reset by peer)
2014-12-28T23:06:32Z Beltxarga quit (Ping timeout: 250 seconds)
2014-12-28T23:07:42Z dagnachew joined #lisp
2014-12-28T23:08:44Z knobo joined #lisp
2014-12-28T23:08:45Z dandersen joined #lisp
2014-12-28T23:09:29Z Xach: flash-: I don't know a good solution. Keeping the doxygen seems all right, if it's not too opaque.
2014-12-28T23:09:34Z specbot quit (Disconnected by services)
2014-12-28T23:11:07Z knobo: Caveman looks like a nice web framework. Any public sites built with it?
2014-12-28T23:11:56Z flash-: Xach: Thanks, it's just what I might do.
2014-12-28T23:12:47Z dagnachew quit (Quit: WeeChat 1.0.1)
2014-12-28T23:13:40Z innertracks quit (Quit: innertracks)
2014-12-28T23:15:49Z flash-: I'm going to bed. If anyone has a good idea on my problem, I'm a regular reader of the logs of this channel.
2014-12-28T23:16:06Z flash- quit (Quit: ERC Version 5.3 (IRC client for Emacs))
2014-12-28T23:18:24Z jumblerg quit (Quit: My Mac has gone to sleep. ZZZzzz…)
2014-12-28T23:18:26Z kristof: knobo: As far as I can tell, quickdocs
2014-12-28T23:20:22Z dagnachew joined #lisp
2014-12-28T23:22:19Z Ethan- joined #lisp
2014-12-28T23:23:10Z arnaudga joined #lisp
2014-12-28T23:24:24Z izback joined #lisp
2014-12-28T23:24:36Z izback left #lisp
2014-12-28T23:25:33Z nikki93 joined #lisp
2014-12-28T23:27:10Z zygentoma quit (Quit: KVIrc 4.2.0 Equilibrium http://www.kvirc.net/)
2014-12-28T23:28:12Z Beltxarga joined #lisp
2014-12-28T23:28:13Z munksgaard quit (Ping timeout: 244 seconds)
2014-12-28T23:30:17Z nikki93 quit (Ping timeout: 244 seconds)
2014-12-28T23:33:50Z kristof quit (Ping timeout: 250 seconds)
2014-12-28T23:34:51Z pacon joined #lisp
2014-12-28T23:36:41Z dkcl joined #lisp
2014-12-28T23:43:25Z harish_ quit (Ping timeout: 272 seconds)
2014-12-28T23:45:40Z atgreen joined #lisp
2014-12-28T23:47:04Z ehu quit (Ping timeout: 255 seconds)
2014-12-28T23:48:08Z milosn joined #lisp
2014-12-28T23:50:17Z atgreen quit (Ping timeout: 240 seconds)
2014-12-28T23:55:11Z dkcl quit (Read error: Connection reset by peer)
2014-12-28T23:55:11Z dandersen quit (Read error: Connection reset by peer)
2014-12-28T23:55:16Z basichash quit (Read error: Connection reset by peer)
2014-12-28T23:56:54Z dandersen joined #lisp