freenode/#lisp - IRC Chatlog
Search
8:39:15
heisig
mrblack: But it is not a function, it is just a symbol that is treated specially in certain macros.
8:39:43
mrblack
jackdaniel, heisig: cool, thanks... it was used in Land of Lisp but I don't think the author explains it, couldn't find. It's hard to find info about it because that's a common word. Do you have any links for it?
8:40:35
jackdaniel
use l1sp.org (the second character is "one", not small "L"), very handy for such lookups
8:40:38
mrblack
thank you, jackdaniel. this seems like a good site to bookmark. Google wasn't of much help ;)
8:41:19
jackdaniel
also I believe that duckduckgo redirects to this site when used with a special bang
8:41:48
aeth
If you make DuckDuckGo your default search engine you can just !l1sp in the URL bar in e.g. Firefox
8:42:03
mrblack
jackdaniel, aeth, great. I used Vimium, though, it lets me create commands for any search I want.
8:45:13
mrblack
is it possible to access this documentation offline like man pages, from Emacs or the command line?
8:46:52
mrblack
I see that "slime-documentation-lookup" will open the term under cursor on the web browser... it's good enough, I guess. But offline would be better
9:24:31
Xof
fiddlerwoaroof: I think you've found the two relevant paragraphs about method combinations and matching specializers / differing qualifiers
9:25:25
Xof
sbcl generally (at least historically) tends to go for outward portability -- if it uses only standard functionality and runs on sbcl, it runs on other CLs
9:25:42
Xof
so it chooses to obey the paragraph that says that what you're trying to do isn't allowed
9:26:07
Xof
however: there is an escape hole -- sbcl doesn't enforce that restriction if there is a single, wild-card method group
9:30:33
Xof
beach: sbcl optimizes make-instance in a bundle of different ways. the main way is when the initarg symbols are constant, we construct a CTOR (see src/pcl/ctor.lisp) which maps the initargs to slot locations (per-class if the class-name argument to make-instance is variable, otherwise just once), receives values for all the initarg forms that weren't compile-time constants, and allocates and initializes the instanc
9:30:52
Xof
actually I'm less sure about the "bundle of different ways"; I think I've managed to get them all into one sentence :-)
9:31:45
beach
Xof: Thanks. What if there are :AROUND methods on INITIALIZE-INSTANCE and/or on SHARED-INITIALIZE?
9:35:36
Xof
we refuse to optimize if there's a non-standard allocate-instance method, or an :around method on shared-initialize. we can cope with :around methods on initialize-instance if it calls (call-next-method) appropriately
9:38:11
Xof
welcome. This was largely Gerd Moellmann's work, when he was (I presume) bored between jobs around *gulp* 2002
10:07:48
flip214_
Can I get the current input position (in bytes) from CXML? I'd really like to create an index (tag => position, length) into a large XML file, and then do "random" IO on it.
10:35:33
beach
You say that ASLR is irrelevant to my address-space argument. I don't understand why.
10:39:29
flip214_
beach: ASLR is irrelevant for the "historical reasons", and also " does not take great care to prevent a temporary buer from overowing,
10:43:15
flip214_
so yeah, ASLR helps _a_small_bit_ re security -- but as soon as you can overwrite a buffer or cause other misbehaviour, you more or less have lost. even if the program "only" crashes, it's a very easy DOS.
10:43:54
beach
I still think it is relevant. ASLR attempts to prevent some code from sticking a different return address on the stack by making that return address randomly different.
10:44:26
beach
And putting a different return address on the stack is possible because the process has full access to its address space, including the stack.
10:44:59
beach
So if the process did not have access to its stack, this kind of attack would not be possible and ASLR would not be necessary.
10:45:25
flip214_
beach: I thought that your main point in 1.2.4 is that full-address-space access is because of historical reasons, and has quite some security implications - some of which might get better with ASLR.
10:45:57
flip214_
but then you propose an architecture where _all_ things run in the same address space, and could potentially read each others secrets.
10:46:43
flip214_
beach: in your architecture, they won't, but that's not a feat of ASLR. _that's_ why I think ASLR is irrelevant for CLOSOS.
10:47:44
beach
It was not meant to be an argument for my architecture. It was meant to be a description of a kludge that was invented to improve security in a system where the process has full access to its address space.
10:49:47
flip214_
beach: I suggested to shorten the ASLR paragraph (and not remove it), so that it's not forgotten.
11:44:46
pillton
mrblack: You can download the CLHS from http://www.lispworks.com/documentation/common-lisp.html .
11:45:56
pillton
mrblack: In can set where emacs looks up pages by changing common-lisp-hyperspec-root i.e. (setq common-lisp-hyperspec-root "file:///my-fancy-nick/contrib/hyper-spec-7.0/HyperSpec/")
11:48:19
flip214_
when using FORMAT iteration ~:{ ~a ~a ~}, can I make the second element optional, eg. for an input '((1 2) (2 3) (4)) ?
12:04:23
mrblack
Does anyone know why I'm getting an error here? "(equal '(1 2 3) (cons 1 (cons 2 (cons 3))))". I'm using sbcl, and this is a direct copy from the book Land of Lisp (I usually type, but I copy pasted just to check after getting the error). Here are the environment and errors: https://hastebin.com/yimevowome.php
12:09:20
jackdaniel
mrblack: I'm certain that 40 people there will be more interested in basics than 316 people here
12:10:11
jackdaniel
as of cons, it is a two-argument function. lists defined recursively as NIL or cons
12:13:08
mrblack
jackdaniel, I understand that "nil" is the empty list, but what I really wanted to know is why it's necessary in the example...
14:46:17
Xof
fiddlerwoaroof: well, I'm less certain than I used to be about the outwardly-portable conservative interpretation of the spec (and other developers are more radical in various directions than I am)
14:46:40
Xof
fiddlerwoaroof: but you can make progress by making your own method combinations with the * method-group
14:52:37
mrblack
edgar-rft, I don't think I got to the "list" function with that syntax, but I get your point
16:18:28
fiddlerwoaroof
Xof: yeah, although I'd think that the same reasoning that allows * to "ignore the rules" should apply when * is part of a qualifier pattern
16:36:01
mrblack
I'm trying to understand this function: https://hastebin.com/onugivohev.pl . What is does: tells me if there's and object on a given location. I understand what "assoc" and "cadr" are doint. What I don't understand is where the value for the parameter (obj) comes from, what is its value?
16:39:31
jackdaniel
this is a good question for clschool (again ,p). remove-if-not takes two arguments: a predicate and a sequence
16:40:09
jackdaniel
then it applies each element in the sequence to the predicate (your obj), and if predicate returns T, element is kept, otherwise it is removed from said sequence
16:40:43
jackdaniel
so remove-if-not returns a sequence with all elements in it which met the predicate
16:41:09
jackdaniel
as of asking questions, sometimes it is worth waiting a little more or try things by yourself.
16:41:35
jackdaniel
mrblack: I believe reading this resource will be beneficial to you: http://catb.org/~esr/faqs/smart-questions.html
16:43:53
pfdietz
One thing to be clear about: remove-if-not is nondestructive. It does not modify its argument (although the return value may share structure with that argument).
16:44:37
jackdaniel
mrblack: remove-if-not applies function at-loc-p to elements which are in the second argument
16:45:19
pfdietz
All lisp variables can be thought of as pointers (although for numbers or characters, the things being pointed to can be copied at any time, at least conceptually).
16:46:53
minion
mrblack: please see gentle: "Common Lisp: A Gentle Introduction to Symbolic Computation" is a smoother introduction to lisp programming. http://www.cs.cmu.edu/~dst/LispBook/
16:47:18
pfdietz
What that code is doing is removing every object from the sequence objs for which the loc of that object (as defined by the association list obj-locs) is eq to loc.
16:47:35
minion
more gentle than Land of Lisp? It has cartoons: An error was encountered in lookup: Parse error:URI "https://www.cliki.net/more%20gentle%20than%20Land%20of%20Lisp?%20It%20has%20cartoons?source" contains illegal character #\? at position 84..
16:50:11
pfdietz
Could also write (remove loc objs :key (lambda (obj) (cadr (assoc obj obj-locs))) :test 'eq)
16:50:12
mrblack
anyway, what I'm not understanding is here does the "obj" the appears in the the definition of at-loc-p(obj) comes from... because it is not entered by the main function, which have these arguments: "(loc objs obj-locs)"
16:51:05
pfdietz
mrblack: that "obj" is a formal parameter of the internal function defined by the labels form.
16:51:43
mrblack
pfdietz, but what is it's value gives its value in (cadr (assoc obj obj-locs))? what does it do????
16:52:19
pfdietz
remove-if-not calls at-loc-p on each element of the sequence. For each call, obj is bound to that element.
16:52:37
pfdietz
So, if objs was the list (a b c) then at-loc-p would be called on a, then on b, then on c.
16:52:56
Bike
Okay, so say you have (labels ((oneplus (x) (1+ x))) (mapcar #'oneplus '(1 2 3))), do you know what that would return?
16:55:46
Bike
(mapcar #'1+ '(1 2 3)) is kind of like (list (1+ 1) (1+ 2) (1+ 3)); mapcar calls the 1+ function on each element of the list.
16:56:41
Bike
mapcar calls oneplus on each argument the same way (mapcar #'1+ ...) would call 1+, and puts the results in a list.
16:56:57
Bike
so (labels ((oneplus (x) (1+ x))) (mapcar #'oneplus '(1 2 3))) would also return (2 3 4).
16:57:36
pfdietz
oneplus is called more than once, and on each call 'x' is bound to a different value (1, then 2, then 3).
17:02:09
Bike
remove-if-not calls its function argument on each element of the list it's given in the same way. so that's where the obj argument comes from.
17:05:58
Bike
No. Listen. (remove-if-not #'at-loc-p objs) is a function call. the REMOVE-IF-NOT function receives two arguments, #'at-loc-p and objs. #'at-loc-p is a function and an argument. that's the "function argument" i meant.
17:06:26
Bike
So with (remove-if-not #'at-loc-p objs), remove-if-not will call the at-loc-p function on each element of the objs.
17:07:27
pfdietz
In C, you can pass function pointers to other functions. This is something like that.
17:08:47
pfdietz
#'at-loc-p is a value that can be computed before calling at-loc-p. It doesn't come from a call to that function, but rather is something like a pointer to that function.
17:10:12
pfdietz
It might be helpful to consider a case where the function being passed is defined by defun, rather than inside another function using labels.
17:10:47
mrblack
I don't know, man, this book feels a little unfair. He/She trows a of of things at me... I don't know it it's all like that. But this "recursion hell" (don't even know if that is recursion) should be better explained.
17:23:53
pfdietz
The labels form has the definition of at-loc-p, but that definition isn't invoked up there. It's just defined there.
17:24:38
pfdietz
Execution falls down into the body of the labels form, which is the call to remove-if-not. THAT function then calls at-loc-p on each element of the sequence objs.
17:25:28
pfdietz
And the value returned by the call to remove-if-not is the value returned by the labels form, and then from the call to objects-at.
17:26:36
pfdietz
A function definition, like that in labels, doesn't start executing the function, it just wraps it up in a nice package that other things can call.
17:35:38
pfdietz
One tricky thing there you should understand: where do loc and obj-locs come from inside the definition of at-loc-p?
17:36:50
mrblack
pfdietz, I think those are parameters supplied from outside the function... either user input or from another function
17:37:00
pfdietz
Those are the reasons that code is using labels, rather than defining at-loc-p outside in a defun.
17:38:18
pfdietz
So each call to at-loc-p is seeing those same two variables. Unlike the parameter obj, which is new on each call to at-loc-p.
17:40:48
pfdietz
Functional programming basically means (1) no assignment statements or other operations with side effects, and (2) using functions as values. This example is functional programming, yes.
17:42:42
pfdietz
assoc looks up an element of an association list; cadr pulls out a value from that element, and eq compares. No objects are being modified, no variables are being assigned to.
17:45:27
pfdietz
Lisp *does* support imperative (the opposite of functional) programming. It has destructive operations and assignments. But this example does not use any of that.
17:47:26
mrblack
lisp is so different it is like learning Japanese sometimes :P Only dabbled with C and Pascal before
17:49:37
mrblack
I like Pascal, but it doesn't have much use. My professor used to teach algorithms for a while (it was actually a Portuguese "translation" people here use to teach newcomers)
17:49:56
pfdietz
Lisp lets you do something new, though: you can define a function inside another function, then return it. This is illegal in Pascal; there functions can only be passed "downward" as arguments to other functions, not stored or returned. There's an implementation reason for this (not important now).
19:16:49
emaczen
I don't have experience with gdb when writing a C program either... but thats what you usually see
19:17:11
makomo
johnjay: use emacs along with org-mode to write your notes and git to version control them, that's about it :D
19:18:08
emaczen
johnjay: ask in #emacs but look at magit mode for convenient key bindings for common git commands
19:19:53
johnjay
makomo: i thought you had a system for annotation source code which i've been thinking about lately
19:20:21
johnjay
i hate the bs inline stuff of javadoc and oxygen where you put @doc_string_with_long_name lots_of_text every other line
19:21:38
makomo
johnjay: ah, nope. another benefit of having your notes in plain text is that they're easily searchable using tools like grep, etc.
19:22:13
johnjay
makomo: i did come up with one idea though. You've heard of literate programming right?
19:22:48
johnjay
instead you make a literate prog file which has notes, and mentions only a subset of lines of the source
19:23:01
johnjay
then when you process it you just match it line-by-line to the source file to check it
19:23:34
johnjay
so for example if you have lines A,B,C,D in your file then your literate notes produce only A and C
19:23:50
makomo
johnjay: what does "check" here mean? if i'm understanding correctly, wouldn't you have to maintain the alignment of the positions of text within both of the files?
19:24:28
johnjay
the idea is not to be perfect but just to have some kind of notes that can match the source
19:24:56
makomo
like literally have parts of the source in those "note files", just for the purposes of matching?
19:25:20
johnjay
if your file is #include int main() { printf("hello"); printf("world"); return 0; }
19:25:30
jcowan
pfdietz: Technically a program can change state and still be functional if the state is not visible to the program
19:25:47
johnjay
then your literate notes might say "this is a file that prints hello with the lines printf(hello); printf("world");" then it matches those two
19:25:56
jcowan
a program that does a debug-print operation on the console is functional if (as usual) there is no way to read back console output
19:26:02
johnjay
the only edges case i thought of is what if you repeat a line which changes something
19:26:30
johnjay
makomo: right because you can add or delete lines in a source file, that's relatively common with source control
19:27:05
makomo
johnjay: right, but you still have to keep them in sync, although not fully, just in parts
19:27:24
johnjay
if you just have the lines hello and world from my example you can still keep it in sync
19:27:48
jcowan
another case is a program that has been instrumented to update a profile counter when some function is called; since the profile counters are invisible to the code, the functions are still functional
19:28:34
makomo
johnjay: i guess the details would then depend on the matching algorithm or whatever
19:29:30
johnjay
e.g. between printf('hello') and printf('world') 10 lines of Qt code were added or something
19:30:47
makomo
same, but i always wonder whether literate programming is feasible. it seems like a good idea to me, but i've never actually tried it on a bigger project
19:31:12
johnjay
yeah that was why i thought this might work, because with literate programming any change necessitates updating the literate source
19:31:27
johnjay
but maybe if you ask for less you can use it this way, to just kind of maintain some basic notes on something
19:32:56
makomo
it's a pretty nice talk, i've watched it multiple times https://www.youtube.com/watch?v=Av0PQDVTP4A
19:34:19
johnjay
i guess the essence of my idea was that the more fixed the code the more literate you can make it
19:34:57
johnjay
so maybe you could have 3 levels: full lp for old unchanging code, my hybrid version for code that's mostly done , and then like notes matching to specific line numbers for WIP
19:35:46
makomo
the hybrid version that uses matching could somehow work, i guess. but the last approach would be too burdensome i think
19:36:21
makomo
right, but that's even worse, because then you have to keep changing those line numbers