milanj has quit [Quit: This computer has gone to sleep]
smasta has quit [Ping timeout: 268 seconds]
jonh has quit [*.net *.split]
shaftoe has quit [*.net *.split]
kushal has quit [*.net *.split]
ArthurAGleckler[ has quit [*.net *.split]
CharlieBrown has quit [*.net *.split]
nicdev has quit [*.net *.split]
drdo has quit [*.net *.split]
weltung has quit [*.net *.split]
mbrock has quit [*.net *.split]
jeremyheiler has quit [*.net *.split]
joeygibson has quit [*.net *.split]
ecraven has quit [*.net *.split]
HDurer has quit [*.net *.split]
_death has quit [*.net *.split]
eMBee has quit [*.net *.split]
ecraven has joined #lisp
drdo has joined #lisp
jonh has joined #lisp
shaftoe has joined #lisp
HDurer has joined #lisp
HDurer has joined #lisp
nicdev has joined #lisp
mbrock has joined #lisp
_death has joined #lisp
jeremyheiler has joined #lisp
joeygibson has joined #lisp
weltung has joined #lisp
kushal has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
kushal is now known as Guest21826
rgrau has quit [Ping timeout: 240 seconds]
ArthurAGleckler[ has joined #lisp
CharlieBrown has joined #lisp
fikka has joined #lisp
igemnace has joined #lisp
rgrau has joined #lisp
Guest21826 has left #lisp [#lisp]
asarch has quit [Quit: Leaving]
z3t0 has joined #lisp
z3t0 has quit [Ping timeout: 248 seconds]
sjl has joined #lisp
sjl has quit [Ping timeout: 240 seconds]
les has quit [Quit: ""]
beach has joined #lisp
<beach>
Good morning everyone!
<Colleen>
beach: drmeister said 1 hour, 17 minutes ago: concrete-syntax-tree-base.asd contains a dependency for :alexandria but doesn't use anything from the system - could you remove it? Also - I submitted a pull request for the improved fix for handling end-of-file in the sicl reader.
eMBee has joined #lisp
em has quit [Remote host closed the connection]
<beach>
drmeister: Pull request merged. Thanks! And yes, I can remove it.
<beach>
Dependency removed. Thanks!
lagagain has joined #lisp
smasta has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
smasta has quit [Ping timeout: 256 seconds]
les has joined #lisp
dtornabene has quit [Quit: Leaving]
dddddd has quit [Remote host closed the connection]
kbtr has joined #lisp
kbtr has quit [Client Quit]
kbtr has joined #lisp
Oladon has quit [Read error: Connection reset by peer]
Oladon has joined #lisp
hexfive has quit [Quit: 404 hexfive not found]
<drmeister>
Hey lispers - when people refer to "tooling" as being important in how they use their programming languages and IDE's - do you know what that means?
<drmeister>
I think I kind of know what it means - but I'm trying to broaden my understanding of what people think it is.
<beach>
Where did you see it used?
Oladon has quit [Quit: Leaving.]
<drmeister>
I guess this kind of answers my question:
<drmeister>
When I read responses on Hacker News to new language announcements - invariably someone says "Your new language X sucks because it lacks what my language Y has - which is the tooling".
fikka has quit [Ping timeout: 260 seconds]
nullman has quit [Ping timeout: 240 seconds]
<drmeister>
We have a lot of that with quicklisp, asdf, and slime - I guess.
<beach>
Sort of, yes.
nullman has joined #lisp
<drmeister>
One of the promises of Clang's AST tools that hasn't really been realized afaik is that it would improve tooling for C++ syntax aware tools.
<beach>
We shouldn't be too proud of having the best tools, though.
<beach>
We could do a lot better than SLIME, for example.
<drmeister>
Cleavir's cst-to-ast could provide new capabilities for slime.
<drmeister>
syntax highlighting, finding locations that call a function, finding where functions are defined - these could be made more robust with cst-to-ast.
<drmeister>
Source to source translation could also be carried out.
Bike has quit [Quit: Lost terminal]
smasta has joined #lisp
fikka has joined #lisp
<beach>
Currently, most implementations implement TRACE by modifying the code. Then you can't debug the debugger.
<drmeister>
Imagine if someone makes a poor choice for a function name - or dynamic variable. grep/search/replace is brittle and error prone. A syntax aware search and replace would be much more robust.
<beach>
The good thing here is that I plan to use CST-to-AST also in Second Climacs, so that we can avoid code duplication.
<drmeister>
Can I just say that I think "Second Climacs" is an unfortunate name for an editor?
<beach>
You are not alone.
<beach>
I guess I will be the only user.
<drmeister>
I feel the same way about "Slime" - love the programming environment - hate the name.
<beach>
Aside from that, I mean, calling the SLIME debugger a "debugger" is a joke.
<beach>
And it makes people think that we have the greatest programming environment around.
schoppenhauer has quit [Ping timeout: 240 seconds]
<beach>
That just isn't the case.
<drmeister>
That won't make me stop using something - but I'd love to see a better "official" name.
<drmeister>
I don't disagree with you about sldb.
<loke>
beach: There are no screenshots or references in the PDF on clordane you posted.
schoppenhauer has joined #lisp
<beach>
loke: That's because it doesn't exist. It's a specification.
<loke>
I see
smurfrobot has joined #lisp
<beach>
The point here is that our Common Lisp implementations need to make breakpoints "thread aware" so that we can have one thread run the debugger to debug another thread.
<beach>
As long as that is not happening, we are doomed to have inferior programming environments.
Kevslinger has quit [Quit: Connection closed for inactivity]
raynold has joined #lisp
mfiano has quit [Quit: WeeChat 1.9.1]
patche has joined #lisp
warweasle has quit [Remote host closed the connection]
<beach>
If we do it that way, we can even allow the user to set breakpoints in standard functions like READ or GETHASH. Currently, that would almost certainly make the debugger stop working.
<drmeister>
I don't disagree. For things like that I currently use gdb or lldb - but they are not lisp aware.
<beach>
How does Clasp implement traces and breakpoints?
<drmeister>
Traces - I think it compiles a wrapper function. Breakpoints - I use lldb or gdb.
<beach>
So it replaces the FDEFINITION by the wrapper?
smurfrobot has quit [Ping timeout: 268 seconds]
<drmeister>
I say I think it compiles a wrapper function because I haven't investigated how it works. I inherited it from ECL and it just works.
<beach>
I see.
<beach>
I'll ask jackdaniel then.
<drmeister>
The behavior is consistent with replacing the fdefinition with a wrapper.
<aeth>
Do people use issue trackers to track future features in large Lisp projects? Or do people use something else (e.g. org files?)
<beach>
Well, that technique doesn't really "work" according to me.
<drmeister>
The trace disappears if I recompile the function.
<loke>
aeth: Github issue tracker is popular.
<beach>
drmeister: Are you sure about that?
<drmeister>
Yes I'm sure about recompiling the function and losing any trace on it.
<beach>
drmeister: If you say (compile #'my-fun), then it disappears?
<drmeister>
No - if I C-c C-c it in slime.
<drmeister>
I can verify in a few min.
<beach>
drmeister: Then you are not only recompiling the function, but also modifying the FDEFINITION.
terpri has quit [Ping timeout: 256 seconds]
red-dot has joined #lisp
blacknc has joined #lisp
<drmeister>
Good point
mishoo has joined #lisp
<beach>
Anyway, I suspect Clasp and ECL (just like SBCL) don't have thread-aware trace points or breakpoints.
<beach>
I am fairly sure I could say the same of every other free Common Lisp implementation.
fikka has quit [Ping timeout: 240 seconds]
pierpa has quit [Quit: Page closed]
fikka has joined #lisp
randomstrangerb has quit [Ping timeout: 268 seconds]
Devon has quit [Ping timeout: 256 seconds]
randomstrangerb has joined #lisp
<aeth>
What would it take to multithread compilation in CL?
<aeth>
I don't think most implementations do this.
FreeBirdLjj has joined #lisp
terpri has joined #lisp
groovy2shoes has joined #lisp
FreeBirdLjj has quit [Ping timeout: 240 seconds]
wigust has joined #lisp
blacknc has quit [Quit: Leaving]
<shaftoe>
fiddlerwoaroof_: where's your linedit fork repo?
ebzzry has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
damke has joined #lisp
smurfrobot has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
ebzzry has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
LocaMocha has joined #lisp
lagagain has quit [Quit: Connection closed for inactivity]
khrbt has joined #lisp
khrbt has left #lisp [#lisp]
khrbt has joined #lisp
zooey has quit [Ping timeout: 255 seconds]
<beach>
So here is an idea for the implementation of thread-aware breakpoints in x86. The important feature is that threads that are not being debugged should not take too big a performance hit.
<beach>
I suggest that, when code is compiled with a high value of the DEBUG quality, then the execution of each form starts and ends with a test of the DF status flag. If 0, then execution continues as normal.
<beach>
If 1, then some further action is taken to determine whether there is a breakpoint at this point in the code. The "further action" remains to be specified, but the slow version would be to interrogate a breakpoint table in the thread instance.
kushal has joined #lisp
red-dot has joined #lisp
<beach>
The use of the DF flag means that, if the implementation uses specific instructions that depend on its value, then the value has to be saved and restored around the execution of these instructions.
<beach>
Any thoughts or questions?
zooey has joined #lisp
vibs29 has quit [Ping timeout: 248 seconds]
<rme>
when I last looked into using the x86 direction flag, I found that manipulating it was expensive. it ended up being faster to set a flag in memory.
<beach>
Interesting.
<White_Flame>
I'm kind of preferential to Java-style interruption, where an address is routinely read. If it's to be interrupted, the address range is made unreable. Now, you could extend this so each thread is reading a different address (just an indirection through a thread-local pointer), and/or use different addresses per potential breakpoint.
<beach>
rme: Even reading it is expensive?
<White_Flame>
I think you have to push flags to stack to read the DF flag, only set & clear are part of the ISA
<rme>
it's been long enough ago that I don't remember the exact details, I'm afraid.
vibs29 has joined #lisp
<beach>
White_Flame: It seems you are right about that.
<phoe>
and 99.9% of the time you'll be reading it, only 0.01% will be clearing/setting it
safe has quit [Read error: Connection reset by peer]
<White_Flame>
hmm, if you have ample room in your 64-bit address space, you could read thread_local_page + N*program_counter to get a unique memory-protection based interrupt per location in your code
<White_Flame>
per location per thread
<beach>
White_Flame: Good ideas. I'll think about your suggestion(s).
<White_Flame>
and with future fixes for meltdown/crispr, it might even be quicker to interrupt than it is now ;)
<White_Flame>
erm, spectrre
<rme>
I'd want to look at trying to use the dr0 through dr3 debug registers on x86 for setting hardware breakpoints if possible
<beach>
rme: I haven't had the time to read up on hardware breakpoints, but that's an important subject.
oleo has quit [Quit: Leaving]
zooey has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 240 seconds]
knobo has joined #lisp
zooey has joined #lisp
fikka has joined #lisp
<beach>
I still like the DF over an address in memory, because that address would have to depend on the thread, making it expensive to read because of indirection. But here is a compromise: at the entry of each function compiled with a high value of the DEBUG quality, move the DF flag to a register or to the local stack frame so that each further test inside the function is cheaper.
Karl_Dscc has joined #lisp
<beach>
I like White_Flame's suggestions as a "second test" when the flag is set.
<beach>
Some simple hash-like technique could be used. Take the PC modulo (say) 256 and consult a table in the thread instance. If a bit is set there, then consult a complete hash table to determine whether this PC value actually has a breakpoint.
<White_Flame>
I suspect the Java way is one of the least intrusive, though it probably does tie up a cache line
<beach>
I fear it will be expensive for threads that are not debugged.
<rme>
there's almost certainly going to be thread-local memory maintained by the lisp runtime. on ccl, %fs or %gs points to the thread-local memory block (except on highly advanced systems like macOS, where we have to burn a gpr for this).
<White_Flame>
beach: each thread reads its own address; you only deny read permissions for the memory page for one thread, in my idea
<White_Flame>
I don't know recall if Java's was per-thread, or for stop-the-world
<White_Flame>
-know
smasta has quit [Ping timeout: 248 seconds]
<beach>
Oh, so you play with the memory manager for different threads?
<White_Flame>
basically, each thread just reads a canary location in memory. When you want to halt a thread, play with the memory manager for a particular canary location
<White_Flame>
each thread reads a _separate_ per-thread location
<beach>
Oh!
<beach>
That sounds expensive, though.
fikka has quit [Ping timeout: 264 seconds]
<beach>
Go to the thread instance, find the address to read, then read it.
<beach>
Sounds like several memory accesses.
<beach>
No?
<beach>
Am I missing something?
<White_Flame>
hopefully it's just a single indirection
<White_Flame>
I don't know all the addressing modes available
<beach>
That sounds way more expensive than testing a bit though.
<beach>
No?
<White_Flame>
the thing is, it'll always be cached. Which can also be a downside
<White_Flame>
the code footprint would be smaller for the memory location, though
<White_Flame>
depends on what you need
<beach>
What makes you think it is smaller?
quazimodo has joined #lisp
<White_Flame>
it's just a read through a register+offset indirection, assuming a thread-local table is in a register
<White_Flame>
that doesn't require many bytes of SIA
<White_Flame>
ISA
<beach>
I think I understand.
pagnol has joined #lisp
<beach>
So, either way, we have at least two ways of making thread-aware breakpoints with very little cost for threads that are not being debugged, and a modest cost for a thread being debugged, but not at this particular value of PC.
<White_Flame>
If you did a read of thread-local-canary-address + 4k*PC, then maybe you could use the same trick to interrupt at a particular PC on a particular thread
heurist` has joined #lisp
heurist has quit [Ping timeout: 255 seconds]
<White_Flame>
having reserved a lot of 64bit address space for the purpose
waaron has joined #lisp
<beach>
That makes me nervous though. It could just be me of course.
<White_Flame>
I'm fully aware that my imagination has no limits of practicality :)
<beach>
Heh!
patche has quit [Quit: Lost terminal]
<White_Flame>
but a 64 bit space is ... big
<White_Flame>
if I remember correctly, the width of the visible universe in terms of electron-diameters is on the order of 2^80
<beach>
It is not important to me at this point to know the exact solution; just that one exists. And I am now convinced that there are at least two.
flamebeard has joined #lisp
<jackdaniel>
someone told that god had to be a very cruel at the time he made men – give them mind with capabilities to make almost infinitely ambitious plans and time to live which doesn't allow to excercise them :)
jonh has quit [Quit: WeeChat 0.4.2]
makomo has quit [Quit: WeeChat 1.9.1]
shka has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
<aeth>
They're just being very forwards-compatible
<aeth>
Introduced in 1988, so probably more than 50 years forwards-compatible.
smasta has quit [Ping timeout: 256 seconds]
<beach>
White_Flame: Wait, your single per-thread address read suffers a severe performance problem when the potential breakpoint turns out not to be one.
<beach>
You have to go through the interrupt and context-switch mechanism, right?
<White_Flame>
only when you want to trigger the interrupt; that should only happen once
mishoo has quit [Ping timeout: 256 seconds]
dec0n has joined #lisp
<beach>
I don't see that.
<beach>
Here is a thread being debugged, so I arrive at some point in the code and I read my unique address.
<White_Flame>
but yeah, switching the MMU stuff to reject he read and flushing TLB cache or whatever is a pretty expensive operation, but that's all involved when you actually perform the interrupt, not exploration
<beach>
The thread is being debugged, so I take the read fault.
<White_Flame>
ah, right, if it's just a per-thread address, and not per-thread address + 4k*pc
<beach>
But this particular PC value does not have a breakpoint associated with it.
<beach>
Right, which may be excessive.
<White_Flame>
so yes, it would constantly be interrupting until it found the PC
<White_Flame>
though the other threads would be left alone
<beach>
Sure.
<White_Flame>
there's all sorts of granularity tradeoffs you could make, like assign a page offset per function, so you only hammer it when it's in the particular function the breakpoint is in
<White_Flame>
but yeah, if you're not going to have it per-PC, then it might make more sense to do manual checks, if you can do them cheaply
<White_Flame>
random thought, but are there any feature of cpu affinity that could help isolate the thread?
<White_Flame>
*features (I hate this laptop keyboard)
Ober has quit [Quit: Emacs must have died]
sjl has joined #lisp
<White_Flame>
but really, how expensive is it to set a breakpoint, and test to see if you're in the intended thread?
<White_Flame>
especially compared to other goofier ideas
makomo has joined #lisp
<beach>
OK, final proposal that does not involve DF: At the entry of each function, read an address at a fixed offset in the thread instance. It contains a flag that indicates whether this thread is debugged.
<beach>
The contents is put in the stack frame or in a register, determined by the register allocator. Before and after the evaluation of each form, call a small local routine with PC as its argument.
<beach>
That routine starts by testing the flag. If 0 it returns normally (this is the case when the thread is not being debugged). If 1, it takes PC modulo (say) 1024 and consults a bit table in the thread instance.
<beach>
If the table contains a 0 (the usual case) then it returns normally, because it means there is no breakpoint at this PC value. If 1, it consults a hash table in the thread instance to see whether this particular PC value has a breakpoint.
<beach>
If not, it returns normally. If it does, it suspends execution and gives control to the debugger thread.
pagnol has quit [Ping timeout: 240 seconds]
mlf has joined #lisp
<beach>
White_Flame: I don't know the answer to your question, but this last solution of mine would work on any architecture.
sjl has quit [Ping timeout: 240 seconds]
<White_Flame>
hmm, it would only work for a single breakpoint, but if you could do 1/(PC - read-from-thread-local), you could trigger a divide by zero exception if that location was set to the current PC
<White_Flame>
but then again, a simple test and branch could do the same
<beach>
Yeah.
<beach>
When the debugger sets a breakpoint, it updates the hash table and the bit table in the thread instance. When a breakpoint is being removed, it clears the bit table, traverses the hash table to set the bits in the bit table.
<beach>
I think this last technique wold work fairly well, with minimal performance impact.
<White_Flame>
hmm, if you double the memory footprint of your code, you could have a flag per instuction byte
<White_Flame>
then it's a large PC-relative offset to see if that flag matches your current thread pointer
<White_Flame>
ie, 15MB of code footprint, then 15MB of zeros mirroring the same locations
<phoe>
I don't think he wants per-instruction breakpoints though, rather one breakpoint per Lisp form.
<White_Flame>
I know, most of them would be unused
<White_Flame>
but they'd be immediate to calculate
<White_Flame>
just read PC+some_big_offset, compare to thread-local register
<phoe>
It will be fast, correct.
<White_Flame>
it's nice living in the future where you can throw egregious amounts of RAM at a problem
<beach>
Hmm. If I make the bit table smaller, say 64 bits, I can skip the single bit and load this small table to the stack or to a register (subject to register allocation). The famous small routine would then immediately test a bit that is PC modulo 64. How much more expensive would that be compared to testing one single bit? I am guessing "not much".
<beach>
Maybe not. The debugger would have to know how to update the local version of the bit table. Not worth it, probably.
milanj has joined #lisp
fikka has joined #lisp
lnostdal has joined #lisp
<shka>
White_Flame: it would be nice, if people would not throw copious amounts on RAM into web based application
<White_Flame>
guilty as charged ;)
<White_Flame>
but I think a good post-IDA disassembler (my big web-based application) tends to be for people willing to have big hardware footprints
<White_Flame>
(hmm, though I think I technically started it way before IDA was a thing...)
mishoo has joined #lisp
vlatkoB has joined #lisp
aindilis has quit [Read error: Connection reset by peer]
HDurer has quit [Remote host closed the connection]
nicdev has quit [Remote host closed the connection]
smasta has quit [Ping timeout: 255 seconds]
Cymew has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
HDurer has joined #lisp
stux|RC-- has quit [Ping timeout: 240 seconds]
stux|RC has joined #lisp
emacsoma` has joined #lisp
emacsomancer has quit [Ping timeout: 260 seconds]
<phoe>
What is the ELS mailing list address?
<phoe>
I'll want to unsubscribe from one address and subscribe from another one.
<phoe>
Oh, I got it. Thanks.
shifty has quit [Ping timeout: 248 seconds]
schweers has joined #lisp
akkad has joined #lisp
varjag has joined #lisp
JoJoen is now known as parseval
krasnal has joined #lisp
<beach>
A summary of my own conclusions of the discussion on breakpoints is now in Appendix A of this document: http://metamodular.com/clordane.pdf
<beach>
I will submit it to nyef`` when he wakes up, because we have discusses such things in the past.
<beach>
Interesting related information: When I run SICL inside a host Common Lisp implementation (currently SBCL), I can implement breakpoints this way with very little effort. I can then implement Clordane so that it can debug SICL programs, even though 1. SICL doesn't really exist, and 2. SBCL doesn't support per-thread breakpoints.
<phoe>
Hah!
<aeth>
Impressive
<phoe>
1) Well, now it does. 2) Well, now it does.
<beach>
Compare this idea to generating a SICL executable sooner rather than later. Then I would lose all my usual tools and I would have to resort to GDB or something similar with absolutely no knowledge of Common Lisp.
vydd has joined #lisp
vydd has joined #lisp
vydd has quit [Changing host]
<schweers>
beach: So its possible to add better debuggers to existing implementations without modifying said implementation?
<beach>
Not really. I am not improving the processing of native SBCL code. Only code compiled with the SICL compiler for execution inside SBCL.
<beach>
So you would have to compile all your code with the SICL compiler.
<beach>
I am basically accumulating evidence that I should not be hasty when it comes to creating a native SICL executable, and even less so when it comes to creating a bootable LispOS image. Instead, I should take advantage of a safe execution environment (here SBCL) to make the system as complete as possible first.
damke has quit [Ping timeout: 264 seconds]
scymtym has quit [Ping timeout: 260 seconds]
murii has joined #lisp
hhdave has joined #lisp
malm_ has joined #lisp
sz0 has quit [Quit: Connection closed for inactivity]
malm_ has quit [Client Quit]
<loke>
beach: What is the status of sicl at th emoment?
<beach>
Strange! Most of the code exists, but I am making very slow progress with the bootstrapping phase.
jack_rabbit has joined #lisp
JuanDaugherty has joined #lisp
<schweers>
beach: out of curiosity: what exactly does sicl do? does it compile to native code or something else?
<beach>
It will when it's done. Right now, it generates AST then HIR. The HIR code is then turned into a small subset of Common Lisp that is compiled on the host compiler for ultimate execution.
<schweers>
Small as in: its easier to write a compiler for, instead of for full CL?
<beach>
And the Common Lisp that is submitted to the host compiler uses first-class global environments for all its lookups.
<beach>
I haven't contemplated that possibility. It is probably easier to start with HIR directly for any other backend.
<raynold>
ahh it's a wonderful day
scymtym has joined #lisp
JuanDaugherty has quit [Quit: Ex Chat]
randomstrangerb has quit [Ping timeout: 268 seconds]
randomstrangerb has joined #lisp
reverse_light has joined #lisp
angavrilov has joined #lisp
quazimodo has quit [Ping timeout: 256 seconds]
shrdlu68 has joined #lisp
lnostdal has quit [Ping timeout: 276 seconds]
lnostdal has joined #lisp
clog has joined #lisp
smurfrobot has joined #lisp
vydd has quit [Quit: Leaving]
smurfrobot has quit [Remote host closed the connection]
quazimodo has joined #lisp
scottj has joined #lisp
<hajovonta>
hello
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
markong has joined #lisp
<shrdlu68>
hajovonta: hi
zooey has quit [Ping timeout: 255 seconds]
Oddity has quit [Ping timeout: 264 seconds]
Kaisyu7 has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
vhost- has quit [Ping timeout: 268 seconds]
heurist` is now known as heurist
zooey has joined #lisp
smurfrobot has joined #lisp
vhost- has joined #lisp
red-dot has joined #lisp
makomo has quit [Ping timeout: 248 seconds]
randomstrangerb has quit [Ping timeout: 256 seconds]
Cymew has quit [Remote host closed the connection]
randomstrangerb has joined #lisp
kedorlaomer has joined #lisp
smurfrobot has quit [Remote host closed the connection]
nullniverse has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
<_death>
now incorporate Go's fix for this deficiency of C..
<flip214>
Shinmera: for EQL-clauses, yeah, right.
<flip214>
would need to accumulate TAGs if arbitrary expressions need to be allowed (as in COND)
<Shinmera>
Well, C only does EQL too, so
<flip214>
good work.... the only thing missing is a BREAK macrolet that does (GO ,end) ;)
<Shinmera>
You can't do that because BREAK is a CL symbol
<flip214>
Shinmera: "case 5 .. 100:" in at least some compilers
<Shinmera>
You can instead use RETURN
<_death>
(break should be the default and there should be a fallthrough macro..)
<flip214>
Shinmera: how about pushing that into alexandria or so?
<_death>
flip214: pushing macros with 0 users to alexandria?
<flip214>
_death: yeah, right. although that would break the compatibility with C.
<flip214>
_death: unless it's pushed somewhere, it will tend to _stay_ at 0 users.
<_death>
alexandria is a conservative library..
<flip214>
thanks anyway.
sz0 has joined #lisp
<Shinmera>
I don't want this macro, so you can push it into alexandria
fikka has quit [Ping timeout: 260 seconds]
milanj has joined #lisp
fikka has joined #lisp
<flip214>
I don't even succeed with docstring typo fixes, so that won't happen
dddddd has joined #lisp
troydm has quit [Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset]
fikka has quit [Ping timeout: 264 seconds]
heurist` has joined #lisp
heurist has quit [Ping timeout: 248 seconds]
orivej has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
jfb4 has quit [Ping timeout: 248 seconds]
red-dot has joined #lisp
jfb4 has joined #lisp
krasnal has quit [Remote host closed the connection]
papachan has quit [Ping timeout: 248 seconds]
damke has joined #lisp
hvxgr has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
<Xach>
khrbt: maybe we could move the github one to sharplispers and call it canon? i can check with nikodemus
scymtym_ has joined #lisp
Devon has joined #lisp
scymtym has quit [Ping timeout: 255 seconds]
troydm has joined #lisp
makomo has joined #lisp
reverse_light has quit [Remote host closed the connection]
asarch has joined #lisp
xrash has joined #lisp
<alandipert>
is there a way to specify a quicklisp disp on a per-project basis? ie http://blog.quicklisp.org/2011/08/going-back-in-dist-time.html appears to set the dist for all subsequent lisp processes on the machine; i'm curious about setting it just for a session/image
<Xach>
alandipert: you can have multiple quicklisp directories - everything is done relative to the initial setup.lisp file.
<Xach>
you could have one in each project if you wanted
<Xach>
it will cost me many picodollars, but i am willing to deal
<alandipert>
Xach thanks, that sounds like a good solution :-)
<alandipert>
Xach i'm kind of a noob, so to clarify... for the per-project way, each project would have something like setup.lisp in it, right? since i see the *quicklisp-home*/qmerge stuff at the top
<Xach>
alandipert: you would have basically an entire quicklisp directory in it (the actual name doesn't matter, just the file arrangement under it)
<Xach>
you can do that with the quicklisp.lisp installer file by using a :path option too
<Xach>
e.g. (quicklisp-quickstart:install :path "my-project/quicklisp/")
scottj has quit [Quit: leaving]
<Xach>
or just cp -a an existing installation, or equivalent
smurfrobot has joined #lisp
<alandipert>
Xach that's great, thanks again
dilated_dinosaur has quit [Ping timeout: 255 seconds]
smurfrobot has quit [Ping timeout: 260 seconds]
pjb has quit [Ping timeout: 256 seconds]
FreeBirdLjj has joined #lisp
murii has quit [Ping timeout: 240 seconds]
zooey has quit [Ping timeout: 255 seconds]
zooey has joined #lisp
pjb has joined #lisp
dilated_dinosaur has joined #lisp
schweers has quit [Read error: Connection reset by peer]
schweers has joined #lisp
pjb has quit [Remote host closed the connection]
pjb has joined #lisp
drot has quit [Quit: Quit.]
rumbler31 has joined #lisp
drot has joined #lisp
murii has joined #lisp
warweasle has joined #lisp
murii has quit [Client Quit]
<attila_lendvai>
I can push to alexandria and I don't know about any pending non-controversial patches
hvxgr has quit [Quit: leaving]
hvxgr has joined #lisp
murii has joined #lisp
murii has quit [Client Quit]
murii has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
z3t0 has joined #lisp
igemnace has quit [Quit: WeeChat 2.0.1]
smurfrobot has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
z3t0 has quit [Ping timeout: 248 seconds]
Tobbi has joined #lisp
FreeBirdLjj has joined #lisp
fikka has joined #lisp
Bike has joined #lisp
smurfrobot has quit [Remote host closed the connection]
attila_lendvai has quit [Read error: Connection reset by peer]
nullniverse has quit [Read error: Connection reset by peer]
Devon has quit [Ping timeout: 264 seconds]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
FreeBirdLjj has quit [Ping timeout: 248 seconds]
z3t0 has joined #lisp
Kevslinger has joined #lisp
ikki has joined #lisp
FreeBirdLjj has joined #lisp
z3t0 has quit [Ping timeout: 264 seconds]
papachan has joined #lisp
mishoo has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 263 seconds]
FreeBirdLjj has quit [Ping timeout: 268 seconds]
kami has joined #lisp
<kami>
Hello #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<beach>
Hello kami.
FreeBirdLjj has joined #lisp
<phoe>
hey hi
Oddity has joined #lisp
zooey has quit [Ping timeout: 255 seconds]
<rumbler31>
good morning
scymtym__ has joined #lisp
red-dot has joined #lisp
ebzzry has quit [Ping timeout: 240 seconds]
sjl has joined #lisp
smurfrobot has joined #lisp
JuanDaugherty has joined #lisp
z3t0 has joined #lisp
scymtym_ has quit [Ping timeout: 265 seconds]
zooey has joined #lisp
fikka has joined #lisp
ebzzry has joined #lisp
z3t0 has quit [Ping timeout: 248 seconds]
LiamH has joined #lisp
<shrdlu68>
What's the purpose of #'cl:char-int ?
<Bike>
some part of the "attributes" thing nobody uses any more
<shrdlu68>
Oh, I see.
fikka has quit [Ping timeout: 260 seconds]
ebrasca has joined #lisp
fikka has joined #lisp
<pjb>
For example, you could encode font attributes there, so you could write bold or italic characters with format.
<tfb>
CL originally had char-bits and other functions to deal with attributes (all coming from Symbolics I think), and char-int included the bits but char-code didn't
<tfb>
(or, perhaps, the other way around)
<tfb>
but that all went away between CLtL1 and 2 I think (might have still been there in 2, was gone by the standard)
kami has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 255 seconds]
oleo has joined #lisp
rippa has joined #lisp
z3t0 has joined #lisp
knobo has quit [Ping timeout: 248 seconds]
z3t0 has quit [Ping timeout: 255 seconds]
asarch has quit [Ping timeout: 256 seconds]
smurfrobot has quit [Remote host closed the connection]
<phoe>
I think that Unicode rendered this function more or less useless.
eivarv has joined #lisp
<Bike>
it's not about code points. in old lisp implementations you could encode things like a character being italicized or having a particular color.
FreeBirdLjj has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 248 seconds]
mnoonan has joined #lisp
fikka has joined #lisp
zaquest has quit [Ping timeout: 260 seconds]
FreeBirdLjj has joined #lisp
murii has quit [Quit: WeeChat 1.4]
Cymew has quit [Remote host closed the connection]
emacsoma` has quit [Ping timeout: 276 seconds]
<kolb>
I just learned that LispWorks does unicode in a weird way, i.e. (length "a⍳c") → 5
<antoszka>
Oops.
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
zaquest has joined #lisp
<antoszka>
I apparently counts the bytes.
<antoszka>
~ echo -n "a⍳c" | hexdump -C
<antoszka>
00000000 61 e2 8d b3 63
red-dot has joined #lisp
murii has joined #lisp
<kolb>
well "weird" is maybe too much said, more like encoding unaware but 8-bit clean
<kolb>
except in symbol names :>
<shka>
Shinmera: what is the canonical way to handle errors from api (like handling incorrect user input
<shka>
)
<shka>
?
Cymew has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
<Shinmera>
shka: If the error is of type api-error, then the API will automatically handle it be either outputting it as data, or redirecting back with the error GET parameter set if the browser parameter is "true"
FreeBirdLjj has quit [Remote host closed the connection]
<shka>
neat!
<shka>
thanks
FreeBirdLjj has joined #lisp
<Shinmera>
So typically in forms I have a hidden input field that sets "browser" to "true"
<shka>
btw, are you online 24/7? :D
<Bike>
antoszka: so what do you get from (char "a⍳c" 3), exactly
turkja has quit [Ping timeout: 240 seconds]
<Shinmera>
No, but I'm typically around between 8:00-24:00 CE(S)T
pjb has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 255 seconds]
<antoszka>
Bike: I have sbcl so cannot reproduce the problem.
z3t0 has joined #lisp
<antoszka>
As kolb says, it's probably just 8-bit clean
<Shinmera>
shka: I'm considering changing it to handle all errors except for special ones.
<Shinmera>
shka: Since being able to just (error "foo") and it doing the right thing would be much more convenient
Cymew has joined #lisp
warweasle is now known as warweasle_afk
warweasle_afk has quit [Quit: rcirc on GNU Emacs 24.4.1]
<shka>
sounds somewhat reasonable
<Shinmera>
The reason I didn't do so so far is that catching all errors might leak information you don't want to leak.
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
flamebeard has quit [Quit: Leaving]
<shka>
perhaps automatic logging of errors and redirecting to "Sorry, programmer is any idiot :(" page would be better
<shka>
that's it: anything that is not api-error
pjb has joined #lisp
<Shinmera>
Maybe, but it still increases boilerplate a lot since it doesn't integrate well with other libraries.
z3t0 has quit [Ping timeout: 248 seconds]
<Shinmera>
So for instance if you have a thing that checks inputs or whatever for validity and uses errors, that won't automatically translate to the useful behaviour.
Cymew has quit [Ping timeout: 255 seconds]
Cymew has joined #lisp
<shka>
true, but errors like those signaled by find-class are weird
<Shinmera>
Right
pjb has quit [Remote host closed the connection]
ikki has joined #lisp
dec0n_ has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
scymtym__ has quit [Ping timeout: 255 seconds]
dec0n has quit [Ping timeout: 268 seconds]
pjb has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
hajovonta has quit [Quit: hajovonta]
moei has joined #lisp
dec0n_ has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 256 seconds]
pjb has quit [Remote host closed the connection]
hexfive has joined #lisp
brendyn has quit [Ping timeout: 260 seconds]
SaganMan has quit [Quit: WeeChat 1.6]
<shka>
Shinmera: i have another trivial question
fikka has joined #lisp
<shka>
how can i make this (post/get "browser") return true
<shka>
AKA: what should i put in my html
<shka>
i know it may seem stupid but i am scratching my head right now
<Shinmera>
If you have a form: <input type="hidden" name="browser" value="true">
<shka>
riiiight
<Shinmera>
If it's just a link, add ?browser=true or whatnot to the end.
<Bike>
Has anyone ever used next-method-p? i have no concept of how it would be used and am curious.
<shka>
honestly i forgot about that hidden html form crap
<Shinmera>
Bike: I have
pjb has joined #lisp
<shka>
Shinmera: thanks
<shka>
Bike: I did, but later refactored my code to get rid of it
schweers has quit [Read error: Connection reset by peer]
<oleo>
i thought next-method-p is a thing to be called in :around methods
schweers has joined #lisp
schweers has quit [Client Quit]
<Shinmera>
Bike: Generally I find it useful if you want to do something like the append/etc method combination, but want to leave control to the method definer about whether they want to exclude superclasses or not.
<shka>
oleo: around method won't be called if you don't have primary method so what's the point?
<tazjin>
does someone know of an example for using enum types in postgres via postmodern?
<oleo>
shka: who said that ?
<oleo>
clos looks for primary methods first it doesn't say there have to be primary methods in order for the rest to be looked up.....
<oleo>
afaik
<shka>
uuuuh
<shka>
i am wrong again i guess…
<shka>
i honestly thought that this is the case
<oleo>
nope, i don't think so
<oleo>
you can be done with just one :around method
<oleo>
which is then default
pjb has quit [Ping timeout: 265 seconds]
<tfb>
kolb: you should read the LW documentation on unicode.
<oleo>
and it won't call other bookkeeping stuff, so if you still want that you need the call-next-method in it
<oleo>
so before calling call-next-method you can use call-next-method-p in order to ensure there is anything to be called....
<oleo>
in order to not salvage calls needlessly
Devon has quit [Ping timeout: 268 seconds]
hvxgr has quit [Read error: Connection reset by peer]
<shka>
Shinmera: i think that i found bug
<oleo>
brb
oleo has quit [Quit: Leaving]
<shka>
i setfed *debugger* to nil, but then out of sudden i get messages like Handling stray condition: The variable MODULARIZE-HOOKS:NAME is unbound.
fikka has quit [Ping timeout: 276 seconds]
<shka>
ok
<shka>
never mind
<shka>
stupid mistake :D
hexfive has quit [Remote host closed the connection]
hexfive has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
FreeBirdLjj has quit [Remote host closed the connection]
_cosmonaut_ has quit [Ping timeout: 248 seconds]
<khrbt>
Xach: yes, would be good to get linedit on sharplispers. I would be happy to assist with testing and merging of patches/PRs.
hexfive has quit [Read error: Connection reset by peer]
smurfrobot has quit [Ping timeout: 256 seconds]
<_death>
oleo: right, so :around methods for those usually don't need next-method-p
hexfive has joined #lisp
zaquest has quit [Read error: Connection reset by peer]
ebzzry has quit [Ping timeout: 248 seconds]
<oleo>
err, wha ?
FreeBirdLjj has joined #lisp
<oleo>
If an around method invokes call-next-method, the next most specific around method is called, if one is applicable. If there are no around methods or if call-next-method is called by the least specific around method, the other methods are called as follows: ....
<oleo>
if
fikka has joined #lisp
<oleo>
i.e. if it does not call-next-method then those won't get called....
<_death>
c-n-m can be passed arguments..
zaquest has joined #lisp
<oleo>
like call a specif one ?
Karl_Dscc has joined #lisp
<_death>
I think there's some confusion.. if an :around method does not c-n-m, of course no next method will be called..
<oleo>
yep
<oleo>
that's what i said
<oleo>
so when it has a c-n-m then it looks for a most specific :around method again, if there's none it goes to the least specific :around method and then from there to the rest of the methods
<oleo>
the bookeeping ones
<_death>
but usually it can assume that there will be a next method, so next-method-p is not needed
<oleo>
welp, you cycle once more.....
<oleo>
if you assume....
lnostdal has joined #lisp
<_death>
modality is different from material implication
nirved has joined #lisp
<_death>
let's say, find a scenario where next-method-p returns nil in an :around method
smurfrobot has joined #lisp
<oleo>
(when (next-method-p) (call-next-method))
<_death>
this is meaningless, give code that works
JonSmith has joined #lisp
Walex has joined #lisp
FreeBirdLjj has quit [Ping timeout: 256 seconds]
smurfrobot has quit [Ping timeout: 276 seconds]
makomo has quit [Ping timeout: 264 seconds]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
<alandipert>
is anyone aware of anything like a design discussion about lisp keywords? the 'why' and history of keywords. thanks in advance for pointers
hhdave has quit [Ping timeout: 248 seconds]
dyelar has quit [Ping timeout: 240 seconds]
tsuru has joined #lisp
asarch has joined #lisp
damke_ has joined #lisp
m00natic has quit [Remote host closed the connection]
<phoe>
alandipert: keywords are just symbols that evaluate to themselves. I do not know which dialect of Lisp they originate from though. Why do you ask?
<alandipert>
i am curious about aesthetic arguments for and against them, since they're technically equivalent to quoted symbols
<_death>
phoe: that's not the whole story, of course.. the reader is also modified to make keywords convenient to use
damke has quit [Ping timeout: 264 seconds]
<Xach>
Yeah, (open "foo.txt" 'direction 'output) then involves package management or string compares or deeper trickery
orivej has quit [Ping timeout: 248 seconds]
<_death>
alandipert: what are "quoted symbols"?
<alandipert>
_death an expression that evaluates to a symbol object
<Xach>
I don't know about their history but I appreciate their convenience
<tfb>
alandipert: suspect strongly keywords originated in Lisp machine lisp
smasta has joined #lisp
<_death>
alandipert: a keyword is a symbol exported from the package named "KEYWORD" that evaluates to itself.. the reader is hacked to intern keywords this way, and to accept :foo as keyword:foo
<alandipert>
Xach in what respect do you find them convenient? considering 'foo and :foo are the same number of characters to type. visual distinction, automatic package membership, combination thereof?
<tfb>
along with packages (not in MACLISP, but are in Zetalisp)
<_death>
alandipert: this makes it convenient to use them as global names
<Shinmera>
alandipert: You're not comparing it properly. :foo is the same as 'keyword:foo. The /point/ of keywords is that they come from one single package.
<tfb>
alandipert: if you have a lot of functions which need an 'test' keyword argument, you need a home-package for that symbol. That package could be CL, but probably should not be. So it's KEYWORD
<tfb>
(in fact it can't be CL because that would require you to be able to intern new symbols in CL and that would be horrible)
<oleo>
doesn't 'bla get interned automatically ?
<oleo>
polluting the current package name space ?
<Xach>
alandipert: :foo means the same thing regardless of the value of cl:*package*. Not so with 'foo.
varjag has joined #lisp
<oleo>
heh
<Xach>
They are used as syntax, not as names, so clashes are not generally an issue.
<Xach>
(I use them as names but never in something shared for others to use)
<alandipert>
_death thanks for that link, i'll check it out
<alandipert>
Shimera and thanks for the clarification about package origin, that seems like the key distinction. the ability to make human-readable names that are not in a package
<alandipert>
altho it makes me wonder why strings aren't as suitable
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
<Shinmera>
Because (eq "foo" "foo") is not T.
Folkol has joined #lisp
<oleo>
two strings on different addresses
<tfb>
strings are what languages which don't have symbols are forced to use as terrible substitutes for symbols
<Shinmera>
strings are a poor man's identifier. See almost any other language and the crutches they go through to do it like that.
<alandipert>
i'm familiar with this point of view but i'm trying to reach the next level of comprehending
FreeBirdLjj has joined #lisp
<alandipert>
why are they poor identifiers? because they are typically used to represent inputs instead of names for parts of programs?
<alandipert>
i realized after typing that my inquiries are indistinguisable from trolling, so i think i will go read more stuff and report back if i find anything interesting. thanks all for the observations and pointers :-D
fikka has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
smurfrobot has quit [Ping timeout: 260 seconds]
<_death>
strings are not atomic.. they also don't tend to live in namespaces
red-dot has joined #lisp
<tfb>
alandipert: because to compare two strings you need to compare them element-by-element, while symbol-comparison is an instruction
<Shinmera>
And you'd be allocating strings all over the place
nika has quit [Quit: Leaving...]
jmercouris has joined #lisp
<jmercouris>
so I've made a macro called defcommand, effectively it is a wrapper around defun that does some other things
<alandipert>
some VMs intern strings under various circumstances. like if they're under a certain size or appear as a constant. certainly concern, but comes with a possible tradeoff
<jmercouris>
my issue is, that defcommand does indentation wrong, at least by my perspective
<jmercouris>
I would like to have the same indentation as defun, is this possible? or no?
<Shinmera>
Colleen: tell jmercouris look up trivial-indent
<_death>
alandipert: it's generally recognized in other languages as well as that strings have "value semantics".. i.e. their identity is immaterial.. the identity of symbols is important
<Bike>
hey, nice. i've never understood the indentation rules and now, i don't have to
pjb has joined #lisp
<jmercouris>
Shinmera: DamN! very cool
dyelar has joined #lisp
<jmercouris>
Shinmera: Is there a way to pass a known indentation to define-indentation?
<Shinmera>
No
<jmercouris>
So i'd have to look up the slime source for a known indentation and copy/paste itin?
<Shinmera>
Well, INDENTATION is an accessor, but I don't think it'll tell you about functions not covered by trivial-indent itself.
<jmercouris>
Shinmera: Where do you usually put your indentations? alongside your macros?
<jmercouris>
in a separate file?
<Shinmera>
Under the macro in question
<jmercouris>
Shinmera: Very cool package man!
<_death>
jmercouris: if your defcommand takes (name lambda-list &body body) then the indentation should be similar to defun by default
tsuru has quit [Ping timeout: 276 seconds]
<jmercouris>
_death: yes, that is what my macro accepts, but for some reason indents differently
<jmercouris>
The number of indents is 4 instead of 2
<sjl>
that looks right. strange that you're getting an extra indent there
<jmercouris>
Let's see if shinmera's package is the secret sauce
hexfive has quit [Remote host closed the connection]
<_death>
jmercouris: defining that macro and indenting the defcommand form results in correct indentation here.. maybe your slime is {under|over}customized?
sz0 has quit [Quit: Connection closed for inactivity]
<jmercouris>
completely fresh emacs after having changed slime-indentation in config: https://youtu.be/OWVyu3QDnxk
smurfrobot has quit [Ping timeout: 240 seconds]
<_death>
you can use common-lisp-get-indentation in elisp to check the indentation
<jmercouris>
is that an interactive command?
<_death>
no.. M-x ielm
z3t0 has joined #lisp
Jesin has joined #lisp
<jmercouris>
No idea what ielm is, but it looks like an ELISP repl
<jasom>
is there a lite version of paredit? I'm thinking one where ( adds a pair of parens and ) jumps to the next closing one only; I have my own solutions for slurp/barf that I prefer.
smurfrobot has joined #lisp
<jmercouris>
anyways, (common-lisp-getindentation) results in "Symbols function definition is void"
<jmercouris>
it looks very strange, it has the correct number of elements
<_death>
maybe slime+ccl-related
<jmercouris>
is that hex it is showing?
<jmercouris>
or is # a special symbol in elisp?
<_death>
jmercouris: the result is 4.. the elisp repl just adds a bunch of "helpful" interpretations
_mjl has joined #lisp
<_death>
jmercouris: 4 in octal, 4 in hex, ascii char corresponding to code 4
<jmercouris>
I was about to say because "o" is definitely not a number in hex :D
<jmercouris>
oh okay, but why the # symbol?
<jmercouris>
every time I see 0x... I always think of hex
<jmercouris>
anyways doesn't matter
<_death>
it's just notation to denote an integer in different bases.. 0x is the C way, #x is the Lisp way
<jmercouris>
oh, so base "o" is octal
<_death>
base 8 is octal
<jmercouris>
I don't see an 8 anywhere in that string
<_death>
this is why October is month number 10, see?
<jmercouris>
I understand how octal binary hexadecimal etc work
<jmercouris>
the question is about #o4
<jmercouris>
what do the individual elements in that string mean?
<_death>
(years used to start on March)
<_death>
jmercouris: in elisp, you just take it as two tokens.. <#o><4>.. in Common Lisp, # is a dispatching macro character and o is a sub-char for octal
<jmercouris>
ok, that is what I was wondering, I get it now
<jmercouris>
thank you
<jmercouris>
just to close the issue, my indentation will simply not work I guess
<_death>
you need to dig further.. it's fun :)
_mjl has quit [Remote host closed the connection]
<jmercouris>
Maybe one of my modes is causing issues in some way
<pjb>
_death: the ascii code 4 is not a character code, it's a control code. There's no ascii character with that code. The only code corresponding to ascii characters are 32 to 126.
<jmercouris>
I'm not myself supremely interested in the intricacies of what is a control char vs a real char, so I am just curious as to why
dyelar has quit [Quit: Leaving.]
<pjb>
jmercouris: depends if you want your software to break soon or to go on running after you're dead.
<jmercouris>
pjb: Well sure, I care about the quality of my software, and that's why I'm always eager to learn
<_death>
jmercouris: generally I dislike them.. but in this case I may be prompted to read the ascii standard ;)
<jmercouris>
but I am asking a different question
<jmercouris>
pjb: so, is your answer therefore "no, not really, but I'd like to write reliable software"?
<pjb>
jmercouris: there are formal definition. If you don't know them, your code will be approximative, and it will break sooner than later.
<jmercouris>
pjb: This is true, but it is again not the question I asked
<pjb>
jmercouris: everybody has his own pet-peevees. characters are one of mines.
<jmercouris>
pjb: Do you, or do you not enjoy, for non-practical reaasons, the intricacies of the difference between chars and control code chars
<jmercouris>
So it is not that you enjoy characters, but rather that they annoy you and you have set the record straight?
<pjb>
It's not that I enjoy it, it is, that's it. Like the difference between bosons and leptons.
<jmercouris>
it bothers you when there is misinformation?
<pjb>
yes.
dfsadsfasdf has joined #lisp
<_death>
pjb: now, what your code checks is that the character is designated as #\Eot rather than #\End-of-Transmission or #\Stop-It or whatever... I agree that there's no name defined in CL for this character
<jmercouris>
_death: A thrilling read I'm sure :D
<dfsadsfasdf>
simple way to check character is in string?
<beach>
dfsadsfasdf: What?
<pjb>
_death: indeed, since it's not a standard name, and even not a semi-standard one like #\tab, it is arbitary.
<jmercouris>
dfsadsfasdf: you could use regex
<dfsadsfasdf>
beach: how to check character is in string in lisp
<_death>
pjb: but CL implementation that assumes ASCII will have (code-char 4) evaluate to a Lisp character that should mean end of transmission, per the ASCII standard
<beach>
dfsadsfasdf: Do you mean, given a particular string and a particular character, determine whether that character is in the string?
<pjb>
It would be better, if you need to work with ASCII control codes, to start with (defconstant +eot+ 4), and use (if (code-char +eot+) (format character-stream "foo~C" (code-char +eot+)) (write-byte +eot+ binary-stream))
<jmercouris>
dfsadsfasdf: (find #\t "The Hyperspec contains approximately 110,000 hyperlinks." :test #'equal)
<dfsadsfasdf>
jmercouris: thanks
<pjb>
often it's more useful to use POSITION.
<_death>
pjb: only if you assume you'll work with non-ASCII based implementation
<dfsadsfasdf>
jmercouris: is there nothing simpler, eg (in "c" "cat")?
<jmercouris>
I think he is only interested in booleaness
<beach>
jmercouris: Why on earth would you use EQUAL to test for character equality?
<pjb>
Notice that (find nil #(t t nil t t)) gives the same result as (find nil #(t t t t t))
<jmercouris>
beach: I wouldn't, I just copy/pasta'd quickly from the cl cookbook
<jmercouris>
one could use whatever they like, but I think a simple example is helpful
<dfsadsfasdf>
ok
<pjb>
dfsadsfasdf: if you want simple, you write it yourself: (defun in (char-designator string-designator) (position (character char-designator) (string string-designator)))
<beach>
jmercouris: No, one should use EQL for reasons of maintenance.
<dfsadsfasdf>
pjb: thanks
<dfsadsfasdf>
I'm new to lisp, coming from python
<jmercouris>
dfsadsfasdf: Welcome!
<_death>
pjb: and if you make that assumption, you should work with binary streams anyway
<dfsadsfasdf>
ty :)
<_death>
pjb: and do the ascii conversion yourself
ikki has quit [Ping timeout: 240 seconds]
<jmercouris>
dfsadsfasdf: I'm also a python developer, so if you wish to frame some questions in python terms, I can help, kind of, I'm still quite new to lisp myself
<pjb>
dfsadsfasdf: the point of using sexps, besides the macros (which were invented 4 years after the sexps), is that they allow you to write operators and functions that merge smoothly in the flow of lisp syntax.
<pjb>
_death: well, already if you have to work with control codes, you should work on binary streams, not on character streams…
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
ikki has joined #lisp
<jmercouris>
pjb: Why?
smurfrobot has joined #lisp
<jmercouris>
is there some performance again? some edge case?
<pjb>
because control codes are binary data.
<jmercouris>
all data is binary data, where do we draw the line?
<_death>
pjb: I tend to agree, but I wouldn't see it as disasterous to use characters (i.e. (defconstant eot (code-char 4)) and work with that) if you assume an ASCII-based implementation will be used
dfsadsfasdf has quit [Quit: Page closed]
<jmercouris>
pjb: Why for example, would we not look at char arrays, and to find last character iterate byte by byte till we find the control character for the end?
<pjb>
_death: 1- (code-char 4) may return nil, even if the implementation supports an ascii external-format.
<pjb>
2- it depends on the external-format.
<jmercouris>
or whatever it is in C, I can't remember I think an empty byte or something
<pjb>
jmercouris: not in lisp.
<jmercouris>
pjb: I'll admit, I definitely do not understand
<_death>
pjb: you're saying it may return nil because you don't see it as a character.. which again points to the need to read the ASCII standard I guess
<jmercouris>
I just want to know what you mean by binary data vs character streams
FreeBirdLjj has quit [Ping timeout: 248 seconds]
<jmercouris>
as to why one would be preferable over the other
<pjb>
jmercouris: there's no binary data in lisp. There are integers, and there's the subtype bit = (member 0 1) so you could say that this is binary. But there is the notion of binary stream which is streams of bytes which are subtypes of integer.
<pjb>
And there are character streams, and a serializer/deserializer to convert between (some) lisp objects and character streams.
<pjb>
(print and read).
<pjb>
_death: it may return nil because that's what clhs says!
<jmercouris>
wouldn't a binary stream be a stream of bits, since you said that bytes don't exist?
<pjb>
Basically, if you read and memorized the clhs, those discussions would mostly disappear.
<_death>
pjb: yes, but I already qualified with the assumption of an "ascii-based implementation".. a fuzzy term that can be used to win an argument :)
<pjb>
_death: again, this is not something that's defined in the clhs.
<beach>
jmercouris: Do you do enjoy these kinds of discussions?
<jmercouris>
beach: Sometimes
<jmercouris>
I think truth and precision are important, on topics of importance
<pjb>
_death: what's defined is that there may be an external format that may use the ascii code to encode the cl standard characters.
<Bike>
maybe han unification can be involved here too somehow. just imagine the possibilities.
<jmercouris>
importance of course being an arbitrary measure, so what is important to me may not be important to you etc
<_death>
pjb: ok.. I will (re?)read the cliki page, and the ascii standard.. maybe this weekend
<pjb>
_death: so if you say something that doesn't exist such as "ascii-based implementation" I hear an "implementation that has an external format using the ascii encoding". And this doesn't imply that the internal char-code/code-char uses the ascii coding system.
<jmercouris>
Bike: lol
<_death>
pjb: right
<pjb>
jmercouris: indeed, you can use :element-type 'bit and read and write bit by bit. But it's also able to read and wites bytes of more than one bit.
<pjb>
Still call them binary streams.
FreeBirdLjj has joined #lisp
<_death>
jmercouris: do you know what a bit is?
<pjb>
Hey, again today, I hear they overestimated the cost of a railways, because they confused miles and km!
<jmercouris>
Okay, so what is the big issue here? that ascii is not being used internally, and therefore a control code may appear erroneously as a character if coerced to a char?
<pjb>
Little details…
<pjb>
Happily for them, they didn't underestimate it…
<jmercouris>
_death: yes, I am a trained computer scientist, believe it or not :D
josemanuel has joined #lisp
<_death>
jmercouris: well, every time I read Claude Shannon it blows me mind all over.. so..
<jmercouris>
_death: What is the implication of your sentence? I don't understand the complete meaning
<jmercouris>
are you saying the definition of a bit by which I operate is a simplification of something more complex?
<pjb>
jmercouris: the big issue is that of conformance (and portability). The point here is that we cannot make the assumption that (code-char 4) will return anything related to the ASCII control code 4, and that after (with-open-file (ascii-stream "foo" :element-type 'character :external-format *ascii-external-format* :direction :output :if-does-not-exist :supersede) (princ (code-char 4) ascii-stream)) there's: no guarantee that the b
<pjb>
content of the file foo will be a byte of value 4 (= EOT in ASCII).
<Bike>
if i say "1.7 bits" do you have some understanding of what that means
<jmercouris>
Bike: No, as far as I understand it, a bit can only have one state, 0 or 1
<Bike>
then yes, your understanding is a simplification, i guess.
<_death>
jmercouris: yes.. I doubt anyone can grasp what a bit is as fully as possible
<Bike>
not one you probably need to worry about, though.
<pjb>
jmercouris: in information theory, bit is the unit of information. A lisp bit may contain more or less than one bit of information.
smasta has quit [Ping timeout: 248 seconds]
<pjb>
jmercouris: for example, if we consider: 4*1000 and I tell you that I got a bit valued 0 from that bit-vector, you get 3/4 bit of information about the position of that bit, since you can exclude the position 0 for this bit 0.
fikka has joined #lisp
<Bike>
an intuitive way to think of it is, say you have a fair coin and flip it. the information about which way it landed is obviously a bit's worth. but what if the coin is weighted, so that it lands on heads more often? intuitively, there is some amount of informing going on if i tell you it landed heads, but less than a bit.
<jmercouris>
so what is the idea
<Bike>
Anyway long story short, celsius is interconvertible with joules per byte.
<pjb>
If you live in a place where the sky is blue 90% of the time, and grey 10% of the time (during the day), if you ask "Is the sky blue?" and I answer you "yes", you don't get 1 bit of information, but only 0.1 bit.
<jmercouris>
I can infer more information from a bit than the raw data?
<jmercouris>
how did I not get a full bit of information? I was interested in the state, 2 possibilities, I got one of them
smasta has joined #lisp
<jmercouris>
I can't really wrap my head around this
<pjb>
E-M E=mc² E-I E=hf M-I m=fh/c² f=mc²/h
<pjb>
Jesin has quit [Quit: Leaving]
smurfrobot has quit [Remote host closed the connection]
<pjb>
Bremermann's limit = 2e50 bit/kg/s ; in a human brain: 1e18 bit/kg/s ; there's some margin…
<pjb>
Bremermann's Limit is the maximum computational speed of a self-contained system in the material universe.
<jmercouris>
I've got a few unalloc'd spots in my head, sure :D
<pjb>
Well, it's still quite frightnening: it means that there's no physical impossibility for an artificial (or even natural) intelligence that is astronomically smarter than us.
<jmercouris>
I'm not sure why that would frighten you
<pjb>
jmercouris: yes, but since the states are not equiprobable, the 1 bit of data didn't convey 1 bit of information. You learned less, because the bit of data just confirmed what was the most probable.
<jmercouris>
are you afraid that this potentially superbeing would turn your life into pure suffering or something?
<jmercouris>
pjb: When you frame it in those terms, it makes sense
<jackdaniel>
well, we do it to animals
<jmercouris>
jackdaniel: perhaps we are not smart enough yet
fikka has quit [Ping timeout: 256 seconds]
milanj has quit [Read error: Connection reset by peer]
<jmercouris>
I think with time we are nicer to animals, in the future I predict more niceness
<pjb>
jmercouris: yes, basically it's the Vogon problem. They just decide to build a hypergalactic highway bypass over the Solar system…
<pjb>
We're nice to animals, but when you build a highway, we don't care about the ants and worms destroyed…
<jackdaniel>
historical data says otherwise
<jmercouris>
jackdaniel: Okay, so you are arguing that, in the past, humans behaved nicer to animals?
<pjb>
We cannot generalize, it's a question of civilization and different people have different levels of civilization.
<jackdaniel>
(that smarter actually makes us less emphatical and care less)
<jmercouris>
jackdaniel: I really disagree with that
<jmercouris>
by that measure, the dumbest people should be the most empathetic
<jmercouris>
and I believe I can find a correlation between stupidity and racism
<jmercouris>
and racism is a counter example to empathy
orivej has joined #lisp
fikka has joined #lisp
<pjb>
jmercouris: wrong.
<jackdaniel>
your "arguments" aren't very sound, but I've got into offtopic ;)
<jackdaniel>
sorry
<jmercouris>
ok let's go to lispcafe
<jmercouris>
I'm curious about your opinions
warweasle has joined #lisp
<jackdaniel>
maybe other time, I'm still behind the schedule with many projects
<jmercouris>
ah, that is a cop out!
<jmercouris>
at any rate, read at your own leisure and reply later, best of luck catching up with work
<jackdaniel>
I'm trying to politely say that I'm not interesting in discussing that with you
milanj has joined #lisp
Jesin has joined #lisp
<jmercouris>
jackdaniel: I'm not sure what I did to give you this opinion of myself, but, I apologize
LocaMocha has quit [Ping timeout: 240 seconds]
<pjb>
jmercouris: well, there's #lispcafe.
<jackdaniel>
you seem to assert I have some particular opinion here – I'm just saying that I'm not interesting in defending my point
<jmercouris>
jackdaniel: You are asserting an opinion, I'm not an idiot
<jmercouris>
it's okay to feel this way about me, I am just letting you know, if at any point I bothered you, I did not mean so
<jmercouris>
I only mean good and peace and happiness in this world
warweasle has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 268 seconds]
smasta has quit [Ping timeout: 256 seconds]
saic has joined #lisp
Devon has joined #lisp
saic is now known as warweasle
red-dot has joined #lisp
hexfive has quit [Read error: Connection reset by peer]
hexfive has joined #lisp
lnostdal has quit [Ping timeout: 256 seconds]
FreeBirdLjj has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
warweasle has joined #lisp
hexfive has quit [Remote host closed the connection]
hexfive has joined #lisp
hexfive has quit [Read error: Connection reset by peer]
FreeBirdLjj has quit [Ping timeout: 256 seconds]
hexfour has joined #lisp
makomo has joined #lisp
randomstrangerb has quit [Ping timeout: 256 seconds]
smurfrobot has joined #lisp
randomstrangerb has joined #lisp
fikka has joined #lisp
<shrdlu68>
1.7 bits sounds like a measure of entropy. I doubt jmercouris is simplifying anything.
* shrdlu68
is by no means a trained computer scientist.
FreeBirdLjj has joined #lisp
Ven` has joined #lisp
damke has joined #lisp
smurfrobot has quit [Remote host closed the connection]
damke_ has quit [Ping timeout: 264 seconds]
Ven` has quit [Read error: Connection reset by peer]
Ven` has joined #lisp
Devon has quit [Ping timeout: 265 seconds]
FreeBirdLjj has quit [Ping timeout: 268 seconds]
PinealGlandOptic has joined #lisp
angavrilov has quit [Remote host closed the connection]
pmc_ has joined #lisp
smurfrobot has joined #lisp
vlatkoB has quit [Remote host closed the connection]
drewc_ is now known as drewc
impulse has quit [Ping timeout: 268 seconds]
smurfrobot has quit [Remote host closed the connection]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
schoppenhauer has quit [Ping timeout: 268 seconds]
impulse has joined #lisp
FreeBirdLjj has joined #lisp
<shka>
how can i :insert-into row with postmodern containing simple-date?
natsu has joined #lisp
<shka>
doing this naive way, gives me Value #<SIMPLE-DATE:DATE 18-01-2018> can not be converted to an SQL literal. error
<shka>
there is literally nothing in the s-sql file that seems to handle this
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
wigust has quit [Ping timeout: 240 seconds]
pmc_ has quit [Quit: Leaving]
schoppenhauer has joined #lisp
<aeth>
yuck, postmodern doesn't use ISO 8601?
FreeBirdLjj has quit [Read error: Connection timed out]
isoraqathedh has quit [Quit: No Ping reply in 180 seconds.]
isoraqathedh has joined #lisp
randomstrangerb has quit [Ping timeout: 256 seconds]
Colleen has quit [Ping timeout: 256 seconds]
randomstrangerb has joined #lisp
Ven` has quit [Ping timeout: 256 seconds]
Ven` has joined #lisp
Colleen has joined #lisp
FreeBirdLjj has quit [Ping timeout: 256 seconds]
PinealGlandOptic has quit [Quit: leaving]
FreeBirdLjj has joined #lisp
xantoz has quit [Read error: Connection reset by peer]
ikki has quit [Ping timeout: 260 seconds]
xantoz has joined #lisp
knobo has quit [Ping timeout: 256 seconds]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
ineiros has quit [Remote host closed the connection]
ineiros has joined #lisp
mathi_aihtam has joined #lisp
mathi_aihtam has left #lisp [#lisp]
pagnol has joined #lisp
lnostdal has joined #lisp
wxie has joined #lisp
FreeBirdLjj has quit [Read error: Connection timed out]
JonSmith has quit [Remote host closed the connection]
norvic has joined #lisp
wxie has quit [Ping timeout: 256 seconds]
nirved has quit [Quit: Leaving]
mishoo has quit [Ping timeout: 248 seconds]
FreeBirdLjj has joined #lisp
ikki has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
eivarv has quit [Quit: Sleep]
kami has joined #lisp
ikki has quit [Ping timeout: 240 seconds]
hexfour has quit [Remote host closed the connection]
hexfour has joined #lisp
_main_ has joined #lisp
_main_ has quit [Read error: Connection reset by peer]
_main_ has joined #lisp
_main_ has quit [Read error: Connection reset by peer]
__main__ has quit [Ping timeout: 276 seconds]
murii has quit [Ping timeout: 256 seconds]
asarch has quit [Read error: Connection reset by peer]
_main_ has joined #lisp
_main_ has quit [Read error: Connection reset by peer]
asarch has joined #lisp
__main__ has joined #lisp
__main__ has quit [Read error: Connection reset by peer]
__main__ has joined #lisp
<jmercouris>
Shinmera: performing updates?
<Shinmera>
Hm?
<jmercouris>
your bot had quit and rejoined
<Shinmera>
It'll do that if it times out.
__main__ has quit [Read error: Connection reset by peer]
__main__ has joined #lisp
hexfour has quit [Read error: Connection reset by peer]
__main__ has quit [Read error: Connection reset by peer]
red-dot has joined #lisp
<jmercouris>
ah ok :P
hexfour has joined #lisp
ja-barr has joined #lisp
<Shinmera>
When I update things it's typically a series of reconnects because I never seem to be able to do anything without also breaking twenty things in the process.
<Shinmera>
Well, either that, or no restart is required at all if it goes smoothly.