<ealfonso>
i'm annoyed by all the "package X also exports/shadows the following symbols..." warnings/errors when refactoring... can slime help me make refactoring easier?
smurfrobot has quit [Remote host closed the connection]
orivej has joined #lisp
igemnace has quit [Read error: Connection reset by peer]
igemnace has joined #lisp
<ealfonso>
I tried uninterning all the symbols, which worked. just wondering if there's a way for slime to do it for me
<PuercoPop>
(C-c x exports a symbol, and when called with a negative argument it unexports it)
<ealfonso>
PuercoPop thanks. good to know
thodg has quit [Ping timeout: 276 seconds]
brendyn has joined #lisp
smurfrobot has quit [Remote host closed the connection]
vitali has joined #lisp
vlatkoB has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
Kundry_Wag has joined #lisp
<aeth>
I usually just restart SLIME with M-x s-r-i-l when I change package definitions. It's (for me) faster than messing with uninterning, except maybe if it's just one.
Kundry_Wag has quit [Ping timeout: 264 seconds]
nickenchuggets has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
flamebeard has joined #lisp
robotoad has quit [Quit: robotoad]
vitali has quit [Ping timeout: 240 seconds]
<White_Flame>
how do I get quicklisp to not muffle warnings & errors from a build?
smurfrobot has quit [Remote host closed the connection]
asarch has quit [Quit: Leaving]
Cymew has joined #lisp
brendyn has quit [Read error: Connection reset by peer]
brendyn has joined #lisp
andrei-n has joined #lisp
ealfonso has quit [Read error: Connection reset by peer]
ealfonso has joined #lisp
blu3r4d0n has joined #lisp
Cymew has quit [Ping timeout: 268 seconds]
karlosz has quit [Quit: karlosz]
smurfrobot has joined #lisp
<pillton>
Hmm (quickload "X" :verbose t) ?
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
fisxoj has joined #lisp
<akkad>
(ignore-errors (ql:quickload :x))
fraya has joined #lisp
fisxoj has quit [Quit: fisxoj]
Mutex7 has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
panji has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
red-dot has joined #lisp
smurfrobot has joined #lisp
Cymew has joined #lisp
ealfonso has quit [Read error: Connection reset by peer]
ealfonso has joined #lisp
Folkol has joined #lisp
<panji>
hi everyone, please help me with this problem. if i have class x and y, both class have slot a and b, is it better to create abstract class with slots a and b or create class a-mixin and b-mixin ?
smurfrobot has quit [Remote host closed the connection]
lumm has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<on_ion>
class with slot a and b
shrdlu68 has joined #lisp
karlosz has joined #lisp
<panji>
thanks, any particular reason not using mixin?
<theemacsshibe[m]>
are there any garbage collectors written in lisp (or anything remotely readable) i can glean from?
terpri has quit [Ping timeout: 276 seconds]
nckx has quit [Quit: Updating my GNU GuixSD server — gnu.org/s/guix]
innovati has quit [Ping timeout: 245 seconds]
smurfrobot has joined #lisp
nckx has joined #lisp
<shka>
theemacsshibe[m]: not open source i am afraid
<shka>
sbcl has GC written in C
<shka>
don't know about ccl
smurfrobot has quit [Remote host closed the connection]
<theemacsshibe[m]>
that's a shame
<theemacsshibe[m]>
i'm just looking to make a tri-color GC since mark-and-sweep is kinda boring and isn't particuarly usable on a C64 with a slow 6502 and quite a bit of memory
<jackdaniel>
I would be suprised if Mezzano had GC which is not written in CL
<jackdaniel>
but I don't know it as a fact
<jackdaniel>
you may ask on #mezzano
<theemacsshibe[m]>
movitz is a manageable size to hack, i'll see what theirs is like
smurfrobot has joined #lisp
<theemacsshibe[m]>
mezzano is kinda big though
<theemacsshibe[m]>
nice, there's a #'kill-the-newborns
<jackdaniel>
on the other hand it is actively developed, so you can ask questions
milanj has quit [Quit: This computer has gone to sleep]
shangul has joined #lisp
<akkad>
sigchild
<theemacsshibe[m]>
movitz has one of those copying things
<shangul>
is that a new introduced signal?
<theemacsshibe[m]>
i still want my full 64k like the cake-haver-and-eater i am
varjag has joined #lisp
ealfonso has quit [Ping timeout: 248 seconds]
Kundry_Wag has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<on_ion>
manual v. auto gc
Kundry_Wag has quit [Ping timeout: 240 seconds]
<theemacsshibe[m]>
manual gc:
<theemacsshibe[m]>
do you care about `#(important crap goes here)` [yN]?
<edgar-rft>
(loop :across heap :collec garbage)
<theemacsshibe[m]>
(loop for thing across heap do (cffi:free thing))
<theemacsshibe[m]>
i mean it'll all be garbage in the end right?
<xificurC>
why not just (malloc :as-much-as-the-sytem-allows-right-now) and write gc-free code?
<theemacsshibe[m]>
cause the timesharing people said it'd be annoying
Mutex7 has quit [Quit: Leaving]
<jackdaniel>
xificurC: because if function conses anything and you don't clean up the garbage, you'll run off the memory eventually
<theemacsshibe[m]>
that's true
Kundry_Wag has joined #lisp
<xificurC>
no. if you don't clean up the garbage you and you run off memory you obviously need more memory! It's so cheap now!
<jackdaniel>
sbcl allows inhibiting gc, you'll get exactly what you have suggested
<xificurC>
seeing the java projects here it's fun to watch how little actual work a server is able to perform
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<xificurC>
let 3 people work in parallel, oh no, OOM
<theemacsshibe[m]>
ooh i know, if we turn that off we can finally compete with --crap-- industry standard/grade languages like C++ and Rust
openthesky has joined #lisp
<theemacsshibe[m]>
must be something like SB-SUPER-VERY-SECRET::PUT-LANGUAGE-BACK-30-YEARSP /s
Kundry_Wag has quit [Ping timeout: 276 seconds]
scymtym has quit [Read error: Connection reset by peer]
<jackdaniel>
I'm pretty sure Lisp 30 years ago still had GC ;)
<theemacsshibe[m]>
oh! i was joking! cmon!
<xificurC>
wasn't it the first?
<theemacsshibe[m]>
GC is so (alexandria:random-elt '(80s 90s))
<theemacsshibe[m]>
yes mccarthy invented GC to make Lisp less painful
<flip214>
jackdaniel: I believe the originally designed lisp didn't, because it was just a theory --- and that can easily assume an unbounded tape...
<theemacsshibe[m]>
pedantically i don't think lisp had a "tape" since it wasn't a turing machine model
<theemacsshibe[m]>
instead mccarthy went for the lambda calculus
<shka>
i forgot about mezzano
<shka>
right
<jackdaniel>
flip214: out of curiosity I've checked LISP 1.5 manual
<ZigPaw>
Wikipedia quote: "Garbage collection was invented by John McCarthy around 1959 to simplify manual memory management in Lisp". So maybe the first one didn't had, as it was "on paper" but it got it pretty much quickly.
<jackdaniel>
it has an appendinx about GC
lumm has quit [Quit: lumm]
<edgar-rft>
that means garbage is collected at the end
heisig has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<beach>
theemacsshibe[m]: It is impossible to write a garbage collector in portable Common Lisp. You need direct access to memory. In fact, I don't think you can write it in valid C either.
<White_Flame>
certainly the "brains" of a GC could be written in CL, with the actual accesses being a clearly demarcated api
<theemacsshibe[m]>
well it might not be common but if your language exposed its heap and tagging functions there's a start
<beach>
Absolutely.
<White_Flame>
I'm also a C64 weirdo and have toyed around with GC ideas, but nothing concrete
<beach>
I firmly intend to write the SICL GCs in Common Lisp as much as possible.
Folkol has joined #lisp
<theemacsshibe[m]>
i wrote my sl3.c fork's garbage collector in valid C
<beach>
I seriously doubt that.
<theemacsshibe[m]>
it's not very good though and probably allocates a byte to hold the tag since i used an enum
<beach>
For example, as I recall, you can't legally convert an integer to an address in C.
<beach>
And you are not allowed to have pointers outside allocated arrays.
<beach>
... or structs.
<theemacsshibe[m]>
that is true
<theemacsshibe[m]>
it compiles with gcc and cc65 (and even borland turbo c with some work)
<beach>
So it is very hard to write things like that so that they respect the C standard.
<beach>
That's a totally different matter.
<on_ion>
beach: that is a very strict standard i think, integers and pointers are converted often
<theemacsshibe[m]>
pretty sure the usual ritual is something like (void*)integer_thing
<on_ion>
although days ago emacs just converted to pointers instead of integers for their 'lisp object' types
<beach>
on_ion: That's why I am saying that you have to rely on undefined behavior in order to make it work.
<on_ion>
(something about pointer bounds)
<theemacsshibe[m]>
yeah sl3.c uses casts to make that possible
<theemacsshibe[m]>
unions could get closer to levels of less frightening
<on_ion>
beach: nah, pointers *are* integers!
<beach>
on_ion: Sorry to hear that you think that.
<on_ion>
printf("%x\n", some_pointer); => 0x..
<theemacsshibe[m]>
it's all a binary sludge in memory after al
<theemacsshibe[m]>
*all
<White_Flame>
pointers aren't "C integers"
<on_ion>
beach: are you american? do you want to teach me or just look down on me?
mange has quit [Remote host closed the connection]
<on_ion>
memory addresses are numbers
<on_ion>
most C "optimisation" relies on that
<beach>
Neither.
<theemacsshibe[m]>
anyways this is a disgusting scheme imitation which is in no way safe or usable and shall never be distributed even though it's GPL3+
<theemacsshibe[m]>
it has poke so at least i can make fun colours though
<on_ion>
(ptr1 + ptr2) - ptr3 = ... have you guys used C at all? =) what goes on in our heads and what the compiler accepts are two different things
milanj has joined #lisp
<White_Flame>
and what the C standard says is undefined behavior is still undefined behavior
<beach>
on_ion: And what the compiler accepts is also different from what the standard allows.
<theemacsshibe[m]>
remember your C arithmetic: a[n] == n[a]
<theemacsshibe[m]>
anyways "principle of least astonishment" was what i was trying to get at with using unions
<on_ion>
beach: yep.
<jackdaniel>
there is uintptr_t in C99 to address the issue
yaewa has joined #lisp
yaewa has quit [Client Quit]
<jackdaniel>
so given newer standard pointers may be handled without relying on undefined behavior (just syaing)
<beach>
So I find it an interesting observation that, if you use C as a programming language for applications, it is nearly impossible to use because you have no automatic memory management, and you can't re-program assignment the way you can in C++, and if you use C as a programming language for system programming, then your code must be written to have undefined behavior.
moei has quit [Ping timeout: 248 seconds]
<theemacsshibe[m]>
i'm sure it's possible to not have undefined behavior
<White_Flame>
if you're doing system programming then all what matters is the environment guarantees
<White_Flame>
*is what
<beach>
White_Flame: Oh, I agree.
<theemacsshibe[m]>
my VGA driver has the line: struct vgac* terminal_buffer = (struct vgac*) 0xb8000;
<beach>
White_Flame: I am just saying that things like operating systems and device drivers are not written in "C", but in a particular implementation.
<theemacsshibe[m]>
oh that would be undefined, that's still an int i'm casting
<shrdlu68>
I find the dimorphism between "system programming" and the rest of programming itself interesting.
Folkol has quit [Ping timeout: 264 seconds]
<theemacsshibe[m]>
k&r please
schweers has joined #lisp
Folkol has joined #lisp
<theemacsshibe[m]>
i think any attempt at making C into something somewhat high level is a bad idea
<theemacsshibe[m]>
IMO a lot of C comes from pointer twiddling and low level stuff so trying to implement anything high level or non-C-like while still retaining C characteristics will just feel wrong and carry bad habits
m00natic has joined #lisp
lonjil has quit [Ping timeout: 260 seconds]
rumbler31 has quit [Remote host closed the connection]
<theemacsshibe[m]>
(this is what years of failed french lessons lead to. bad jokes.)
lonjil has joined #lisp
red-dot has joined #lisp
lumm has quit [Quit: lumm]
lumm has joined #lisp
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
_cosmonaut_ has joined #lisp
<beach>
theemacsshibe[m]: Sorry your French lessons were not satisfactory.
smurfrobot has joined #lisp
<theemacsshibe[m]>
they call their flag a "tricolore" when trying to not say it's french
<theemacsshibe[m]>
curioustBbeachualso have you ever tried being informal, Bbeach ?? ? beach?
<theemacsshibe[m]>
ok matrix broke.....erm
<theemacsshibe[m]>
have you ever tried being less formal, beach ?
<beach>
theemacsshibe[m]: Sure. Come to ELS, and you will see the less formal version of me.
HDurer has quit [Ping timeout: 260 seconds]
smurfrobot has quit [Ping timeout: 276 seconds]
HDurer has joined #lisp
HDurer has joined #lisp
Cymew has quit [Read error: Connection reset by peer]
Cymew has joined #lisp
Bronsa has joined #lisp
terpri has joined #lisp
lumm has quit [Quit: lumm]
shangul has quit [Ping timeout: 240 seconds]
<theemacsshibe[m]>
it's a bit far away
shangul has joined #lisp
<theemacsshibe[m]>
no lisp stuff in Australia
shangul has quit [Read error: Connection reset by peer]
<jackdaniel>
nice trip to Italy may widen your horizons ;-)
<theemacsshibe[m]>
i've got no money
<theemacsshibe[m]>
my plan of selling music to rent out servers to run fancy web apps to get out of home quickly isn't working well
<theemacsshibe[m]>
i've only made $5.50
SenasOzys has quit [Ping timeout: 240 seconds]
<beach>
You can get together with pillton and organize ALS.
<beach>
I'll show up.
<theemacsshibe[m]>
please re-read *** and reconsider that
<beach>
Sorry, I thought you hinted that you are in Australia, so I suggested organizing a Lisp Symposium there.
hjek has joined #lisp
panji has quit [Ping timeout: 256 seconds]
hhdave has joined #lisp
<theemacsshibe[m]>
i am in australia and i have no money
<theemacsshibe[m]>
also i don't know of many people who use lisp here, let alone australia-specific companies
<beach>
That's why I suggested talking to pillton.
SenasOzys has joined #lisp
makomo has quit [Ping timeout: 265 seconds]
<theemacsshibe[m]>
also i doubt i can actually run things, i'm not even out of high school
<beach>
Hmm, yeah, you might have to wait a bit.
wigust has joined #lisp
dddddd has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
<schweers>
hm, ELS 2019 starts on 01.04. ;)
<theemacsshibe[m]>
i suppose i can make fun of python people in computing at least
<theemacsshibe[m]>
isn't that half of being a lisp programmer?
<schweers>
making fun of people? not as far as I’m concerned. although I do pitty some other people. I’m also sure they pitty me.
Folkol has joined #lisp
makomo has joined #lisp
buoyantair has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
HDurer has quit [Ping timeout: 264 seconds]
<xificurC>
I started with a 100 line macro that was a `(lambda (x) (let (many-vars-here) (labels (many-functions-here) ...))). Switched it to a function and pulled out all the internal functions and variables. Now I have many small definitions almost all taking no arguments but modifying 7 toplevel specials
HDurer has joined #lisp
<xificurC>
it's funny how one can read and read about good design and still produce crap, constantly
<xificurC>
now I see thought that 1 should be toplevel, 4 should be grouped into 1 object and be an argument where needed along with the other 2. :(
<xificurC>
do you guys write more top-down or bottom-up? I can only make things nice after writing them out in horrific ways like described here
vlatkoB_ has joined #lisp
<schweers>
I try to write more in a bottom-up fashion, but I’d be lying if I claimed that it always turns out right. That’s okay though (I think).
<schweers>
bottom-up has the advantage that you can test your lower level stuff and actually run it, as opposed to coding top-down and having to mock everything out in order to test it.
EvW has joined #lisp
<xificurC>
this was bottom up, I just can't see what will I need before writing it all out first
red-dot has joined #lisp
<xificurC>
so, not sure if I'm an idiot with regards to design or if this is the normal evolution
<schweers>
that’s okay. Make sure to try and make it better when you know more about your problem
<schweers>
I suppose the latter
<xificurC>
I suppose you're either too kind or a liar
<schweers>
unless myself and almost everyone who writes about these things are idiots too.
<schweers>
no, I run into similar problems, so I’m very sympathetic to your kind of situation.
SenasOzys has quit [Ping timeout: 264 seconds]
vlatkoB has quit [Ping timeout: 264 seconds]
<xificurC>
I like the fact that I don't spend days designing but it just sort of pops out from all the hacking
<xificurC>
I don't like the fact that it takes 2-4 complete rewrites to get something shiny
<schweers>
As we’re wandering off-topic anyway, I’d like to mention that the book “Test-Driven Development by Example” was a real revelation for me. Also it made me feel like a moron, but that’s another story.
<xificurC>
one more question, thinking ahead now - when you have a class/struct and it is the only one using a function do you make it defun or defgeneric?
<shka>
xificurC: does not matter
<schweers>
I may be differing strongly from other peoples practices, but I mostly use structs and defuns. I do this for performance reasons, as performance is quite relevant in my current work. Other people may suggest you use classes and generic functions until you can prove they are causing performance issues.
<shka>
xificurC: CL allows you to switch defun into defgeneric without any issue
<xificurC>
schweers: are the examples in the book in java?
<schweers>
partly java, partly python. but try not to hold that against the author. you have to take some of the writing with a grain of salt, for that reason.
<shka>
so initial decision is not critical
<xificurC>
thanks
<schweers>
He talks too much about classes, objects, and methods than I care for, but hey, you can overlook that pretty easily.
<White_Flame>
schweers: I use generic functions with structs fairly often. You don't have to go to defclass to get their benefit
<schweers>
White_Flame: true. I do that myself.
<schweers>
I just forgot to mention that.
<shka>
xificurC: defclass is easier to work with
<shka>
because of interactivity
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
thodg has joined #lisp
<schweers>
and multiple inheritance, if you care about that.
<shka>
yes, this also
<xificurC>
shka: interactivity?
<schweers>
I really don’t get why the majority of our industry seems to think that multiple inheritance is inherently (hehe) wrong.
<shka>
xificurC: redefining defstructs is well known to be land of undefined
<schweers>
works pretty well in sbcl, but I wouldn’t rely on it.
<White_Flame>
schweers: because their languages suck
<shka>
schweers: because C++ fucked programmers mind badly
<schweers>
but CLOS could be the foundation of other languages than lisp
<schweers>
shka: true. I remember that I almost wept as I read how CLOS does MI.
<shka>
and because of huge impact C++ had, corpolanguages mimiced it
<shka>
along with it's flaws
* schweers
feels the sudden urge to drink heavily
<shka>
oh, relax
<shka>
there are worse things in world then this
<schweers>
I guess
<White_Flame>
yeah, like perl ;)
<shka>
White_Flame: it gets worse
<schweers>
not sure if I’d prefer perl or C++
<shka>
whole world is fucked up, not just IT
<schweers>
but IT/CS/whatever needn’t be as fucked up as it is.
<shka>
actually that's why i like to rant about computer programs
<shka>
it is nice distraction from gloom reality of our existence
<schweers>
seems like such a first world problem, when you think about it.
<White_Flame>
yeah, stick to your own sphere, can't worry about everythign else
<schweers>
people are starving, kids are being forced to fight in wars, but most languages don’t have a proper notion of MI.
skapata has joined #lisp
<schweers>
back to the previous topic: I wonder where one could best confront the majority of programmers with these ideas. Talking in here will not convince anyone, it’s just preaching to the choir. Taking over -- say -- a java IRC channel would probably be viewed as rude.
<shka>
schweers: useless
<shka>
imagination can't be forced into changed unless mind wants to change
<White_Flame>
the majority of programmers undertsand what is possible to be constrained to what is known
<shka>
and mind sits firmly in the material reality
<jackdaniel>
write a nice essay which makes the benefits obvious and post it on a few communication channels
<jackdaniel>
alternatively record a video, or stream it on twich
<White_Flame>
most programmers don't see their coding problems as problems, but rather the normal issues that programming deals with in the course of things
<schweers>
people have done that, it doesn’t seem to resonate (much)
<shka>
White_Flame: most programmers are not all that passionate
<jackdaniel>
some people do that already, it is not perceived as rude and sometimes it gets somewhat popular
<shka>
to begin with
<shka>
they just need money for kids and stuff
<White_Flame>
also, if you're not working on difficult problems, you don't need above-average solutions
<jackdaniel>
if you ask how to force people to agree with your ideas, well: hypnosis isn't an option, because it doesn't work that way – you may only suggest something
<schweers>
White_Flame: I disagree.
<shka>
White_Flame: i agree
<White_Flame>
"need" being the operative word
<White_Flame>
they'll help, but they're not required
<schweers>
I don’t work on something which naturally lends itself to lisp, but nevertheless I’m very grateful for being able to use lisp for the project.
<White_Flame>
I mean, Lisp won't help you much for Hello, World programming
<schweers>
I hardly write any macros, hardly use CLOS.
<schweers>
no, but the majority of (useful) software does not fall into that category.
<schweers>
well, no, but then: is it “required” to use something “better” than assembly or C?
<shka>
schweers: i would argue that python web developers who just maintain some crappy django web page do not care
<White_Flame>
schweers: it's a cost/benefit tradeoff
<shka>
and there is awfull lots of them
<schweers>
shka: maybe you’re right that most programmers are not that passionate.
Folkol has joined #lisp
<shka>
yup
<shka>
besides, major flaw of CL are libs
rumbler31 has joined #lisp
<jackdaniel>
given a passionate programmer who knows (say) python and does cool stuff with it, starting with: your language of choice is shit, CL is best programming language which has all it and more, and if you don't agree with me that MI is cool then you are below-average soldier programmer without passion
<jackdaniel>
won't buy you his attention either ;-)
<shka>
if you want to CL become more popular and have more opportunity to earn money with lisp, try to address this problem
thodg has quit [Ping timeout: 256 seconds]
<jackdaniel>
or hers ;p
<shrdlu68>
"There they stand", he said to his heart "There they laugh: they do not understand me, I am not the mouth for these ears" ~Zarathustra
<shrdlu68>
^every lisper.
<schweers>
jackdaniel: I guess I understand where you are going with this, but I’d like to go on the record to say that I did not mean that. And I agree with you.
<schweers>
oh dear, are we quoting Nietzsche now?
<shka>
jackdaniel: bills won't pay themselfs, so i don't see why you are so offensive
<jackdaniel>
I mean that putting yourself in a superior position (e.g I'm going to convince Java programmers, that CL is *better*), isn't a good way to start a conversation
<jackdaniel>
shka: I don't understand
<shka>
in fact, learning CL requires unusual circumstances nowdays
<shka>
you will need to have extra time
<schweers>
shka: how so?
<schweers>
I needed extra time for most languages I have learned
<shka>
true
<schweers>
python, for example
<shka>
and most people can't spend it unless it is for a reason
<schweers>
I learned (a little bit of assembly), C, C++ and Java in school. The rest I learned on my own time
<shka>
i have extra time because, well i don't have a so called life
<jackdaniel>
and the thing is that this urge to believe unconditionally that *your* choice is the optimal one (i.e CL is a superior language) is tempting, but most probably a fallacy of sticking to known things
<shka>
no girlfriend, not much friends
<shka>
but it is not a norm
<jackdaniel>
I write in CL because I *like* it, not because I think it is better than (say) Scheme, Forth, C# or Java
rumbler31 has quit [Ping timeout: 260 seconds]
<shka>
jackdaniel: i think that it is about lisp ideas, not about cl itself
<shrdlu68>
schweers: I don't know why this is so strongly reminiscent of that scene.
<schweers>
shka: I did for the longest time too, and thus viewed all lisps as being roughly equivalent. I have come to like CL much much more than other lisps.
<schweers>
shrdlu68: I must admit that I did not read the book, although I have it at home and tried to. But Nietzsche has a really weird way of writing.
* jackdaniel
said what he wanted to say, getting back to cltl2 env access implementation for ECL
<shka>
anyway, there is no point in force feeding people with lisp
<schweers>
nah, that’s not what I wanted either
<shka>
majority do not need it, some will not like it
fm4d_ has joined #lisp
<shka>
and as jackdaniel said, it can get offensive rather quickly
<shrdlu68>
"Too long have I lived in the mountains, and too much have I listened to the streams and trees: now I talk to them as to goat-herds"
* jackdaniel
notes (even if he already closed this window), that his point was the internal feeling of superiority of the speaker what is deterring, not language advocacy itself
<White_Flame>
"The time had come, so Marvin left."
AetherWind has quit [Quit: Leaving]
<shka>
jackdaniel: well, your internal feelings may or may give some impression, you may be just misinterpreted as well, especially if you are not perfectly socially calibrated
<shka>
murky waters
<shka>
anyway, i simply don't bother with that anymore
buoyantair has quit [Ping timeout: 265 seconds]
<fm4d_>
Hi, could someone give me an advice how to create keyword symbols? For example I would like to convert '((test . 1) (test2 . 2)) into (:test 1 :test2 2). I've explored the symbol-making functions but none of them seems to be able to do this. Thanks :)
<shka>
fm4d_: alexandria has make-keyword function
<shka>
you probabbly should use it
<_death>
fm4d: a keyword symbol is simply a symbol in the package named "KEYWORD".. intern takes a package designator
<schweers>
(intern (symbol-name 'sym) (find-package "KEYWORD")) should do the trick
<shka>
well, or that
<shka>
but make-keyword is nicer to read and write
<schweers>
and I guess most people have alexandria at their disposal anyway
EvW has quit [Ping timeout: 260 seconds]
<fm4d_>
schweers thanks, your solution works well
<fm4d_>
shka (alexandria:make-keyword "a") returns :|a| instead of :a
<fm4d_>
could you explain the bars for me please?
<shka>
fm4d_: sure
<shka>
fm4d_: try "A"
<fm4d_>
:D
<fm4d_>
thats confusing
<schweers>
Common Lisp normally upcases symbols
<shka>
because you skipped reader, name was not uppcased
<schweers>
so if you enter 'sym, the reader converts it to a symbol which has the name "SYM"
<shka>
basicly, lisp is case sensitive language
<shka>
but it converts symbols to upcase by default
<schweers>
if you really want a symbol which has a lowercase name, you can say '|sym| or (lengthy) '\s\y\m
<fm4d_>
Ah, I see
<fm4d_>
thanks
<shka>
no problem
<schweers>
if you use (SYMBOL-NAME), you get the "correct" casing back
<shka>
fm4d_: i think that (make-keyword 'a) will works as well
<shka>
IIRC
<schweers>
it does
<schweers>
just tried it :D
<shka>
ok, cool
<fm4d_>
hm
<fm4d_>
it does not for me
<fm4d_>
CL-USER> (alexandria:make-keyword "b")
<fm4d_>
:EXTERNAL
<fm4d_>
:|b|
<schweers>
try this: (make-keyword 'b)
<schweers>
or (make-keyword (symbol-name 'b))
<schweers>
both do the same
<fm4d_>
ah, i didnt realize it was a symbol and not a string
<shka>
right
<fm4d_>
makes sense now :]
<schweers>
yeah \o/
<shka>
ok, nice
<fm4d_>
btw is it in accordance with clisp style to generate keyword symbols dynamically like that?
<fm4d_>
and using apply quite frequently?
<shka>
clisp = common lisp?
<schweers>
I guess it depends on what you’re doing
<fm4d_>
yes, common lisp
<schweers>
fm4d_: clisp is a specific implementation
<fm4d_>
so what do you use as a shortcut for 'common lisp'?
<White_Flame>
just remember that generating symbols on the fly is technically a memory leak
<shka>
fm4d_: CL
<schweers>
unless you unintern them again
<White_Flame>
if a symbol is in a package, it won't get automatically collected
<schweers>
but yes, White_Flame is right
<fm4d_>
shka: ok
<fm4d_>
and what about keywords then? they are part of KEYWORDS package
<shka>
fm4d_: if you say lisp, people here will assume common lisp here
<fm4d_>
=> they dont get collected either, right?
<White_Flame>
correct
<fm4d_>
ok, thanks
<shka>
well, they can be collected, but only after uninterning
<shka>
which you usually don't do
<schweers>
TIL that "::sym" reads as :sym
markoong has joined #lisp
<jdz>
All symbols in keyword package are automatically exported.
<loke>
schweers: makes sense
<schweers>
it does, I just never thought about it that way.
<loke>
the blang package name is equivalent to KEYWORD, so ::foo is equivalent to keyword::foo
<loke>
schweers: Also makes sense, since I can't think of any any actual use case for writing a keyword with doube :
<schweers>
exactly
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
buoyantair has joined #lisp
red-dot has joined #lisp
SenasOzys has joined #lisp
Bronsa has quit [Ping timeout: 256 seconds]
EvW has joined #lisp
_cosmonaut_ has quit [Ping timeout: 268 seconds]
orivej has joined #lisp
raynold has quit [Quit: Connection closed for inactivity]
pagnol has joined #lisp
Folkol has quit [Ping timeout: 276 seconds]
igemnace has quit [Remote host closed the connection]
alter-schjetne has joined #lisp
skeuomorf has quit [Ping timeout: 240 seconds]
schjetne has quit [Ping timeout: 260 seconds]
Murii has quit [Read error: Connection reset by peer]
Murii has joined #lisp
makomo has quit [Ping timeout: 264 seconds]
skeuomorf has joined #lisp
Fare has joined #lisp
rumbler31 has joined #lisp
skeuomorf has quit [Ping timeout: 240 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
Fare has quit [Ping timeout: 240 seconds]
smurfrobot has joined #lisp
_cosmonaut_ has joined #lisp
smurfrobot has quit [Remote host closed the connection]
Murii has quit [Read error: Connection reset by peer]
hjek has quit [Quit: Leaving.]
red-dot has joined #lisp
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
skapata has quit [Remote host closed the connection]
daniel-s has joined #lisp
kamog has joined #lisp
smurfrobot has joined #lisp
<xificurC>
I'm running slime and compiling definitions with slime-compile-defun. Now I get a condition of "The value NIL is not of type STRING" but the top of the backtrace shows my function which doesn't even take strings. I guess something it passed nil to something else. Why can't I see the call beneath it? :(
Negdayen has joined #lisp
rumbler3_ has joined #lisp
rumbler31 has quit [Ping timeout: 260 seconds]
<beach>
First `n', then `v'.
<beach>
Or first `n', then SPACE.
random9899 has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
thodg has joined #lisp
<ssake>
"gulp-browserify": "^0.5.1",
ssake has left #lisp [#lisp]
LiamH has joined #lisp
warweasle has joined #lisp
<beach>
xificurC: Oh, it could be that your implementation is doing tail merging, so that the call below it disappears.
<beach>
xificurC: Are you using SBCL?
<xificurC>
beach: yes
_cosmonaut_ has quit [Ping timeout: 256 seconds]
<beach>
xificurC: Did you set your OPTIMIZE qualities in your .sbclrc?
rumbler3_ has quit [Remote host closed the connection]
<beach>
As I recall, by default, SBCL does tail merging, but not with a high value of DEBUG.
<schweers>
beach: how do you set optimization qualities in general? do you only set them in .sbclrc and never change them?
<beach>
I might have forgotten the details.
<beach>
schweers: Me?
<schweers>
yes
<beach>
schweers: Yes, I very rarely change them.
<beach>
Only when I need to in order to benchmark some algorithm I implemented.
<beach>
... so that I can then put it in an ELS paper. :)
<schweers>
I was thinking I’d like to have rather aggressive optimizations for production, but not for debugging and/or testing. And I’m not sure how to properly do that
<schweers>
But normally you don’t really care about optimizations?
<beach>
Correct. At least not at that level. I design good data structures and algorithms instead.
<schweers>
well, one can do both and reap even greater benefits
<beach>
Sure, but it is rarely worth the time.
Fare has joined #lisp
<random9899>
schweers: there was one good thing in LoL for that
<schweers>
by optimizations I mostly meant setting the compiler to do some more work
<schweers>
random9899: really?
<random9899>
yes
<beach>
schweers: I see, yes. Like I said, I rarely find it necessary.
<random9899>
really
Kundry_Wag has joined #lisp
<schweers>
random9899: do you recall in which chapter? I don’t have the dead tree version on me right now
thodg has quit [Ping timeout: 245 seconds]
Kevslinger has joined #lisp
<schweers>
hm, I guess in 7.7 Writing and Benchmarking Compilers. Not freely available. I hope I’ll remember to look at that tonight when I get home.
<schweers>
I think I should just take the book to the office.
skeuomorf has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
Bronsa has joined #lisp
<random9899>
the online pdf version does not contain it afaik
<random9899>
i got that one too, but was surprised to see it cutoff like that
<schweers>
still: thanks for the tip, I’ll look into the dead trees at home
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
h_ has joined #lisp
mindCrime has joined #lisp
<random9899>
chapter 7.2
rippa has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<random9899>
dispatch-macro-character '#f and the macros fast-progn and safe-progn
<xificurC>
beach: forgot to write back, thanks that indeed shows more in the stacktrace :)
<random9899>
tho you also have to consider other stuff like some declarations getting only considered for compiled code etc....
_cosmonaut_ has joined #lisp
Oladon has joined #lisp
<random9899>
and despite their name with progn, they use a (locally, cause progn does not accept declarations
<beach>
xificurC: Oh, good.
<random9899>
so you kinda have to write some compiler-macro .....
<schweers>
random9899: cool, thanks!
papachan has joined #lisp
<random9899>
ya with them schweers you can enable fast compilation at some point and go back to safe compilation at another point in your code....
<random9899>
really handy if you can make it right
Kundry_Wag has joined #lisp
<random9899>
but since it's a macro and macros are not guaranteed to be expanded before compilation, you'll really have to couple normal macro stuff (for runtime) with compiler-macro versions of those (for compile time)
<schweers>
uhh, I just realized something. If I say (declaim (optimize (debug 3))), does the effect it has stop at the end of the file I’m currently compiling/loading/executing?
<random9899>
no schweers
<random9899>
until you change it
<schweers>
It seems to me, the answer must be no, as there would otherwise be no point in putting such a form into .sbclrc
<random9899>
declarations can shadow yes
<random9899>
each other
<random9899>
and they last until you change them
<random9899>
schweers afaik some stuff does not get effect at runtime, probably the compiler decides to ignore some settings
<random9899>
one thing more you can do is make it read-time
Fare has quit [Ping timeout: 260 seconds]
<random9899>
i.e. #.(declaim (optimize (debug 3)))
<schweers>
so (declaim (optimize (safety 3))) (locally (optimize (safety 0)) (defun really-well-tested ...)) (defun not-so-well-tested ...) does pretty much what I expect: set safety to 0 for WELL-TESTED, but back to 3 for the rest (i.e. NOT-SO-WELL-TESTED in this contrived example)
<schweers>
what is the benefit to running it at read time? As far as I remember DECLAIM has its effect at compile time, right?
thodg has joined #lisp
<random9899>
naaaa, safety 3 is ok, but as long as you don't specify the other optimizations which are diagonally opposite to it you may not get what you expect
pseudonymous_ has joined #lisp
<schweers>
sure, just as an example
<schweers>
I didn’t want to clutter it more than I have to
<schweers>
maybe I should have put it on pastebin instead of inlining it here in IRC
hvxgr has quit [Ping timeout: 260 seconds]
pseudonymous has quit [Ping timeout: 265 seconds]
<random9899>
right
igemnace has joined #lisp
lemoinem has quit [Ping timeout: 268 seconds]
lemoinem has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
hvxgr has joined #lisp
Kundry_Wag has joined #lisp
_cosmonaut_ has quit [Ping timeout: 248 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<random9899>
declaim has it's effect at compile-time only when the file-compiler (compile-file) is being used on a file containint that (declaim.....) form
<random9899>
If a use of this macro appears as a top level form in a file being processed by the file compiler, the proclamations are also made at compile-time. As with other defining macros, it is unspecified whether or not the compile-time side-effects of a declaim persist after the file has been compiled
nowhere_man has joined #lisp
nowhereman_ has quit [Ping timeout: 256 seconds]
<random9899>
declare expressions must appear as actual subexpressions of the form to which they refer -> i.e. not (declare (optimize bla bla bla)) but (declare (optimize (bla bla bla)))
<random9899>
Macro forms cannot expand into declarations
<random9899>
Figure 3-23. Standardized Forms In Which Declarations Can Occur
shka_ has joined #lisp
pierpal has quit [Ping timeout: 245 seconds]
sz0 has quit [Quit: Connection closed for inactivity]
innovati has joined #lisp
<random9899>
and have a look at proclaim too ofc
<random9899>
Although the execution of a proclaim form has effects that might affect compilation, the compiler does not make any attempt to recognize and specially process proclaim forms. A proclamation such as the following, even if a top level form, does not have any effect until it is executed: (proclaim '(special *x*))
<random9899>
If compile time side effects are desired, eval-when may be useful.
<random9899>
(eval-when (:execute :compile-toplevel :load-toplevel) (proclaim '(special *x*))) In most such cases, however, it is preferrable to use declaim for this purpose.
<random9899>
so declaim is almost like the above eval-when proclaim, only that you have to bear in mind that compile-time effects are still not guaranteed untile the file-compiler compiles some stuff....
skeuomorf has quit [Ping timeout: 240 seconds]
<random9899>
and last but not least Since proclaim forms are ordinary function forms, macro forms can expand into them.
heisig has quit [Quit: Leaving]
lukego has joined #lisp
<lukego>
How does one troubleshoot ccl exiting with the message "double free or corruption (out)"? My lead is that it's happening when I create a bunch of threads and sockets.
<shka_>
lukego: cffi?
pierpal has joined #lisp
<random9899>
SBCL is essentially a compiler-only implementation of Common Lisp. That is, for all but a few special cases, eval creates a lambda expression, calls compile on the lambda expression to create a compiled function, and then calls funcall on the resulting function object. A more traditional interpreter is also available on default builds; it is usually only called internally. This is explicitly allowed by the ANSI
<random9899>
standard, but leads to some oddities; e.g. at default settings, functionp and compiled-function-p are equivalent, and they collapse into the same function when SBCL is built without the interpreter
<lukego>
yes, via usockets
<shka_>
lukego: only that?
siraben has joined #lisp
Bike has joined #lisp
<shka_>
because it sounds like either bug in ccl or in some c lib
<random9899>
so it talks about runtime compilation not load-time compilation as would happen with compile-file
<shka_>
lukego: anyway, launch gdb or some other debugger and attach to CCL process
<shka_>
it is nothing pretty, i must warn you…
<lukego>
Yeah. I suppose that if this is heap corruption then gdb will probably wake up long after the real problem. But I might be lucky. Otherwise I can try to minimize the test case.
<lukego>
Thanks shka_
<p_l>
lukego: fwiw, "double free" sounds like something errored in native code
<shka_>
p_l: he already knows that bro
<p_l>
Ahh, missed it
<lukego>
How many threads is "a lot" for ccl btw? is there some number at which there be dragons?
<shka_>
lukego: those are native threads
<shka_>
nothing fancy
<shka_>
as for error, i bet that this is some kind of stray null :-)
<random9899>
ecl is nice for creating .o objects for small lisp code
<random9899>
but i've never used it
<random9899>
and since it's a repl, read first, eval next, print last
<shka_>
starting 100 threads on windows is for instance not a bright idea
<random9899>
threads sharing address space ?
<p_l>
shka_: huh, why windows would object to many threads?
<lukego>
shka_: I see things like polling conditions at 1kHz and figure that's putting some pressure on the kernel
<p_l>
1kHz polling doesn't sound good unless it's realtime code
<shka_>
p_l: i have no idea, i just know that i didn't ran well back when i was still programming on windows
<shka_>
windows 7 days
<p_l>
btw, unrelated question - how many people here do some consulting work with lisp?
<p_l>
shka_: I'd suspect something related to the code rather than OS...
h_ has quit [Quit: leaving]
<fe[nl]ix>
lukego: on Linux/x86_64 I believe the default thread stack size is 8Mb
vitali has joined #lisp
<shka_>
p_l: thread scheduling can make a difference
<shka_>
but i did not investigate
<lukego>
fe[nl]ix: Hm. I have 64GB ram on this machine and I don't think I'm bumping that limit, but good to keep in mind.
<lukego>
ccl isn't starting in gdb for me. Have to sort out some dependency. But meanwhile maybe I can strace/ltrace a little to check for allocation failures or the like.
<random9899>
The three big moments in a Lisp expression's life are read-time, compile-time, and runtime. Functions are in control at runtime. Macros give us a chance to perform transformations on programs at compile-time. ...read-macros... do their work at read-time.
<random9899>
Macros and read-macros see your program at different stages. Macros get hold of the program when it has already been parsed into Lisp objects by the reader, and read-macros operate on a program while it is still text. However, by invoking read on this text, a read-macro can, if it chooses, get parsed Lisp objects as well. Thus read-macros are at least as powerful as ordinary macros.
pagnol has quit [Quit: Ex-Chat]
DemolitionMan has joined #lisp
Oladon has quit [Quit: Leaving.]
<shka_>
p_l: thread creation also takes more time on windows
pierpal has quit [Read error: Connection reset by peer]
<shka_>
in fact, linux threads are now dirty cheap
<p_l>
shka_: process/thread manipulation generally takes more time on NT, which is why threads & threadpools were advocated since beginning
<shka_>
on windows, was not the case few years back
<p_l>
while Unix systems in general had very cheap fork(), with thread creation even cheaper
<shka_>
yeah
nowhere_man has quit [Ping timeout: 256 seconds]
<shka_>
anyway, large number of (working) threads is not a good idea in general
<random9899>
right
<shka_>
and plane stupid on windows for a reasons i don't care about anymore
<shka_>
*plain
* p_l
hides old experiments of several thousands threads in application per node
Kyo91 has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
<shka_>
having said all of that, my experience is dated
<shka_>
maybe it got better
<p_l>
it could be also related to what the threads did, possibly hidden by runtime
<random9899>
welp, there was an ieee paper about the mathematical fatality of threading/concurrent
kami has joined #lisp
<kami>
Hello
<shka_>
p_l: well, you can check, i don't even have windows anymore
EvW has quit [Ping timeout: 276 seconds]
<p_l>
if one digs deep enough, windows first shows a message passing system between each process and kernel, and if you dig deeper you find undocumented support for ASTs
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<random9899>
afaik there's not even 1 single time reference like 1 ns on what you can depend on with the current hw we have, it's all voltage dependent.... not ?
<random9899>
so what do you go for timing it well as threading programmers when you have to rely on such things ?
jmercouris has joined #lisp
<jmercouris>
beach: did you get my email?
SaganMan has joined #lisp
<lukego>
random9899: I usually use the RDTSC/RDTSCP instructions. Those are based on a reference clock that doesn't vary. at least on recent CPUs that support the relevant feature flag
<random9899>
aaah
<random9899>
ok thank you for that info
<beach>
jmercouris: I did. Still thinking about it.
<jmercouris>
beach: ok
<beach>
jmercouris: I am flattered of course. But I am thinking I would like for SICL to be slightly more advanced than it currently is.
<jmercouris>
beach: Well, the topic could be maybe just about your CL research in general
<beach>
jmercouris: I'll think about it.
<beach>
Thanks for the offer.
<jmercouris>
ok, no problem
<fe[nl]ix>
lukego: RTDSC is highly unreliable
<fe[nl]ix>
*RDTSC
<random9899>
the serializing version, guarding against out-of-order execution
<random9899>
On Windows platforms, Microsoft strongly discourages using the TSC for high-resolution timing for exactly these reasons, providing instead the Windows APIs QueryPerformanceCounter and QueryPerformanceFrequency.[2] On POSIX systems, a program can get similar function by reading the value of CLOCK_MONOTONIC clock using the clock_gettime function.[3]
<random9899>
Since the family 10h (Barcelona/Phenom), AMD chips feature a constant TSC, which can be driven either by the HyperTransport speed or the highest P state. A CPUID bit (Fn8000_0007:EDX_8) advertises this.
<random9899>
oh man
<lukego>
fe[nl]ix: for what purpose? I use it all the time
<lukego>
have to be careful though e.g. be prepared for different cores to have different epocs. but it's a low level feature :) and libc has slightly higher level things on top
<fe[nl]ix>
exactly
<fe[nl]ix>
the counter is per-core and also varies with core freq
<fe[nl]ix>
unless your CPU supports "Invariant TSC"
<fe[nl]ix>
in which case RDTSC comes from a dedicated clock
<random9899>
There is no promise that the timestamp counters of multiple CPUs on a single motherboard will be synchronized. Therefore, a program can get reliable results only by limiting itself to run on one specific CPU. Even then, the CPU speed may change because of power-saving measures taken by the OS or BIOS, or the system may be hibernated and later resumed, resetting the TSC. In those latter cases, to stay relevant,
<random9899>
the program must re-calibrate the counter periodically.
<random9899>
so i suppose that also holds for inter-core ?
<lukego>
fe[nl]ix: True. Though I think all CPUs made in the last N years have the invariant TSC.
<random9899>
ya i got the constant_tsc flag too
smurfrobot has joined #lisp
<fe[nl]ix>
lukego: if you're using Xeon-class CPUs I think so
<fe[nl]ix>
not so sure about laptops
<lukego>
otherwise I believe glibc can give you a more consistent clock with nanosecond precision that is (safely) sourced from TSC under the hood.
jmercouris has quit [Ping timeout: 240 seconds]
vitali has quit [Ping timeout: 265 seconds]
<lukego>
fe[nl]ix: btw do you know how is iolib support on LispWorks and on Mac? (known to not work? or known that somebody does that? etc)
Cymew has quit [Remote host closed the connection]
Cymew has joined #lisp
surya has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
Folkol has joined #lisp
buoyantair has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
nika has joined #lisp
smurfrobot has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 264 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
lukego has quit [Ping timeout: 260 seconds]
Kyo91 has quit [Ping timeout: 264 seconds]
Fare has joined #lisp
SenasOzys has quit [Ping timeout: 245 seconds]
smurfrobot has joined #lisp
blackwolf has joined #lisp
thodg has quit [Ping timeout: 255 seconds]
siraben has quit [Ping timeout: 276 seconds]
robotoad has joined #lisp
Kyo91 has joined #lisp
Kyo91 has left #lisp [#lisp]
Kyo91` has joined #lisp
smurfrobot has quit [Remote host closed the connection]
flamebeard has quit []
siraben has joined #lisp
FreeBirdLjj has joined #lisp
siraben has quit [Remote host closed the connection]
nowhere_man has joined #lisp
pierpal has joined #lisp
skidd0 has joined #lisp
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
<beach>
Help me think this through, please: I would like to transform the dpANS TeX files to a bunch of files that I can compile with a single LaTeX command, say pdflatex.
<beach>
There are several obstacles. For one thing, the dpANS files do not use LaTeX, and a number of TeX macros basically emulate LaTeX macros in incompatible ways. For another, each chapter is meant to be compiled with TeX separately, so there are files that are included in each chapter file. Furthermore, there is a mixture of "semantic" macros and typesetting macros, and I would like to get rid of the typesetting macros without
<beach>
sacrificing the semantics macros. I would also like to replace the specific TeX macros that have counterparts in LaTeX.
<beach>
The purpose of the exercise is to obtain a maintainable LaTeX document with indexes, table of contents, cross references etc. This LaTeX document would be the basis for WSCL.
<beach>
I would then start modifying the text, probably putting original paragraphs in appendices and referring to them from the main text. But that's in the future. So how do I go about this in a way that does not introduce too many errors? I don't mind manual editing. It is not urgent.
SenasOzys has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
scymtym has joined #lisp
h___ has joined #lisp
<p_l>
fe[nl]ix: "consumer" cpus were first to get invariant TSC because of games
<fe[nl]ix>
good to know :D
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
Kundry_Wag has joined #lisp
buoyantair has joined #lisp
buoyantair_ has joined #lisp
buoyantair has quit [Ping timeout: 260 seconds]
HDurer has quit [Ping timeout: 268 seconds]
h___ has quit [Quit: leaving]
pierpal has quit [Ping timeout: 256 seconds]
HDurer has joined #lisp
vitali has joined #lisp
HDurer has quit [Ping timeout: 260 seconds]
HDurer has joined #lisp
kami has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #lisp
light2yellow has joined #lisp
random-nick has joined #lisp
EvW1 has joined #lisp
fraya has quit [Remote host closed the connection]
buoyantair_ has quit [Quit: Leaving]
milanj has joined #lisp
pierpal has joined #lisp
EvW1 has quit [Ping timeout: 245 seconds]
warweasle has joined #lisp
bbobb has joined #lisp
vitali has quit [Ping timeout: 265 seconds]
makomo has joined #lisp
schoppenhauer has quit [Ping timeout: 268 seconds]
sjl has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
HDurer has quit [Ping timeout: 256 seconds]
hhdave has quit [Ping timeout: 265 seconds]
vtomole has joined #lisp
daniel-s has quit [Remote host closed the connection]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
shrdlu68 has left #lisp [#lisp]
red-dot has joined #lisp
mflem has joined #lisp
kami has joined #lisp
skeuomorf has joined #lisp
m00natic has quit [Remote host closed the connection]
skidd0 has quit [Quit: WeeChat 2.1]
smurfrobot has joined #lisp
igemnace has quit [Quit: WeeChat 2.1]
Kundry_Wag has quit [Remote host closed the connection]
smurfrobot has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 276 seconds]
blackwolf has quit [Ping timeout: 260 seconds]
<random9899>
The whole language always available. There is no real distinction between read-time, compile-time, and runtime. You can compile or run code while reading, read or run code while compiling, and read or compile code at runtime.
<random9899>
Running code at read-time lets users reprogram Lisp's syntax; running code at compile-time is the basis of macros; compiling at runtime is the basis of Lisp's use as an extension language in programs like Emacs; and reading at runtime enables programs to communicate using s-expressions, an idea recently reinvented as XML.
<Bike>
you don't need to keep quoting paragraph blurbs
<Bike>
if you have a question you want answered or topic you would like to discuss, please use your own words
nowhere_man has joined #lisp
vitali has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
lumm has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
fyodost has joined #lisp
<phoe>
random9899: yes, and?
<phoe>
I know this article
<random9899>
i knew that site but not that article, must have missed it somehow
rumbler31 has joined #lisp
<phoe>
random9899: Graham has quite a lot of essays, they're a rather good reading as long as you take him with a pinch of salt
<random9899>
i put the quotes, well wrt to the confusion arising in people when talking about read-time, run-time and compile-time....like with schweers about his question about what a #.(declaim...) is different from a normal (declaim ..) etc....
<jackdaniel>
question: given cltl2 interface is implemented, how am I supposed that variable is unknown for my own declarations? example: (let ((x 3)) (declare (ignore y)) …) will issue a simple-warning
<jackdaniel>
I want to do the same in a function in cltl2:define-declaration, the thing is that lexical variables are note yet in the environment
<phoe>
it'll return NIL if "There is no apparent definition or binding for variable."
<jackdaniel>
so variable-information will fail to find y even if it is there (let ((y bam)) (declare (phoe y)) …)
Kyo91` has quit [Ping timeout: 276 seconds]
<phoe>
oooh. hmm.
<jackdaniel>
phoe: lexical variables are not in the environment yet at the time of invoking declaration lambda function
<phoe>
you need to somehow pass that information from LET to it
<jackdaniel>
because result of declaration is included in result of variable-information too
<phoe>
like, hm - the list of new bindings from LET needs to be passed to the declaration function
<jackdaniel>
I know how to do it *using* compiler internals, because I'm already doing that, but not sure how to achive it simply using cltl2
<phoe>
hm, I see.
wigust- has joined #lisp
<phoe>
This seems to be rather silly. Inside (let ((x 3)) ...), I would expect X to be lexically bound. Even inside a (declare ...) that might happen in there.
wigust has quit [Ping timeout: 256 seconds]
<jackdaniel>
declarations are processed at compilation time, there is nothing to be bound yet. only some information in lexenv may be present
<phoe>
Uh, yes - that is what I meant.
<phoe>
I would expect X to name a variable in the lexical environment.
<jackdaniel>
so you expect let to behave similar to labels, not to flet
<phoe>
What do you mean?
himmAllRIght17 has quit [Quit: WeeChat 2.0.1]
<jackdaniel>
when you have flet, first you process definitions *then* you extend the environment
<jackdaniel>
when you have lable,s first you extend the environment and then you process definitions
<phoe>
I see
<jackdaniel>
thanks to that you are able to call functions among themself
<phoe>
I see, so that is how it is implemented.
<phoe>
Inside LET, a variable should not be able to refer to itself though.
<jackdaniel>
(note that this is different behavior than let*)
<phoe>
So we don't want to directly copy a LABELS-like behavior.
<Bike>
declare isn't like a separate form or anything. it makes sense to think of (let ((y bam)) (declare (phoe y)) ...) as being like (let+ ((y bam phoe)) ...). there is probably no time at which the variable is bound but not typed as far as the environment is concerned.
<phoe>
It needs to be understood and processed by LET, right?
<Bike>
in other words i don't understand what either of you are talking about. "declaration lambda function"?
<phoe>
Bike: cltl2 and define-declaration
<phoe>
Bike: if Y is an unknown variable, how do we detect that using cltl2 functionality?
<Bike>
cltl2 doesn't seem to specify what the environment is for or when the function is called.
<Bike>
I suppose you could say that the environment is first augmented with a lexical y, then that's passed to the define-declaration function, and then that's used to produce the actual environment used for processing the body.
<jackdaniel>
that's not a case in SBCL
smurfrobot has joined #lisp
<Bike>
in the case of (phoe y) as a free declaration, the environment passed to the declaration function would have y unbound, i.e. variable-information returns NIL.
Kundry_Wag has quit [Read error: No route to host]
<jackdaniel>
I'm asking, because I'm trying to figure what's the right thing to do (implementing cltl2 for ECL – first writing a test suite)
<Bike>
sb-cltl2 doesn't even work fully
Kundry_Wag has joined #lisp
<jackdaniel>
do you remember which parts are not implemented?
<Bike>
it's not so much a lack of implementation as it is bugginess. they're probably still in the tracker
<Bike>
i just knew that link would be bullshit long, but i posted it anyway, like an idiot
python476 has joined #lisp
<Bike>
the one i hit was 769592, which is that augment-environment signals stupid errors sometimes because it goes through internal compiler machinery that immediately signals when it hits inconsistencies, because they matter for compilation but not cltl2
<Bike>
anyway i wouldn't worry about define-declaration
sauvin has quit [Remote host closed the connection]
<Bike>
i wrote a cltl2 wrapper library but didn't bother with it. and it has so many users! at least zero
<Bike>
if you do want to worry about it, i think what i described would be a reasonable way to do it
<phoe>
Bike: I would be worried if it had negative user count; knowing how much you deal with C++ it would likely mean an integer overflow
<mfiano>
Heh, I thought all lisp software had 0 users, excluding the developer.
<jackdaniel>
Bike: yes, I think I'll implement it the way you mention
<Bike>
ah, but i don't even use it, which gives it -1 users excluding me
<mfiano>
Ha
rumbler31 has quit [Remote host closed the connection]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Fare has quit [Ping timeout: 264 seconds]
vitali has quit [Remote host closed the connection]
pierpal has joined #lisp
vitali has joined #lisp
Kyo91` has joined #lisp
herr_jth has joined #lisp
pkdrobytt has joined #lisp
trittweiler has joined #lisp
MichaelRaskin has joined #lisp
EvW has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
nimiux has joined #lisp
smurfrobot has quit [Remote host closed the connection]
light2yellow has quit [Quit: light2yellow]
zooey has quit [Remote host closed the connection]
Khisanth has quit [Ping timeout: 256 seconds]
zooey has joined #lisp
pierpal has quit [Remote host closed the connection]
tmf has joined #lisp
beardio has joined #lisp
<fiddlerwoaroof>
package-inferred-system is kinda nice
<fiddlerwoaroof>
Although, I dislike how it hides your system dependencies in the .asd
grumble has quit [Remote host closed the connection]
grumble has joined #lisp
Khisanth has joined #lisp
moei has joined #lisp
comborico1611 has joined #lisp
orivej has joined #lisp
<phoe>
I actually don't use p-i-s
<phoe>
it does not really suit my programming style
beardio has quit [Quit: rcirc on GNU Emacs 26.1]
smurfrobot has joined #lisp
Fare has joined #lisp
<fiddlerwoaroof>
Yeah, I'm not sure I'd actually use it
<fiddlerwoaroof>
But, I appreciate what it does, I've always been slightly annoyed about the duplication between the ASDF system's dependency lists and the defpackage forms
smurfrobot has quit [Ping timeout: 248 seconds]
thodg has joined #lisp
ealfonso has joined #lisp
mikecheck has joined #lisp
Tristam has quit [Read error: Connection reset by peer]
Tristam has joined #lisp
smurfrobot has joined #lisp
herr_jth has quit [Remote host closed the connection]
ealfonso` has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
ealfonso has quit [Ping timeout: 245 seconds]
Kundry_Wag has quit [Remote host closed the connection]
ealfonso` has quit [Read error: No route to host]
Kundry_Wag has joined #lisp
drastik_ has joined #lisp
drastik has quit [Ping timeout: 256 seconds]
Kyo91` has quit [Remote host closed the connection]
Kyo91` has joined #lisp
drastik_ is now known as drastik
Pixel_Outlaw has joined #lisp
markoong has quit [Ping timeout: 245 seconds]
skapata has joined #lisp
smurfrobot has joined #lisp
herr_jth has joined #lisp
scymtym has quit [Ping timeout: 245 seconds]
smurfrobot has quit [Ping timeout: 265 seconds]
markoong has joined #lisp
red-dot has joined #lisp
smurfrobot has joined #lisp
pkdrobytt has quit [Quit: Lost terminal]
random9899 has quit [Ping timeout: 245 seconds]
papachan has quit [Quit: WeeChat 2.1]
nowhere_man has quit [Ping timeout: 256 seconds]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
ckonstanski has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
rumbler31 has joined #lisp
smurfrobot has quit [Remote host closed the connection]
rumbler31 has quit [Ping timeout: 255 seconds]
scymtym has joined #lisp
random9899 has joined #lisp
wigust- has quit [Ping timeout: 248 seconds]
trittweiler has quit [Ping timeout: 265 seconds]
eli_oat has joined #lisp
kamog has quit [Remote host closed the connection]
skeuomorf has quit [Ping timeout: 260 seconds]
smurfrobot has joined #lisp
slyrus_ has quit [Quit: Leaving]
Mutex7 has joined #lisp
smurfrobot has quit [Remote host closed the connection]
skeuomorf has joined #lisp
Denommus has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
mikecheck has quit [Remote host closed the connection]
smurfrobot has joined #lisp
gggiova has joined #lisp
gggiova has quit [Client Quit]
FreeBirdLjj has quit [Ping timeout: 260 seconds]
smurfrobot has quit [Ping timeout: 245 seconds]
shka_ has quit [Ping timeout: 248 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
dessm has joined #lisp
eli_oat has quit [Quit: Leaving.]
<aeth>
fiddlerwoaroof: It simplifies your definitions of external dependencies, but it doesn't simplify your definitions of internal dependencies that much because unless your project is flat, you are going to have to create a /foo.lisp for every /foo/ so you can just import my-project/foo instead of my-project/foo/bar
vlatkoB_ has quit [Remote host closed the connection]
Kyo91` has quit [Ping timeout: 264 seconds]
eli_oat has joined #lisp
smurfrobot has joined #lisp
<aeth>
On the other hand, you wouldn't get that feature without it, anyway.
Denommus has quit [Quit: ERC Version 5.3 (IRC client for Emacs)]
smurfrobot has quit [Remote host closed the connection]
innovati has quit [Quit: My MacBook Air has gone to sleep. ZZZzzz…]
innovati has joined #lisp
smurfrobot has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
smurfrobot has quit [Remote host closed the connection]
thodg has quit [Ping timeout: 245 seconds]
eli_oat has quit [Quit: Leaving.]
Kundry_Wag has quit [Ping timeout: 260 seconds]
nickenchuggets has joined #lisp
Kundry_Wag has joined #lisp
talonfire441 has joined #lisp
nowhere_man has joined #lisp
LiamH has quit [Quit: Leaving.]
innovati has quit [Read error: Connection reset by peer]
innovati has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
openthesky has quit [Quit: Leaving.]
openthesky1 has joined #lisp
openthesky1 has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Bike has quit [Ping timeout: 260 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
pierpal has joined #lisp
bbobb has quit [Quit: bbobb]
schoppenhauer has joined #lisp
pierpa has joined #lisp
jack_rabbit has quit [Ping timeout: 245 seconds]
kami has quit [Ping timeout: 260 seconds]
vtomole has quit [Ping timeout: 260 seconds]
mindCrime has quit [Ping timeout: 268 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
random-nick has quit [Read error: Connection reset by peer]
vitali has quit [Ping timeout: 260 seconds]
dyelar has quit [Ping timeout: 256 seconds]
hjek has joined #lisp
smurfrobot has joined #lisp
tmf has quit [Ping timeout: 265 seconds]
hjek has quit [Quit: Leaving.]
hjek has joined #lisp
Kundry_Wag has quit []
Khisanth has quit [Ping timeout: 248 seconds]
dessm has quit [Ping timeout: 276 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
Bike has joined #lisp
lumm_ has joined #lisp
lumm has quit [Ping timeout: 256 seconds]
lumm_ is now known as lumm
skeuomorf has quit [Ping timeout: 264 seconds]
warweasle has joined #lisp
Khisanth has joined #lisp
daniel-s has joined #lisp
python476 has quit [Ping timeout: 260 seconds]
smurfrobot has quit [Remote host closed the connection]
mikecheck has joined #lisp
robotoad has quit [Quit: robotoad]
EvW has quit [Ping timeout: 240 seconds]
nirved has quit [Ping timeout: 260 seconds]
smurfrobot has joined #lisp
red-dot has joined #lisp
mindCrime has joined #lisp
nirved has joined #lisp
EvW1 has joined #lisp
dddddd has quit [Remote host closed the connection]
Tristam has quit [Ping timeout: 264 seconds]
MasouDa has joined #lisp
Folkol has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
ckonstanski has quit [Ping timeout: 248 seconds]
robotoad has joined #lisp
whartung has quit [Remote host closed the connection]
whartung has joined #lisp
ckonstanski has joined #lisp
MasouDa has quit [Read error: Connection reset by peer]
Tristam has joined #lisp
MasouDa has joined #lisp
cgay has quit [Ping timeout: 245 seconds]
cgay has joined #lisp
sjl has quit [Ping timeout: 264 seconds]
smurfrobot has quit [Remote host closed the connection]