<Bike>
oh, i thought maybe it was through a fault handler or something
<Bike>
bytes-consed-between-gcs is customizable, i think. maybe you can mess with that?
fikka has quit [Ping timeout: 264 seconds]
<didi`>
In my case, usually I have some percentage of the heap allocated, say 80%, then the GC is triggered and the heap is exhausted.
<stylewarning>
didi`: That variable seems like the wrong one to tune for a bug like this, no? IIUC, the default is 5% of the heap size, and that means when 5% of the heap is used, a GC of some sort will be attempted.
<didi`>
stylewarning: Oh, I don't know how to fix it. My workaround has been trying to use less and less programs during my work and aggressively cut my memory usage inside my program.
varjag has joined #lisp
<stylewarning>
I see
<didi`>
So by running fewer programs, I can dedicate more RAM to SBCL's heap.
<didi`>
stylewarning: Another "fix" I employ is calling the GC from time to time inside the REPL.
<stylewarning>
didi`: this bug is unfortunately being trigged in the depths of a complicated compiler pass
<didi`>
stylewarning: Crap.
<mega_beginner>
Page it out to an ssd, but then performance will be down horribly
paul0 has joined #lisp
<mega_beginner>
< Not a serious suggestion
<didi`>
mega_beginner: Desperate times...
<stylewarning>
I just want the garbage collector to collect garbage. :) It only has one job.
<didi`>
Tho I only have a rusty disc.
<didi`>
One paging starts, game over.
<didi`>
s/One/Once
markoong has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
johnvonneumann_ has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 240 seconds]
johnvonneumann has joined #lisp
kajokajo is now known as kajo
johnvonneumann is now known as Guest78695
fikka has joined #lisp
dddddd has quit [Remote host closed the connection]
<stylewarning>
when I replace the vector with a list that is PUSH'd on to, the bug disappears
<stylewarning>
makes me think there's something awry with collecting large objects, which I know are allocated specially
<pierpa>
any change if you use (make-array 32 :initial-element 42) ?
<pierpa>
and also give an :initial-element to the other make-array
fikka has quit [Ping timeout: 240 seconds]
<pierpa>
if this makes a difference then my suspects would go to conservativeness
orivej has quit [Ping timeout: 240 seconds]
<pierpa>
as, in the previous case you needed a RANDOM integer to trigger it. In this case, uninitialized arrays. So, vectors containing random fixnums would seem to play a part in this.
sjl has joined #lisp
<stylewarning>
pierpa: no difference
<pierpa>
you destroyed my theory!
<stylewarning>
pierpa: the random integer bit was because i needed different objects for EQUALP
<stylewarning>
but I changed that to EQ so all objects, even with the same contents, are basically different
<pierpa>
k
fikka has joined #lisp
orivej has joined #lisp
MoziM has quit [Quit: WeeChat 2.1]
fikka has quit [Ping timeout: 256 seconds]
<aeth>
sounds interesting
mega_beginner has quit []
erratic has joined #lisp
<aeth>
Does GC only trigger on allocation or manually calling?
fikka has joined #lisp
mikecheck has left #lisp ["part"]
<stylewarning>
aeth: I think it only triggers on those two events
<aeth>
Is there a way to find out exactly when the GC runs?
<stylewarning>
Yes, you can log it to a file.
<aeth>
I'm guessing that other threads (e.g. SLIME+Swank?) would trigger GC even in a non-allocating workload, but running it in a separate process entirely and seeing if the GC is triggered could be yet another test for consing.
<aeth>
Assuming you can isolate the rest of the program.
<aeth>
Doesn't help with your problem (unless I wasn't reading it carefully), but it would be an interesting test to run on some things
fikka has quit [Ping timeout: 248 seconds]
zachk has quit [Quit: Leaving]
<stylewarning>
aeth: good call out. Unfortunately it didn't change anything
<aeth>
stylewarning: Does SBCL have built in file logging or is it done as part of the *after-gc-hooks* that's mentioned in the manual?
makomo has quit [Ping timeout: 245 seconds]
<aeth>
oh I see, there's another section
<Xach>
clsql-mysql does not like the mariadb version string
<aeth>
(gc-logfile, in case anyone is wondering)
<Xach>
debian 9 does not have libpng12.so
<Xach>
so many things to fix to push out a new quicklisp dist!
<stylewarning>
Xach: fix the SBCL garbage collector too
shifty has quit [Ping timeout: 240 seconds]
<Xach>
the key there is to catch doug's attention
<Xach>
or stas's?
shifty has joined #lisp
obicons has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
shifty has quit [Ping timeout: 248 seconds]
Oladon has joined #lisp
smasta has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 248 seconds]
comborico1611 has quit [Quit: Konversation terminated!]
caltelt_ has quit [Ping timeout: 264 seconds]
figurehe4d has quit [Quit: Leaving]
smasta has joined #lisp
buffergn0me has joined #lisp
fikka has joined #lisp
orivej has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 256 seconds]
Pixel_Outlaw has joined #lisp
fikka has joined #lisp
gabiruh has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
figurehe4d has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
milanj has quit [Quit: This computer has gone to sleep]
fikka has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
mathrick has joined #lisp
vitali has joined #lisp
pierpa has quit [Quit: Page closed]
fikka has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
brendyn has joined #lisp
vmmenon has joined #lisp
robotoad has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
great_beginner has joined #lisp
fikka has joined #lisp
impulse has quit [Read error: Connection reset by peer]
impulse has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
vitali has quit [Ping timeout: 245 seconds]
bigfondue has joined #lisp
pierpal has quit [Quit: Poof]
vitali has joined #lisp
pierpal has joined #lisp
gabiruh has joined #lisp
fikka has joined #lisp
gabiruh has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 276 seconds]
rumbler31 has joined #lisp
fikka has joined #lisp
Trystam has joined #lisp
Tristam has quit [Ping timeout: 260 seconds]
Trystam is now known as Tristam
fikka has quit [Ping timeout: 248 seconds]
xlei has joined #lisp
Oladon has quit [Quit: Leaving.]
figurehe4d has quit [Remote host closed the connection]
figurehe4d has joined #lisp
Oladon has joined #lisp
f1gurehead has joined #lisp
fikka has joined #lisp
f1gurehead has quit [Remote host closed the connection]
f1gurehead has joined #lisp
figurehe4d has quit [Ping timeout: 240 seconds]
great_beginner has quit []
fikka has quit [Ping timeout: 248 seconds]
skapata has quit [Remote host closed the connection]
jkordani has quit [Read error: Connection reset by peer]
rumbler31 has quit [Remote host closed the connection]
fikka has joined #lisp
f1gurehead has quit [Quit: Leaving]
figurehe4d has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
figurehe4d has quit [Remote host closed the connection]
gabiruh has joined #lisp
fikka has joined #lisp
EvW has joined #lisp
gabiruh has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 260 seconds]
flazh has quit [Ping timeout: 265 seconds]
EvW has quit [Ping timeout: 264 seconds]
milanj has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
flazh has joined #lisp
fikka has joined #lisp
Trystam has joined #lisp
Tristam has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 256 seconds]
Trystam is now known as Tristam
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
charh has quit [Quit: jksd]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
gabiruh has joined #lisp
fikka has joined #lisp
<mfiano>
Hello!
gabiruh has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 260 seconds]
<mfiano>
I have a stupid question perhaps, but I'm toying with compiler macros for the first time in all my years of Lisp use. Anyway, is there anyway to prevent the original function from being called in the REPL? It seems to work in a compiled file, but obviously not in the REPL.
akkad has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
smasta has quit [Ping timeout: 268 seconds]
rumbler31 has joined #lisp
caltelt_ has joined #lisp
sauvin has joined #lisp
sauvin has quit [Max SendQ exceeded]
baho has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
igemnace has joined #lisp
SaganMan has quit [Ping timeout: 264 seconds]
SaganMan has joined #lisp
fikka has joined #lisp
baho has quit []
fikka has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Read error: Connection reset by peer]
FreeBirdLjj has joined #lisp
SaganMan has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
FreeBird_ has joined #lisp
SaganMan has joined #lisp
Pixel_Outlaw has quit [Remote host closed the connection]
FreeBirdLjj has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 240 seconds]
gabiruh has joined #lisp
fikka has joined #lisp
gabiruh has quit [Ping timeout: 240 seconds]
krwq has quit [Remote host closed the connection]
makomo has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
gector has quit [Read error: Connection reset by peer]
gector has joined #lisp
buffergn0me has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
<jackdaniel>
mfiano: you have to put it in other function and then call it
<jackdaniel>
say FOO has a compiler macro involved
<beach>
Good morning everyone!
<jackdaniel>
((lambda () (foo 2))) ; ←
<jackdaniel>
hey beach
<jackdaniel>
mfiano: or, if your implementation doesn't compie repl expressions by itself, then: (funcall (compile nil '(lambda () (foo 2))))
<mfiano>
jackdaniel: thank you
fikka has quit [Ping timeout: 264 seconds]
_whitelogger has joined #lisp
gousuto has quit [Read error: Connection reset by peer]
fikka has joined #lisp
Smokitch has joined #lisp
FreeBirdLjj has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
orivej has joined #lisp
caltelt_ has quit [Ping timeout: 245 seconds]
littlelisper has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
Tordek has quit [Ping timeout: 256 seconds]
vert2 has quit [Ping timeout: 240 seconds]
vlatkoB has joined #lisp
vert2 has joined #lisp
makomo has quit [Ping timeout: 260 seconds]
bend3r has quit [Ping timeout: 240 seconds]
bend3r has joined #lisp
gabiruh has joined #lisp
Tordek has joined #lisp
fikka has joined #lisp
gabiruh has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 240 seconds]
littlelisper has quit [Quit: Yaaic - Yet another Android IRC client - http://www.yaaic.org]
makomo has joined #lisp
sauvin has joined #lisp
fikka has joined #lisp
doesthiswork has quit [Quit: Leaving.]
al-damiri has quit [Quit: Connection closed for inactivity]
jack_rabbit has joined #lisp
Smokitch has quit []
fikka has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
Oladon has quit [Quit: Leaving.]
fikka has quit [Ping timeout: 240 seconds]
pjb has quit [Remote host closed the connection]
pjb has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
nostoi has joined #lisp
fikka has joined #lisp
nostoi has quit [Client Quit]
Trystam has joined #lisp
Tristam has quit [Ping timeout: 264 seconds]
trittweiler has joined #lisp
Trystam is now known as Tristam
MoziM has joined #lisp
guaqua has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 255 seconds]
<MichaelRaskin>
beach: I guess the core I have can be trivially wrapped to suppotr file-agnostic code debugger; not sure what is a good way to add location support, maybe a reader that saves a hashtable of «Form object -> storage location»
<beach>
We have a reader that keeps source information. It is called Eclector.
shangul has joined #lisp
<MichaelRaskin>
(I have only tested it to implement a _tracer_, of course)
<shangul>
Error: there is not such function: I
<MichaelRaskin>
I thought Eclector returns a special code object?
<MichaelRaskin>
I.e. not something I can feed directly to macroexpand.
<MichaelRaskin>
But yes, and adapter to Eclector sounds like a good idea.
<beach>
It can return a concrete syntax tree, but one of the protocol functions on that returns the underlying expression.
FreeBirdLjj has quit [Remote host closed the connection]
<flip214>
beach: mail incoming - in case you don't read the u-b.fr mails regularly. Have a nice weekend!!
FreeBirdLjj has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
<beach>
Saw it. Thanks.
<MichaelRaskin>
beach: I guess I should declare that recovery-after-macroexpand in eclector should work well enough with what I do not to think about it right now
random-nick has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
Trystam has joined #lisp
<beach>
MichaelRaskin: I am afraid I don't understand what your plan is in sufficient detail to understand things like that.
Tristam has quit [Read error: Connection reset by peer]
igemnace has quit [Remote host closed the connection]
<MichaelRaskin>
The idea is: I have written a wrapper macro that checks a global variable before and after every form to maybe call some operation
<MichaelRaskin>
Right now to skip all the debug code in the function it just branches on the debugger-active variable in the beginning of every function; maybe the compiler is more thread-safe and won't optimise out the checks, in which case I need to improve that place a bit more.
doesthiswork has joined #lisp
<MichaelRaskin>
I want to give every thread a thread-local binding for the relevant global variables, and put callbacks for editing thread-local copies into a global hashtable.
<MichaelRaskin>
When debugger is activated, it sets the callback to do something, for example to talk with the debugger thread (or debugger process) and ask it if it is OK to continue
<beach>
I think I understand.
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
makomo has quit [Quit: WeeChat 2.0.1]
<MichaelRaskin>
I hope eclector will not be unhappy about my wrapper trick with character pushback.
<beach>
What is your wrapper trick with character pushback?
random-nick has quit [Remote host closed the connection]
<MichaelRaskin>
I set a reader-macro on #\( that unreads that #\( reads with the previous readtable, then wraps the form in a macro
<beach>
I see.
gabiruh has joined #lisp
<beach>
Since you are calling READ, Eclector won't give you a CST. Just an expression.
random-nick has joined #lisp
<beach>
Why do you put newlines after LET*?
<beach>
And why are the bindings indented the same as the body?
<MichaelRaskin>
Well, the bindings block is indented the same as the body, the bindings are one character to the right.
milanj has joined #lisp
<MichaelRaskin>
Frankly, I would still prefer Pascal-style formatting in every language…
<beach>
Why is the list of bindings indented the same as the body?
<beach>
It shouldn't be.
gabiruh has quit [Ping timeout: 240 seconds]
<MichaelRaskin>
Yeah, I know, in TRAG code I write for Irène I do start the bindings block on the same line as let*
<MichaelRaskin>
I don't like these deep indents, though
<beach>
Well, it's not about personal preference. It is about conventions that exist for better communication between people. But, sure, as long as you keep your code to yourself, you can do what you want.
<beach>
But since you showed it to me, I had to tell you how distracting that style is to someone who is used to the Common Lisp conventions.
<MichaelRaskin>
Can I use something from SICL as external-process autoformat tool?
<beach>
You can use anything from SICL you like. But I don't know what an external-process autoformat tool is.
<MichaelRaskin>
Something that I can feed a file and get the newlines removed according to the conventions.
<beach>
Hmm, no I don't know of any tool like that. It would be a good thing to have though.
pagnol has joined #lisp
<MichaelRaskin>
Does Eclector preserve comments in CSTs? And specific reader macro use?
<beach>
In CST, it doesn't preserve comments, but it has hooks for doing that, and I do it in Second Climacs, though Second Climacs is still not using Eclector. I am gathering up the courage go switch.
lumm has joined #lisp
<MichaelRaskin>
Can I start Second Climacs completely headless and ask it to reformat a file?
<beach>
I am afraid not. It is not at that point yet.
fikka has joined #lisp
<LdBeth>
Hack on the pretty printer?
<MichaelRaskin>
Pretty printer is not enough, I want to keep reader macros and comments
varjag has quit [Remote host closed the connection]
<beach>
Such a tool would be great also for the purpose of education. People could submit their code to it and have it comment on the indentation and spacing style.
<beach>
I guess I should try to isolate that code in Second Climacs so that it could be used also as a separate tool.
<MichaelRaskin>
Can I just instantiate something like SC buffer and apply the reformatting command?
varjag has joined #lisp
<beach>
I haven't fully implemented the indentation stuff yet, so no, not yet.
<MichaelRaskin>
Ah.
<LdBeth>
MichaelRaskin: if you specify corespondent print method for reader macros, it would work
<beach>
LdBeth: In Second Climacs, I preserve comments and other material for which a reader macro return no values. Eclector can do that as well and I will replace the modified reader in Second Climacs with Eclector soon. You can't arbitrarily insert comments into code, because you would then violate the syntax of many special forms.
<beach>
LdBeth: Take for instance (let #| comment |# ((var val)) body).
<beach>
If the comment turns into a CONS cell, then it will be parsed as if it were the list of bindings.
orivej has quit [Ping timeout: 260 seconds]
fm4d has joined #lisp
igemnace has joined #lisp
<MichaelRaskin>
I think he meant that (let …) is now a cons cell with a comment attached
<beach>
I don't see how such a scheme could work in all situations.
moei has quit [Quit: Leaving...]
<MichaelRaskin>
I don't know either
<MichaelRaskin>
There are some free-standing commentaries from time to time
shka_ has joined #lisp
<beach>
flip214: You can omit the nursery collection, but you must do something essentially equivalent, because you need to inform the global collector what objects are live. Otherwise, you have to assume that all object in the global heap that were live after the previous collection are still live, and that would kind of defeat the purpose of garbage collection in the first place.
gigetoo has quit [Ping timeout: 265 seconds]
robotoad has quit [Quit: robotoad]
<beach>
flip214: And I really don't see why you would want to skip the nursery collection.
fikka has quit [Ping timeout: 260 seconds]
<fm4d>
Hi, I am slightly confounded by this behaviour: (funcall #'defparameter (read-from-string "test") 123)
quazimodo has joined #lisp
<fm4d>
It seems like funcall does not work with macros
<beach>
Correct.
<beach>
Macros are not functions.
<fm4d>
Is there some alternative?
<beach>
You can funcall the macro function, but you need to be aware of its signature.
<fm4d>
Basically I need to call a macro with value that is a result of evaluation
<fm4d>
defparameter with result of (read-from-string ...)
robotoad has joined #lisp
shrdlu68 has quit [Ping timeout: 255 seconds]
<fm4d>
So I should use macroexpand?
<beach>
You might as well use EVAL in situations like that.
fikka has joined #lisp
pjb has quit [Read error: Connection reset by peer]
<fm4d>
Could you provide me with an example please?
<pjb>
but instead, you should use a function to define a global dynamic variable at run time.
<pjb>
and go home and rethink seriously your life.
<jackdaniel>
another way around this is (defparameter #.(read-from-string "hello") 234)
<pjb>
I mean, why do you want to define global dynamic variables at run time? This makes no sense, since your program,being already compiled, cannot make use of it!
<fm4d>
Well, I want to load configuration for entire program from text file
<pjb>
Yes, what jackdaniel does would work at compilation-time, so it'd be ok. A better way to do it would be to write a macro expanding to that defparameter form.
<pjb>
fm4d: then you don't want to do such a thing.
<fm4d>
What do you recommend instead?
<pjb>
I mean, just store the configuration in some object (structure or CLOS instance) and bind it to a variable known to your program, such as (defvar *configuration* (make-default-configuration))
<pjb>
fm4d: and think about it: it's much better to keep the configuration in objects, since then you can pass it around as a single reference, instead of having a ton of global variables. It allows you to run easily with different configurations, either at the same time in different threads, or sequentially.
<fm4d>
Sure, to be honest I just wanted to practice some operations with filesystem etc. and this seemed like a reasonable thing to do.
<pjb>
fm4d: now, since you use lisp, there's another way to load configurations.
<fm4d>
:]
<pjb>
fm4d: (load "configuration.lisp")
<LdBeth>
beach: Simply treat #|form|# as normal atom, which is what the text editor normally do. This reader would not be used for eval
<pjb>
You only have to document a "configuration language" for the user to use in his lisp configuration source.
<fm4d>
pjb actually after fierce fight I managed to make asdf work, so no more load :D
<pjb>
This let the user use CL and algorithms to define his configurations. It can be handy for sophisticated users. Like emacs users with ~/.emacs
fikka has quit [Ping timeout: 260 seconds]
<fm4d>
Hm
<LdBeth>
beach: although it would be tough if someone wants complex ASCII art in comments
gigetoo has joined #lisp
<pjb>
fm4d: (defun load-configuration () (let ((*package* (load-time-value (find-package "CONFIGURATION-LANGUAGE")))) (load "configuration.lisp"))) you don't do the load while compiling, this has nothing to do with asdf. This is loading the user's configuration file.
<pjb>
Actually you would look it up in (user-homedir-pathname) or one of the XDG config directories.
<fm4d>
Well, I've though that I would make the config loading a part of asdf so asdf:load-system also loads the configurations
fikka has joined #lisp
<fm4d>
And drops me right into a working environment
<fm4d>
Is that wrong? :X
<fm4d>
Its more of a local configuration for a not very large app
<fm4d>
So what I really want is to do (asdf:load-system ...) (in-package ...) and be ready to go
<fm4d>
I have to return to the books, I didn't really get into the compilation aspect of common lisp yet
<fm4d>
I've came from scheme
<pjb>
It's the same.
<pjb>
There's also the distinction between compilation-time and run-time.
zhrek has joined #lisp
<LdBeth>
ASDF is like Unix’s make
<LdBeth>
Usually people wouldn’t depend on make to load configs, right
<fm4d>
Yes, but I have always considered only the runtime aspect I guess, books like SICP or Little Schemer don't delve into implementation details
<pjb>
Imagine how starnge it would be to execv("make"…) to load a configuration file!
<fm4d>
Okay, makes sense :D
oni-on-ion has quit [Ping timeout: 240 seconds]
gigetoo has joined #lisp
<fm4d>
And my workflow with asdf during development is ok, at least? Using asdf:load-system to correctly load dependencies and all files into one package and then in-package?
fikka has joined #lisp
<pjb>
If you will. But nowdays, I just use ql:quickload to load everything. So if it happens that a dependency is not installed, quicklisp will download and install it automatically.
<fm4d>
And how do you deal with packages?
<MichaelRaskin>
beach: by the way, is there a good way to add an entry for the readtable in a way that uses «default read behaviour» for some parts, and would use Eclector if called by Eclector?
<pjb>
fm4d: packages are unrelated to systems.
<fm4d>
I mean, I have the defpackage in package.lisp which is loaded first by asdf in serial manner.
<pjb>
good for you.
<fm4d>
So I can just include (in-package ...) in every file
<pjb>
quicklisp uses asdf.
<fm4d>
Well, Ill get to that.. sometimes.. later..
<fm4d>
*sometime
<pjb>
I avoid :serial in asdf, so that only a minimum set of file need to be recompiled and reloaded when I edit one.
<LdBeth>
MichaelRaskin: there’s a macro WITH-STANDARD-IO-SYNTAX
fikka has quit [Ping timeout: 245 seconds]
<MichaelRaskin>
It is in a different direction
<MichaelRaskin>
I already have a reference to the read-table I want to use
<MichaelRaskin>
But if I use read, Eclector will not save position information for the form I read
markoong has joined #lisp
fikka has joined #lisp
<LdBeth>
MichaelRaskin: you can redefine readtable inside the reader function
<MichaelRaskin>
That I know
<MichaelRaskin>
That I do
<MichaelRaskin>
I have working code for the normal reader case
<MichaelRaskin>
The question is if there is a cheap way to support non-default reader
<LdBeth>
You mean pass the entire form to eclector?
<MichaelRaskin>
When I call read with another readtable, can I easily call eclector if I was called by eclector
shangul has quit [Ping timeout: 240 seconds]
<pjb>
MichaelRaskin: in lisp it's always cheap to call another operator.
<pjb>
Instead of calling (cl:read stream), call (eclector:read stream); cannot be cheapest.
_whitelogger has joined #lisp
<fm4d>
Yes, but the techniques and approaches should be at least similar, aren't they?
<pjb>
fm4d: however, the implementation techniques taught in LiSP can of course be used in CL. It's just a little more comple in CL, (the CL environments are more complex).
robotoad has quit [Quit: robotoad]
<pjb>
Definitely.
<fm4d>
I mean, for udnerstanding the general concepts etc.
<pjb>
Yep.
<fm4d>
Ok, thx.
<pjb>
And you can read the sources of SICL or some other CL implementation while reading LiSP, to see how it's done for CL.
<beach>
MichaelRaskin: I don't know. You would have to ask scymtym.
<fm4d>
Hm. Its quite hard to find a line between actually getting hands-on experience with CL without complete knowledge and just reading books like LiSP, PAIP, Let over Lambda without much experience in CL.
<beach>
Are you saying the books are too hard to understand?
<beach>
fm4d: I probably didn't understand what you were trying to say.
<fm4d>
Its not that they are too hard (they are hard, but in the way that you simply have to put a lot fo time and concentration into them), but about finding a good line between reading books without actually writing much code (memory fades fast for things you dont put into action) and writing code without having all the knowledge from the books.
<random-nick>
I think he meant to say that it is hard to know how much of CL you need to know in order to use it
<fm4d>
Yep
<beach>
I see.
<beach>
fm4d: I think it is with Common Lisp as with everything else. You start off by doing simple things, and over time, you learn more conventions, more tricks, etc.
varjag has quit [Ping timeout: 264 seconds]
<LdBeth>
You can use functional paradigm in CL if you like, that’s not a problem
Lauven has joined #lisp
<fm4d>
Yeah, but it really feels like this is much more prominent in CL (comparing with the standard languages used in the industry)
EvW has joined #lisp
<beach>
fm4d: I think that's normal. Common Lisp has more features than most languages.
<fm4d>
Thanks to both scarcity of resources and the.. the way CL is alien to everything else and many features and tools are more elaborate and complicated.
<fm4d>
Not that I consider it 'wrong', not at all, it just makes things little harder to get into.
<beach>
fm4d: Sure. But once you do, it is very gratifying.
lumm has quit [Read error: Connection reset by peer]
josemanuel has joined #lisp
lumm has joined #lisp
<makomo>
fm4d: i'm not so sure. C++ feels a lot similar to me in that regard
<makomo>
s/a lot/very/
<fm4d>
Maybe its about the order of exposure. I was exposed to C++ when I was about.. 13 or so and then all the stuff like Java, Python, C# etc.
<pjb>
fm4d: in general, learning programming requires writing and reading a lot of programs. You have to do both: read books, write programs, read programs and loop!
<makomo>
fm4d: same :-)
<fm4d>
And all these languages and envrionments kind of build on the same principles
<makomo>
i learned C++ as my first language pretty much
<makomo>
but learning C++ in detail has the same problems that you described imo
<pjb>
and don't be in a hurry, it takes 10 years to start being proficient in anything.
<fm4d>
And then you come across something totally alien like lisp and not only the language is alien but everything else.
<makomo>
there's *tons* of stuff to learn
<beach>
Forcing someone to use C++ that early in life is extremely cruel.
<makomo>
haha
<makomo>
well i wasn't really forced, it was my own decision
<makomo>
and a decision i'm grateful to myself for
<beach>
Oh!
<fm4d>
:D
<makomo>
i know that C++ is an ugly and warty language, but learning it has a lot of benefits
<fm4d>
I literally have no idea why I bought C++ in 21 days as a teenager ~13 years ago.
<pjb>
fm4d: and console yourself, that's nothing compared to the 4,500+ classes and 350,000+ methods of Android, and similar in iOS or any other framework.
<fm4d>
Such mental torture in such young age.
<pjb>
fm4d: the CL package exports only 678 symbols.
<LdBeth>
If I’m 13, I would definitely not choose CL either
<pjb>
scheme is nice for youngsters.
<makomo>
it's very likely that someone who's 13 has never even heard of lisp
<makomo>
you have to be in the right environment to find it at such a young age
<pjb>
makomo: I heard of lisp when I was 13. And that was in 1977!!!
<makomo>
probably because it was 1977
<pjb>
Unfortunately, it was out of reach…
<makomo>
:-)
<beach>
fm4d: I agree with pjb. You need to read code, write code, read books, expose your code to others, follow advice, and the loop.
<makomo>
pretty much, there aren't any magical tricks to it
<pjb>
Nowadays, it's easy to read programs, there are a lot of them available on github, etc.
<fm4d>
pjb I cant really comment on android, but for example Python, which I spent some years working in professionally, is really large, sometimes not intuitive, complicated etc., but the difference is that you can have literally 80 IQ and still find all your answers online.
<pjb>
you will also find answers for CL. news:comp.lang.lisp irc://irc.freenode.org/#lisp http://cliki.net etc.
<fm4d>
Its like.. you don't rely on your own understanding but on the feeling that 'it is somewhere on the net'
<makomo>
also, all of the "popular" books on lisp that you'll find are really good
<fm4d>
Agreed, github is a godsend in this regard.
<makomo>
LoL, PAIP, CLOS, AMOP, On Lisp, ANSI Common Lisp, LiSP, etc.
<makomo>
all of them are very good
<fm4d>
Thats a funny thing about lisp. You can literally put all the good books on one shelf.
<beach>
fm4d: You can find answers here.
<makomo>
i haven't seen a "Lisp for dummies" or "Lisp in X days" yet
<makomo>
must be a good sign
<beach>
fm4d: There are plenty of knowledgeable people hanging out in #lisp.
<pjb>
lisp is not for dummies.
<beach>
makomo: Definitely a good sign, yes.
<makomo>
:-)
<fm4d>
beach yeah, totally, I think it is.. cultural somehow.
<zhrek>
Is PCL not in vouge?
<pjb>
What about: "Lisp in 3650 days"?
<MichaelRaskin>
It is only a question of popularity, though
<makomo>
zhrek: PCL too, how could i forget!
<fm4d>
It feels better to find answers without personal interaction
<makomo>
pjb: let's introduce the constraint, X <= 30
<MichaelRaskin>
I mean, learning Lisp in 21 days as well as the outcome of C++ in 21 days is completely feasible
<fm4d>
makomo what is AMOP?
<pjb>
Of course, you can always teach a subset.
<makomo>
Art of the Meta-Object Protocol
<pjb>
even a useful subset.
<beach>
minion: Please tell fm4d about AMOP.
<minion>
fm4d: direct your attention towards AMOP: AMOP: The Art of the Metaobject Protocol, an essential book for understanding the implementation of CLOS and advanced OO. See <http://metamodular.com/CLOS-MOP>
<fm4d>
makomo uff, okay, I thought I miss a book in my collection :D
<makomo>
:-)
<fm4d>
But nope, its there
<beach>
You have it already?
<beach>
fm4d: You might want to put off reading it until you have some significant experience with using CLOS for ordinary applications.
<makomo>
i just thought of another book that uses CL as its main language
<makomo>
a quite interesting one actually
<fm4d>
beach: I've decided to just wing it without CLOS, with alists mostly. Its.. maybe dumb but it works for my small projects.
<makomo>
Calendrical Calculations
<makomo>
everything you've ever wanted to know about date, time, timezones, calendars, etc. etc.
<makomo>
it's not about CL, but it uses CL
milanj_ has joined #lisp
housel has joined #lisp
<beach>
fm4d: I see. Using a standard class from time to time is not hard though. The hard part is designing a reasonable protocol using generic functions.
<LdBeth>
please avoid use lists
<makomo>
fm4d: believe me, you'll want to get familiar with CLOS as soon as possible
<makomo>
not because it'll make your life easier, but because it'll open your eyes
<makomo>
and then maybe make your life easier of course :-)
<fm4d>
I absolutely believe you and I am looking forward to it, I am just trying to mix up theory with practice and exposure to deeply entrench the knowledge.
milanj has quit [Ping timeout: 256 seconds]
<fm4d>
Simply reading about programming language without practicing it is.. wasted time.
<makomo>
well i guess so, but you can always spend some time reading and then go on to programming
<makomo>
like in phases
<makomo>
i think i've spent at least a month or two just reading about lisp :-)
<makomo>
playing in the REPL from time to time, but never writing anything worthwhile
jmercouris has joined #lisp
<fm4d>
Yeah, but if you don't follow with practice and instead you spend next 6 times with other stuff, you realize that you don't really remember much.
<makomo>
i guess the key is actually following up with a programming phase because unless you do, you'll probably forget what you've read
<makomo>
yup
<fm4d>
BTW I am really looking forward to AOMP, that books has a really strange vibe around it, like some ancient grimoire full of knowledge from different times.
<fm4d>
But to be honest most LISP books are like that :D
<jmercouris>
LdBeth: why should one avoid using lists?
<makomo>
fm4d: i know right, it's like the forgotten scrolls of the ancients
<makomo>
btw, did you guys know that AMOP's cover was hand-drawn by des Rivieres' wife?
<makomo>
interesting trivia
<fm4d>
makomo: I have 'scrolls' reserved for actual papers by McCarthy :P
<LdBeth>
jmercouris: it will form a habit which prevents one from thinking at large scale
<makomo>
fm4d: haha
<jmercouris>
LdBeth: Do you have any evidence to support this notion
<jmercouris>
?
RemoteFox has joined #lisp
<RemoteFox>
ola
lnostdal has quit [Ping timeout: 265 seconds]
<makomo>
\o
<beach>
Hello RemoteFox.
<jmercouris>
LdBeth: I think your claim is unsubstantiated, if you don't know something for certain, its best to stay mum lest you spread misinformation
<beach>
RemoteFox: Are you new here? I don't recognize your nick.
<fm4d>
jmercouris I am also curious about that. To me lists feels a lot like dictionaries in Python. You simply use them for nearly everything thats not complicated enough to use OOP.
<RemoteFox>
beach: I am
<LdBeth>
jmercouris: I think at the beginning of J for C Programmer there’s a good example, C people implement a poor file scanner by hand, while in J a more efficient build in parallelized form can be used
<beach>
RemoteFox: What brings you to #lisp?
<RemoteFox>
fm4d just told me about this channel
<beach>
Oh, OK.
<RemoteFox>
I have been recreationally programming in lisp few years back
<beach>
In Common Lisp?
<fm4d>
RemoteFox is a passive lisper :D
<RemoteFox>
common lisp and also in rebol, which is just masked lisp
<RemoteFox>
fm4d: shush
<jmercouris>
fm4d: that or simple structs
<jmercouris>
LdBeth: that might be a good example, but it isn't empirical evidence
<jmercouris>
LdBeth: I suspect there may be truth to what you say, but without evidence, it is not worth saying, or it should be phrased in a way that indicates its uncertainty
<RemoteFox>
right now I do mostly python (job, my own projects), but I am trying to build a self interpreter
<jmercouris>
e.g. "it might be that using lists only stunts your growth as a programmer"
<fm4d>
jmercouris Yes, you can always turn struct/dict/etc into class later, if you need to bind data with behaviour or to inherit it etc.
<pjb>
jmercouris: using anything only stunts your growth as a programmer (or anything). When you have a hammer, everything looks like nails!
<pjb>
jmercouris: don't have a hammer. have a toolbox!
<fm4d>
I've always believed that from simple to complicated is a proper pattern of development (at least for rapid prototyping and bottom-up approach)
<jmercouris>
pjb: one must fully understand the hammer before moving onto the screwdriver
<fm4d>
RemoteFox you should mention that 'self' is a language, 'building self interpreter' can be understood in a weird manner.
<fm4d>
RemoteFox: that makes you look crazy
<fm4d>
(:D)
<RemoteFox>
:D
<pjb>
fm4d: yeah but actually all way are good ways: bottom-up, top-down, inside-out, outside-in. What matters, is iterative and interactive programming.
<pjb>
fm4d: mostly, programming is a discovery process, so you can progress in any direction you like or can, starting from known, and discovering the unknown. Otherwise you just use libraries.
<pjb>
(using libraries is not programming).
<fm4d>
pjb: That remind me of how wonderful is SLIME, the interactive and reflective capabilities.
<pjb>
jmercouris: not necessarily. You can have an overview of each tool before going deeper and deeper in each. Since some tools must be used in combination, it's better to do it this way.
<jmercouris>
pjb: I'm not sure what is better or worse, I've done both and it is hard to tell
<jmercouris>
for Lisp I started with a very shallow view of everything, and I forgot so many things
<jmercouris>
it is only now that I am going through a textbook to actually learn the language
<fm4d>
BTW: Is anyone here using some reader macros for hash-table syntax? Like CL21.
<LdBeth>
The most serious problem is, what if, you’re gonna use a language without list?
<fm4d>
It seems really clunky and hard to read in its default form.
<jmercouris>
if I had done this from the beginning I would be "using a hammer" for everything in the start, but I feel like it would be better
<jmercouris>
LdBeth: you can implement a list in any language
<Lauven>
For those of you who have read "Structure and interpretation of computer programs" would you recomend it to someone with just couple of years of javascript experience or should I wait until I get a grasp of scheme and lisp before I dive into it and get more experience in general?
<jackdaniel>
Lauven: SICP is a great book and it is fine to read it without prior scheme / lisp experience
<jackdaniel>
go for it
<fm4d>
Lauven it is actually written for people without prior exposure to lisp, I believe
* LdBeth
only a few chapters before
<Lauven>
Great. Thank you
MoziM has quit [Quit: WeeChat 2.1]
FreeBirdLjj has quit [Remote host closed the connection]
EvW has quit [Ping timeout: 255 seconds]
doesthiswork has quit [Quit: Leaving.]
EvW1 has joined #lisp
jmercouris has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 264 seconds]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
fikka has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
scymtym has joined #lisp
hetayh has joined #lisp
hetayh has quit [Client Quit]
pjb has quit [Remote host closed the connection]
SaganMan has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 260 seconds]
pjb has joined #lisp
shifty has joined #lisp
fikka has joined #lisp
pjb has quit [Remote host closed the connection]
papachan has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
FreeBirdLjj has joined #lisp
doesthiswork has joined #lisp
fikka has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
Lauven has quit [Quit: leaving]
didi` has quit [Ping timeout: 240 seconds]
gabiruh has quit [Ping timeout: 240 seconds]
Lauven has joined #lisp
paul0 has quit [Quit: Leaving]
lnostdal has joined #lisp
Smokitch has joined #lisp
Lauven has quit [Quit: leaving]
gabiruh has joined #lisp
Lauven has joined #lisp
fisxoj has joined #lisp
varjag has joined #lisp
flazh has quit [Ping timeout: 264 seconds]
Lauven has quit [Quit: leaving]
Lauven has joined #lisp
flazh has joined #lisp
beach has quit [Ping timeout: 245 seconds]
beach has joined #lisp
quazimodo has joined #lisp
shangul has joined #lisp
igemnace has quit [Remote host closed the connection]
smurfrobot has quit [Remote host closed the connection]
Pixel_Outlaw has quit [Quit: Leaving]
<ted_wroclaw>
Hi guys. Has anyone tried to build cltl2 from the latex source? I checked github and didn't find anything...
Lauven has quit [Quit: leaving]
wigust has joined #lisp
Naergon has joined #lisp
karlosz has quit [Ping timeout: 276 seconds]
karlosz has joined #lisp
shangul has quit [Ping timeout: 265 seconds]
milanj__ has quit [Quit: This computer has gone to sleep]
karlosz has quit [Client Quit]
karlosz has joined #lisp
<beach>
ted_wroclaw: Are you saying that you don't have the source?
<beach>
Why do you want to build it?
<ted_wroclaw>
I have the source, but I got an error when I tried to build it.
<ted_wroclaw>
I want to resize it so that it looks a little better when printed on A4 (or us letter) paper
<beach>
Oh, I see.
<ted_wroclaw>
It's not critical, as I have a printed copy of the book, but it would be nice.
FreeBirdLjj has quit [Remote host closed the connection]
housel has quit [Remote host closed the connection]
housel has joined #lisp
FreeBirdLjj has joined #lisp
<beach>
It looks like it is written in an old version of LaTeX and the compatibility mode can not fix it.
<beach>
There is a message saying it is very likely the style file.
jibanes has quit [Quit: Changing server]
shifty has quit [Ping timeout: 255 seconds]
<ted_wroclaw>
Are you using texshop?
fikka has quit [Ping timeout: 240 seconds]
<beach>
ted_wroclaw: No, I was just using pslatex because there seem to be PostScript file for the pictures.
jibanes has joined #lisp
fisxoj has quit [Ping timeout: 260 seconds]
<ted_wroclaw>
Okay. I got the same error. I'm not a latex guru, but I'll see if I can find something on repairing it. I've always regretted not becoming more proficient with latex.
<beach>
I have not been willing to put in the time.
fikka has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
<ted_wroclaw>
Me neither. I usually just hack around until I get whatever I'm working on to look nice and leave it at that. Then I forget how I did it. My template document header is an enormous collection of commented out packages. Shameful, really.
kajo has quit [Read error: Connection reset by peer]
mega_beginner has quit []
smasta has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
beach has quit [Ping timeout: 268 seconds]
fikka has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
FreeBirdLjj has joined #lisp
smasta has quit [Ping timeout: 260 seconds]
jmercouris has joined #lisp
skapata has joined #lisp
brendyn has quit [Ping timeout: 264 seconds]
ted_wroclaw has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
scymtym has quit [Ping timeout: 255 seconds]
Jesin has quit [Quit: Leaving]
dddddd has quit [Remote host closed the connection]
karlosz has quit [Remote host closed the connection]
caltelt_ has joined #lisp
milanj__ has joined #lisp
buffergn0me has joined #lisp
jmsb has joined #lisp
karlosz has joined #lisp
skidd0 has joined #lisp
vitali has joined #lisp
karlosz has quit [Read error: Connection reset by peer]
karlosz has joined #lisp
beach has joined #lisp
scymtym has joined #lisp
caltelt_ has quit [Ping timeout: 256 seconds]
charh has joined #lisp
vitali has quit [Ping timeout: 255 seconds]
smasta has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
<skidd0>
Does anyone have a good resource on print/read from terminal?
robotoad has joined #lisp
jonh has joined #lisp
<jackdaniel>
you need to be more specific with your question
<jackdaniel>
standard print and read-line functions work fine in the terminal
<skidd0>
well, I have a program that uses unix-opts library to make an executable with flags
<skidd0>
one of these flags allows the creation of an object by prompting for a name and other info
<skidd0>
but, the program waits for input without displaying the prompt
<skidd0>
and, after i enter info and press return a few times, all the prompts THEN show up
<skidd0>
is this a stream issue?
buffergn0me has quit [Ping timeout: 256 seconds]
mflem has joined #lisp
<jackdaniel>
normally in the terminal lines are buffered, so you need to end your prompt with a new line (this may be changed, but I don't remember the specifities - it is a terminal emulator setting)
<jackdaniel>
also if you want something to be printed, you may call finish-output on stream
<skidd0>
ah
<skidd0>
that could be it
<skidd0>
they do all appear on the same line
<skidd0>
that seems to do it, thanks man
<jackdaniel>
sure
<skidd0>
has anyone done any work with object persistence? like cl-prevalance, where the objects are serialized and use transactions for updates. Or, another question, what's a common method for saving objects to disk?
<_death>
if they're printed in a generic way, maybe you can use the pretty printer
<flip214>
pjb: sorry, I'm doing electronic engineering right now... you know, using +-20% capacitors and so on....
dddddd has joined #lisp
EvW has joined #lisp
buffergn0me has joined #lisp
asarch has joined #lisp
detectiveaoi has joined #lisp
trittweiler has quit [Ping timeout: 240 seconds]
<pjb>
flip214: perhaps it's possible to do something with the pretty printer. Otherwise, wrap your floats in a clos object, and define a print-object method for them.
<Bike>
right want to do that anyway, so you can have components with the same nominal value but different tolerqances
<didi>
We should decide if we want to deprecate structs or not. /me votes for no, but he is not very bright
ryanbw has quit [Client Quit]
<buffergn0me>
Deprecate structs in what context?
<didi>
buffergn0me: In any of them. So we declare CLOS the successor.
<Bike>
defstruct usually defines a class
<buffergn0me>
Structs are really useful apart from generic functions and objects. For example with the :type options to generate accessors for lists/vectors returned by various things
mproll has quit []
<didi>
buffergn0me: Can structs define accessors to vectors?
pierpa has joined #lisp
<Bike>
if you give defstruct :type, it mostly just defines a bunch of functions to do (aref x 0) or whatever.