<White_Flame>
an interrupt is just pause, run externally-provided lambda, resume. If you want to wake up from a timeout, you should use locks/waits/etc with timeouts
<v0|d>
sup #lisp?
loli has joined #lisp
karlosz has joined #lisp
dale has quit [Quit: dale]
colelyman has joined #lisp
vilivulpine has quit [Remote host closed the connection]
robdog has joined #lisp
verisimilitude has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 268 seconds]
Oladon has joined #lisp
noloop has left #lisp [#lisp]
<Ukari>
thx, White_Flame, now i use bt:wait-on-semaphore with :timeout
<White_Flame>
yep, sounds more appropriate
myrkraverk has quit [Ping timeout: 250 seconds]
igemnace has quit [Ping timeout: 245 seconds]
milanj has quit [Quit: This computer has gone to sleep]
durumi has joined #lisp
myrkraverk has joined #lisp
<fiddlerwoaroof>
minion: memo for emaczen: I've looked into Obj-C exceptions, but I don't think there's anything you can really do about them
<minion>
Remembered. I'll tell emaczen when he/she/it next speaks.
<fiddlerwoaroof>
minion: memor for emaczen: see the recent-ish comments in #ccl from eschatologist
<fiddlerwoaroof>
minion: memo for emaczen: see the recent-ish comments in #ccl from eschatologist
<minion>
you speak nonsense
<minion>
Remembered. I'll tell emaczen when he/she/it next speaks.
atgreen has joined #lisp
igemnace has joined #lisp
charh has quit [Ping timeout: 245 seconds]
dddddd has quit [Remote host closed the connection]
charh has joined #lisp
ikki has joined #lisp
loli has quit [Ping timeout: 255 seconds]
colelyman has quit [Ping timeout: 256 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
makomo has quit [Ping timeout: 259 seconds]
loli has joined #lisp
dale has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
Oladon has quit [Quit: Leaving.]
charh has quit [Ping timeout: 246 seconds]
robdog has joined #lisp
charh has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
_whitelogger has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
wanz has quit [Quit: wanz]
wanz has joined #lisp
robdog has joined #lisp
marvin2 has quit [Ping timeout: 244 seconds]
wusticality has quit [Ping timeout: 264 seconds]
robdog has quit [Ping timeout: 268 seconds]
robdog has joined #lisp
<Ukari>
is there a test framework which could run assert asynchronously? like (test test-foo (bt:make-thread (lambda () (is (eq 1 1)))))
<Ukari>
have a def-suite like fiveam is better
<pillton>
Why do you want this?
<Ukari>
because some of my test will run in another thread, and if the test framework support assert asyncly it will be more easy to write tests
colelyman has joined #lisp
loli has quit [Ping timeout: 250 seconds]
robdog has quit [Ping timeout: 268 seconds]
<beach>
Good morning everyone!
<pjb>
Ukari: you see now why my stance on tests is that everyone should write their own test framework, instead of trying to use an existing one?
<pjb>
Ukari: the requirements on a test framework depend strongly on the kind of system you want to test.
<Ukari>
maybe you are right
<pjb>
Ukari: you could take an existing test framework, and add the required features to be able to run them in parallel in different threads.
<pjb>
This might require locking of counters, serialized result reports, etc.
<pjb>
I would suggest com.informatimago.common-lisp.cesarum.simple-test, which is simple, and you may be able to extend easily to support threads. ;-) patches welcome.
<pillton>
Ukari: There are other ways to solve this problem which don't require a new test framework.
robdog has joined #lisp
verisimilitude has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
ebrasca has quit [Remote host closed the connection]
loli has joined #lisp
atgreen has quit [Ping timeout: 255 seconds]
ltriant has quit [Quit: leaving]
robdog has joined #lisp
rumbler31 has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 250 seconds]
wanz has quit [Quit: wanz]
libertyprime has quit [Ping timeout: 258 seconds]
robdog has joined #lisp
bkst has quit [Read error: Connection reset by peer]
bkst has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
colelyman has quit [Ping timeout: 256 seconds]
torbo has quit [Remote host closed the connection]
iovec has quit [Quit: Connection closed for inactivity]
robdog has joined #lisp
wanz has joined #lisp
jack_rabbit has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
ikki has quit [Ping timeout: 246 seconds]
robdog_ has quit [Ping timeout: 268 seconds]
loli has quit [Ping timeout: 246 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
dale has quit [Quit: dale]
loli has joined #lisp
sauvin has joined #lisp
robdog has joined #lisp
tsiolkov has quit [Quit: WeeChat 2.3]
pierpal has quit [Read error: Connection reset by peer]
robdog has quit [Ping timeout: 250 seconds]
milanj has joined #lisp
abhixec has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
jprajzne has joined #lisp
robdog has joined #lisp
rumbler31 has joined #lisp
akoana has left #lisp ["Leaving"]
rumbler31 has quit [Ping timeout: 246 seconds]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
prite has joined #lisp
robdog has joined #lisp
robdog_ has quit [Ping timeout: 268 seconds]
robdog has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
loli has quit [Ping timeout: 246 seconds]
prite has quit [Ping timeout: 258 seconds]
Krystof has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
ggole has joined #lisp
abhixec has quit [Ping timeout: 255 seconds]
angavrilov has joined #lisp
loli has joined #lisp
robdog has joined #lisp
varjag has joined #lisp
didi has joined #lisp
prite has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
<didi>
How do I break out of a recursive function without going through all the recursions? I wrote something like <https://paste.debian.net/hidden/430c13d2>. Is it too gross? I thought of using signals, but it sounded like too much. It looks like a continuation, but I have control of the scope, that is, I'm using the lexical scope.
pierpal has joined #lisp
<no-defun-allowed>
I can't get the paste to load.
<didi>
no-defun-allowed: Oh, why?
<no-defun-allowed>
Safari asks me what client certificate to use, and the server will not accept them.
robdog has joined #lisp
<didi>
:-(
<didi>
It looks fine to me, but I'm using Debian.
<no-defun-allowed>
I'll check on Firefox...
<didi>
Thank you.
<no-defun-allowed>
Well, I'd usually do a function like that, with return-from.
<didi>
Oh, cool.
<no-defun-allowed>
Though, it'd probably be too complex for a FLET, and I'd move it into a DEFUN.
varjag has quit [Ping timeout: 240 seconds]
<didi>
no-defun-allowed: Yeah, mine is growing beyond a screen page, so I think I should break it.
robdog has quit [Ping timeout: 250 seconds]
gxt has quit [Ping timeout: 268 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
<White_Flame>
didi: you should ensure it's tail recursive; that's the easiest way
<White_Flame>
beacuse then it's always just 1 hop out
<White_Flame>
else, you could use throw
<White_Flame>
but I'd highly recommend tail recursion
keep_learning_M has quit [Quit: This computer has gone to sleep]
<beach>
Hello splittist.
robdog has quit [Ping timeout: 250 seconds]
scymtym has joined #lisp
keep_learning_M has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
schweers has joined #lisp
loli has quit [Ping timeout: 240 seconds]
karlosz has quit [Quit: karlosz]
iovec has joined #lisp
marvin2 has joined #lisp
nowhere_man has quit [Ping timeout: 258 seconds]
loli has joined #lisp
makomo has joined #lisp
ioa has joined #lisp
<ioa>
good morning
<schweers>
when sbcl claims to have no more memory ... is there something I can do in that image to investigate? i.e. find out where all the memory went?
<verisimilitude>
You can have a STORAGE-CONDITION handler.
<verisimilitude>
Does ROOM provide any useful behavior in this case?
<schweers>
Good question. I’ll try next time it happens.
<schweers>
huh, so storage-condition actually is a proper condition, interesting
<beach>
Hello ioa.
heisig has joined #lisp
varjag has joined #lisp
arpunk_ has joined #lisp
moldybits has joined #lisp
arpunk has quit [Read error: Connection reset by peer]
moldybit1 has joined #lisp
random-nick has joined #lisp
moldybits has quit [Client Quit]
moldybit1 has quit [Client Quit]
<p_l>
schweers: (room t) might help a bit
<p_l>
Also details of error from SBCL (ran out of dynamic space? ETC)
<schweers>
I’ve now got it running in SLIME, I’ll see what I can do when that point comes again. I guess it won’t be for another few hours though. So thanks for your tips, espectially about ROOM. I had completetly forgotten it.
fengshaun has joined #lisp
<makomo>
morning
jb has quit [Ping timeout: 246 seconds]
jb has joined #lisp
akater has quit [Remote host closed the connection]
akater has joined #lisp
loli has quit [Ping timeout: 250 seconds]
<beach>
Hello makomo.
moldybits has joined #lisp
igemnace has quit [Quit: WeeChat 2.3]
<fengshaun>
what's a recommended book for learning common lisp?
<fengshaun>
is practical common lisp a good way to go?
<shka__>
yes
<shka__>
either that or land of lisp
<shka__>
but PCL is better i think
<fengshaun>
thanks
<makomo>
fengshaun: yeah, go with PCL as a beginner. later on check out advanced books like On Lisp, Let Over Lambda, etc.
loli has joined #lisp
<fengshaun>
nice, thanks
Zaab1t has joined #lisp
wanz has quit [Remote host closed the connection]
wanz has joined #lisp
juristi has joined #lisp
keep_learning_M has quit [Quit: This computer has gone to sleep]
keep_learning_M has joined #lisp
Zaab1t has quit [Quit: bye bye friends]
yangby has joined #lisp
yangby has quit [Client Quit]
<moldybits>
what's the canonical way to express a `do { ... } while (...)' loop in lisp?
<makomo>
(loop :do ... :while ...) :-)
<moldybits>
>_<
<moldybits>
and you're using keywords for aesthetic reasons, yes?
<makomo>
yup, purely aesthetic. you can use whatever symbol you want, as LOOP only checks the symbol's name when looking for "loop keywords"
<jackdaniel>
moldybits: (do () ((null (test))) ,@body) ; is also a way to express it
m00natic has joined #lisp
keep_learning_M has quit [Quit: This computer has gone to sleep]
<loke>
moldybits: LOOP also supports various other variations, like so (LOOP WHILE X UNTIL Y DO (something) UNTIL Z DO (something-else) WHILE ZZ)
robdog has joined #lisp
<jackdaniel>
including incomprehensible combos
<moldybits>
null confused me at first.
<jackdaniel>
moldybits: do macro's second clause is the "end" test
<jackdaniel>
so it is more like "until"
<jackdaniel>
that comes from the fact, that DO (among other things) is a syntactic sugar for a tail recursion
<jackdaniel>
(I won't elaborate on that because I need to take care of something else, but it is nicely explained in peter norvig style guides)
<pjb>
moldybits: try: (defpackage "MY-LOOPS" (:use "CL") (:export "WHILE")) (loop do (print 'hi) while nil) (use-package "MY-LOOPS")
<moldybits>
i'm actually more comfortable with recursion than do :p
robdog has quit [Ping timeout: 264 seconds]
* loke
really hates DO. It's the worst of all worlds.
<moldybits>
pjb: you mean just to see it in action? how does defininig a package for it help, though?
<loke>
Maxima uses it, so I've had to get used to it. But it's very uncomfortable.
<loke>
I should rewrite the maxima usees of DO into LOOP :-)
<pjb>
moldybits: just try it.
<moldybits>
it is a bit verbose. i think i'll use the loop version as i feel i need to fully embrace it.
robdog has joined #lisp
<moldybits>
the last expression causes a name-conflict between my-loops:while and common-lisp-user::while
<pjb>
Which is the reason why I use always keywords for loop keywords.
<moldybits>
ah, right. i recall something about this.
<loke>
why would you USE CL and EXPORT WHILE at the same time?
<loke>
It's such a bizarre reason for uglifying your loops :-)
<pjb>
Notice that some lisp have macros named WHILE, UNTIL, etc. (eg. emacs lisp) and some package may also export operators such as COLLECT, SUM, MAXIMIZE, etc. So those collisions are not academic.
<pjb>
loke: because the MY-LOOPS package will be implemented in Common Lisp.
<_death>
why would you use-package and not use :use...
<pjb>
_death: whatever.
robdog has quit [Ping timeout: 250 seconds]
<pjb>
_death: but at the REPL you may prefer use-package.
<_death>
yes
<pjb>
_death: also, ibcl.
<no-defun-allowed>
You may prefer saving your fingers.
<_death>
so the issue usually manifests itself in interactive development, if you're using a package that exports these symbols
<moldybits>
when i misspell a symbol in slime, it starts showing up as a completion, which is annoying. is the way symbol interning works (or whatever it's called) ... good/sensible?
<_death>
you can unintern it
<White_Flame>
yeah, the R part of repl should be transactional
<loke>
moldybits: You should be able to filter out symbols in the completion list that are not bound to a variable or function.
<White_Flame>
if the code didn't run successfully, it's bad that it leaves such side effects
<loke>
moldybits: However, you may still want to complete on it (it may be a CLIM presentation type, for example)
<moldybits>
loke: as in "it would've been nice" or "with slime properly set up"?
<White_Flame>
in theory, this could be done in the repl by detecting an abort, and containing what it had interned up in the meantime, undoing it after the fact
<loke>
moldybits: I mean “with the appropriate amount of hacking”
atgreen has joined #lisp
<loke>
it's probably not very hard.
<jackdaniel>
actually you'd need to trace function intern (so in practice, you'd need to hack the reader, and reader as is isn't very comprehensible)
<loke>
White_Flame: That would be very bad... What about this: (setf (gethash h 'foo) n bar (error "foo"))
<loke>
after that, the hash h would contain a key which is an uninterned symbol
<White_Flame>
true
<White_Flame>
I'm not sure how difficult it would be to isolate simpler cases
<loke>
White_Flame: Far too difficult to be worth the effort, IMHO
<White_Flame>
yep
<moldybits>
i just remember finding symbols and packages unexpectedly confusing last time i tried understanding them. would you people consider it to have been properly designed?
<jackdaniel>
improving completion though makes more sense
<White_Flame>
the biggest one to abort/undo on would be unbound variable or unknown function
<no-defun-allowed>
I think what jackdaniel suggests would be easier and more useful.
<White_Flame>
and only if that symbol was interned newly on that attempt, and only if used for hat
<jackdaniel>
that would bring inconsistency into repl, I'm not sure if it is worth it
<moldybits>
makomo: thanks, btw. i ended up using your suggestion.
<no-defun-allowed>
Say, if the user is up to `(`, SLIME should only suggest fbound symbols.
<makomo>
moldybits: you're welcome :-)
xkapastel has joined #lisp
robdog has joined #lisp
<_death>
no-defun-allowed: '(<complete> ...
<_death>
no-defun-allowed: (let ((<complete
<_death>
no-defun-allowed: etc.
<jackdaniel>
or even, what indeed makes sense if something is a function: `(complete ,@foo)
<jackdaniel>
given we define a macro in the repl
<no-defun-allowed>
Yeah.
<_death>
many of my completions come from using M-/
<White_Flame>
of course, if you botch a short name that you don't use completion for, none of that helps
<no-defun-allowed>
Then, I wonder how it'd fare with cl-arrows and other syntax-moving macros. It probably should not be enforced on the user, only just the default action, or maybe double-tab would bring up all suggestions or something clever.
loli has quit [Ping timeout: 250 seconds]
robdog has quit [Ping timeout: 268 seconds]
<jackdaniel>
or we could get super-fancy and use markov chains for autocompletion ;-)
<White_Flame>
markov chains for predicting full image mutation
<no-defun-allowed>
Better yet, write a program to step out exactly what the inputted program would do.
* no-defun-allowed
makes too many "we went full circle" jokes, sorry
rozenglass has joined #lisp
<moldybits>
hm. i combined all files into one (just 200 lines for now), with headings and ^L. i wonder if i'll feel inclined to split it up as it grows.
<vms14>
which is the book that shows more the philosophy of lisp?
<vms14>
or the "enlightenment" all people hear about lisp?
<vms14>
the book that will make you understand what really is lisp about
<p_l>
not sure if there's one such book. You'd probably have to cobble it together from multiple ones?
<pjb>
vms14: PAIP is nice, SICP too, several others.
<heisig>
vms14: Just hack something in Lisp, and I promise you will find out why so many programmers love it.
<heisig>
Practical Common Lisp is a good introduction.
<vms14>
thanks for the anwser
<p_l>
SICP teaches you computing science with definitive lisp bent. PAIP will show you a bunch of techniques that will do a lot of good (including writing an optimizing compiler!)
<vms14>
I know that it's practice matter
<vms14>
but I wanted to see if you knew a book that shows the essence, because lisp is not only a language
<p_l>
Gentle Introduction to Symbolic Computation will open to you various alternative uses of Lists (though, iirc, it didn't do much about symbol-plist, which is kinda forgotten thing in CL)
<vms14>
what I see is that lispers have different way when thinking about a program
<vms14>
and that they dissect it different, like every function is a little step that takes a previous function and is taken for another function
<vms14>
from*
<vms14>
I mean learn to think as a lisper, even if that's matter of time. Sure there are books that show this fact, more than the others
<vms14>
I guess I'll go for SICP and translate the stuff from scheme to lisp
<vms14>
I'm interested on the On lisp, the let over lambda, and the paip, also the sicp
robdog has joined #lisp
Lord_of_Life has quit [Ping timeout: 255 seconds]
wanz has quit [Quit: wanz]
Achylles has joined #lisp
atgreen has quit [Remote host closed the connection]
atgreen has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
Lord_of_Life has joined #lisp
wanz has joined #lisp
edgar-rft has joined #lisp
Lycurgus has joined #lisp
<vms14>
what things of lisp you guess are part of this "enligthenment" that changes your way of think about programming?
<schweers>
How programs are represented is one thing.
<vms14>
I guess mostly macros, but aren't all the stuff
<jackdaniel>
vms14: that program is a living thing you may modify at runtime
<schweers>
But also Common Lisp in particular gets a lot of things right which are not limited to lisp like languages. CLOS is one thing, conditions and restarts is another.
<vms14>
the "best" feature I see lispers talk about lisp is the way lisp behavior can change
<vms14>
mostly how mutable is lisp
<schweers>
Having the whole language available at all times is also something I had to get used to and cannot do without anymore.
<vms14>
and that you don't write programs, but write a new language which adapts to your needs
<vms14>
also the bottom up design
<vms14>
jackdaniel, I like what you say
<vms14>
<3
<jackdaniel>
I think you've read some of pg essays. there is some truth in them, but part of it is just a salesperson speech
Achylles has quit [Ping timeout: 258 seconds]
schjetne has quit [Ping timeout: 272 seconds]
<vms14>
jackdaniel, well when I saw some posts I was thinking "meh, it's just a fan"
<vms14>
but the "lisp fans" are talking so high about lisp in a way I've never seen before with other languages
<Demosthenex>
i'd say there's a bit of the epiphany still. i came from a procedural algol style background, and when i worked with lisp for a while and it clicked, it was quite a feeling ;]
<vms14>
so I wanted to check whether is true or not
<vms14>
and the bit I saw it tells me that they are not lying
<Demosthenex>
i had been skeptical about the epiphany claim myself, and it's not like the heavens part and light shines down, but it changes the way you think
<vms14>
Demosthenex, so you mean the functional style?
dddddd has joined #lisp
<schweers>
Lisp is not really that functional.
<jackdaniel>
well, I'm working with CL almost exclusively and I can tell with certainity that it is no silver bullet - a very good language with well-thought qualities and some flaws
<vms14>
it's multiparadigm
<Demosthenex>
vms14: no, i don't mean learning functional. i mean lisp, and programming with lisp.
<jackdaniel>
but similar things may be said about other languages too I suppose
<vms14>
also what I see is that most of modern languages are "modern" and have "modern features" that lisp had forever
<jackdaniel>
(some of the flaws I talk about are not inherent to the language itself, but to the ecosystem and such)
<vms14>
so they're just taking stuff from lisp
<Demosthenex>
frankly i've said to many friends that i wish i'd learned lisp first in highschool. i feel like it made me a better programmer in every langauge as a result of learning it.
<schweers>
Not forever. Just longer than some others.
<vms14>
and it's strange to know that an ancient language like lisp is more modern that most of languages we know
<vms14>
and that what we expect from a modern language are features lisp had
<schweers>
vms14: Don’t confuse lisp the idea with Common Lisp the language. The latter was standardized in ... 1994?
<vms14>
also I guess learning lisp is a bit like start again to learn programming, due to the fact lisp is different to most languages
<vms14>
and that most languages are very similar, sharing the same syntax, the same loops, etc
<Demosthenex>
vms14: if you spent a few weeks learning lisp with a pet project, i think you won't be disappointed.
<vms14>
Demosthenex, I like lisp, and more I learn, more I love it
<Demosthenex>
vms14: into emacs yet? it has some cool things you can do with parens
<schweers>
It will spoil you though ;)
<Demosthenex>
schweers: too right!
<vms14>
also the goal is to learn lisp in order to understand what is that "enligthenment" and to steal concepts from lisp the day I'll make a toy language
<schweers>
Demosthenex: right about what?
<vms14>
Demosthenex, I don't want to learn emacs, but it seems is the only way to program in lisp
<Demosthenex>
schweers: spoiling you ;]
<schweers>
vms14: Do it. Seriously.
<vms14>
also that if you invest time with emacs, and learn how to configure it, you'll be happy and start to think why you didn't come before
loli has quit [Ping timeout: 255 seconds]
<Demosthenex>
absolutely. emacs is the only editor
<vms14>
I like vi, and Sam, the editor from plan9
<Demosthenex>
ok, so use evil for emacs. vi keybindings.
<vms14>
but I understand that emacs can be ultra configurable
<Demosthenex>
you don't use emacs for the keys...
<vms14>
yeah, I'll do it
<schweers>
vms14: I don’t know anything about Sam, but you can use bare evil-mode in emacs or spacemacs (which is what I use)
<vms14>
I feel lost without vi keys
<Demosthenex>
getting into CL with SLIME is just so damn cool.
<schweers>
Extensible, not just configurable. Big difference.
<Demosthenex>
emacs is the programmable programmers editor ;]
<schweers>
Demosthenex: I pity those who cannot or will not use such a system.
<vms14>
schweers, Sam is like the true evolution of ed, mixing awk and sed in an editor
<Demosthenex>
schweers: i just can't stand those who get wrapped up in font effects and cute gui tweaks instead of the power of the thing in front of them. :P
<vms14>
also lisp is the programmable programming language
<vms14>
and what makes emacs be so hackish
<heisig>
vms14: There is also Portacle (https://portacle.github.io/), which is easier for getting started than standard Emacs.
<Demosthenex>
heisig: that's right! good idea.
<vms14>
nah, I guess I'll go directly for emacs
<Demosthenex>
vms14: using a prepackaged emacs isn't an issue
<Demosthenex>
its just pre-configured really. you can undo it, or change it as you will
<vms14>
hmm
robdog has joined #lisp
<heisig>
Meanwhile, I'm waiting for Second Climacs ...
<vms14>
I guess it's not in netbsd packages, you can install it from emacs?
<vms14>
like a package
<vms14>
anyway install slim was easy stuff
<schweers>
I think nowadays you have to add some slime configuration to get a repl.
<vms14>
i've used something like "slim fancy" or alike
Inline has joined #lisp
anewuser has joined #lisp
<schweers>
That should do the trick
<schweers>
Do you get a repl when you say M-x slime RET in emacs?
<vms14>
yeah
<vms14>
it was very easy to get it working
<moldybits>
vms14: for me it's that it has little tools to make incremental development easier, which makes it fun. i don't know if or care how useful it is or is not in the real world.
<vms14>
I'll resign and learn how to use emacs
robdog has quit [Ping timeout: 268 seconds]
<vms14>
I'm very hardheaded and that's my worst problem
<moldybits>
is there a function to check if a character is printable/displayable?
<schweers>
I get an error claiming that the defmethod form has an invalid qualifier and that only append and :around are valid.
loli has joined #lisp
juristi has quit [Remote host closed the connection]
atgreen has joined #lisp
<pjb>
schweers: works for me (in ccl).
<makomo>
schweers: same, works here
<makomo>
(sbcl)
<schweers>
weird
<Bike>
maybe the generidc function was previously defined?
<pjb>
schweers: no, I'm not sure how append is implemented, but if it uses append, returning a literal list may be a problem for the last argument to append, since it won't be copied.
Achylles has joined #lisp
<schweers>
Ah, restarting the image helped
<pjb>
schweers: setting the file position with file-position should be as efficient as fseek, ie. very on usual file systems. Only if your file is stored on tape, should it be slow.
<pjb>
schweers: are you using tapes?
<schweers>
pjb: no, I am worried about issuing a syscall on every jump. Not sure that would happen, though.
<pjb>
syscalls are fast. But granted, on small files, it might be faster to just load the whole file in the userspace, mutate it in RAM, and save the whole file back.
<pjb>
see com.informatimago.common-lisp.cesarum.file
<schweers>
Currently I mmap the whole thing and operate on it as foreign memory, so I have no syscalls for the actual operation.
jmercouris has joined #lisp
<schweers>
I wonder how bad the difference would be if I were to switch to normal binary I/O
Posterdati has quit [Ping timeout: 246 seconds]
<schweers>
Also: the files are large, so that is not an option
<jmercouris>
where can I find all of the directives for format?
<jmercouris>
I want to do (format nil "~{~a~^ ~}" list) but insert a newline instead of a space
<pjb>
schweers: well, page faults are not better than syscalls…
Posterdati has joined #lisp
<pjb>
jmercouris: clhs format has a link to them.
<jmercouris>
I am looking at the page and I was just going down a rabbit hole trying to find it
<pjb>
(format nil "~{~a~^~%~}" list)
<jmercouris>
would be section 22.3?
selwyn has joined #lisp
<schweers>
I’m not really sure about that. Also, not every write causes a pagefault
<schweers>
(I think)
<jmercouris>
pjb: that works, thanks
robdog has joined #lisp
<makomo>
jmercouris: SLIME has a hyperspec.el module which you can use to look up stuff from CLHS. it even has a special function just for FORMAT directives: common-lisp-hyperspec-format
<makomo>
very very useful. i also find myself always digging through the CLHS just to find that list of FORMAT's directives. quite annoying :-)
<jmercouris>
makomo: I'll see if I can load that module in my init, thanks :)
<shrdlu68>
I usually check the non-alphabetic index.
<schweers>
makomo: wow, thanks for that SLIME function!
<makomo>
enjoy! :-D
<makomo>
it's a great timesaver once you start consciously stopping yourself from using the web browser to access CLHS
robdog has quit [Ping timeout: 250 seconds]
<makomo>
so much faster most of the time
<jmercouris>
I don't use the web browser actually
<jmercouris>
I use slime-documentation-look-up and it shows me all of the things
<schweers>
what do you use instead? a web wowser? ;P
<jmercouris>
well, ultimately it does open up eww on a local copy of the hyperspec
<jmercouris>
but I'm not visiting the actual site
<makomo>
jmercouris: yeah, i use that too (thought it was part of hyperspec.el, but it seems it isn't)
<drmeister>
That is an animation of a molecular dynamics run of a protein called lysozyme.
<drmeister>
All powered by Common Lisp.
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
<drmeister>
Well, the actual rendering is with Javascript and there is some Python between the Common Lisp kernel and the browser.
<schweers>
Wow, cool!
robdog has joined #lisp
<makomo>
nice work drmeister
<splittist>
v neat
abhixec has quit [Quit: reboot]
quazimodo has quit [Remote host closed the connection]
<koenig>
That's pretty nice work, drmeister.
<koenig>
I did my PhD in the Charm++ group at UIUC and spent some time working on NAMD.
<koenig>
I sort of view that aspect of molecular dynamics as being the big scale "set up a batch job and run it on a supercomputer" side of things.
<koenig>
And view your work with Clasp and interactive molecular dynamics in a notebook as being on the smaller scale "develop an interactive shell that you can use to poke at molecular dynamics problems interactively" side of things.
<drmeister>
Well one sec for that - but it programatically generates AMBER input scripts and a makefile that will run the AMBER jobs with as much parallelism as possible. It will use your local machine, a cluster of GPU accelerated machines - or the Amazon Web Services GPU instances.
quazimodo has joined #lisp
amerlyq has joined #lisp
<koenig>
Well that's pretty cool!
<koenig>
I have to admit that I don't know how big AMBER scales. We used to run some pretty big NAMD runs and NAMD was one of the qualification applications used to certify Summit at ORNL.
<shka__>
drmeister: i love it
<koenig>
I guess the neatest thing about your work in my opinion is that you're driving toward what is essentially an interactive shell and an associated domain specific language for doing molecular dynamics.
<drmeister>
Thanks. There's more though - we are going to be running parallel AMBER jobs at a very large scale.
<drmeister>
That's a small job - one free energy perturbation calculation that calculates the ddG of benzene going to phenol in lysozyme.
<drmeister>
Thousands of these running in parallel.
shrdlu68 has quit [Ping timeout: 240 seconds]
<drmeister>
The ellipses are jobs. The rectangles are files that are generated and consumed by the jobs.
<drmeister>
It's a feed-forward network of calculations.
<drmeister>
Horizontal levels are run in parallel on GPU accelerated machines.
<drmeister>
AMBER is considered to have the fastest GPU code.
<drmeister>
What we are doing here is automating large numbers of free energy perturbation calculations.
ebrasca has joined #lisp
<drmeister>
The Common Lisp code sets up the input for a distributed build system that can be run on different target machines.
<dim>
drmeister: wow nice! are you doing the jobs orchestration in the CL layer too? if that's the case, are you using lparallel/lfarm for that?
<pfdietz>
While I don't do chemistry, I do read Derek Lowe's blog. That has to count for something, right?
<drmeister>
dim: No - we are generating makefiles and input scripts within a directory hierarchy.
angavrilov has quit [Remote host closed the connection]
<drmeister>
The jobs orchestration is developed by my partner Martin Cracauer - formerly of Google and ITA
ikki has joined #lisp
<dim>
gotcha
<drmeister>
It uses standard unix tools to distribute the jobs so that everything follows a well defined and reviewable security model.
<dim>
well if you're looking for ways to have CL “listeners” on the remote GPU servers and talk lisp to them directly for orchestration and off-loading, have a look at lfarm, I think you'll like it!
<drmeister>
Thank you. Some of the jobs in that graph I just dumped are lisp jobs running in Cando.
<drmeister>
The jobs basically run as shell scripts - launched using ssh - so that we can use ssh key management as the security model.
makomo_ has joined #lisp
<dim>
yeah lfarm also works on top of ssh
<dim>
instead of bash you have say clasp running on a port where it expects lisp commands, same model as slime/swank if I understand correctly
<drmeister>
We are building security into everything because if pharmaceutical companies are going to use this - they can review the security and feel as good about it as they can anything else.
loli has quit [Ping timeout: 255 seconds]
<dim>
so that the code you run remotely is still lisp, you basically have remote funcall over it, a quite classic RPC mechanism
makomo has quit [Ping timeout: 255 seconds]
<drmeister>
Understood. We opted for an approach where the workers can do different things like run AMBER jobs, run Cando scripts, run cpptraj (part of AMBER) run a python script (bleh - gotta rewrite that in Cando CL)
<drmeister>
run semi-empirical quantum calculations...
<dim>
yeah, sounds like the right approach to me too
<dim>
I just have a policy of never using shell scripts in production
<drmeister>
Why is that?
<dim>
I would readily replace that parts with CL based entry points
FreeBirdLjj has quit [Remote host closed the connection]
<dim>
well the most important and difficult thing to do in a production environment is error handling, reacting to things not doing what's expected
<drmeister>
Yes.
<dim>
implementing proper error handling in shell script is at best hazardous
<drmeister>
Agreed.
FreeBirdLjj has joined #lisp
<dim>
I've never seen shell script handling errors correctly
<dim>
so I would use even Python rather than shell scripts, or if I have Common Lisp and its condition system and restarts... well... that looks more like it
<drmeister>
Martin and I talked about this. Cando can launch other programs using unix calls. But this is more his domain - so we are doing things with the shell rather than using Cando as the shell.
<drmeister>
You raise a very good point.
<dim>
makes sense given the expertise you have in the team
<dim>
I would still feel suspicious about the whole shell parts
moldybits has quit [Quit: bbl]
<drmeister>
IIRC the argument was that if we use standard tools like ssh, bash, rsync for this layer that the security would be reviewable.
FreeBirdLjj has quit [Ping timeout: 255 seconds]
<drmeister>
Also, we run things in tmux - so we can connect into any machine and figure out what has been going wrong.
<drmeister>
I'm just glad I'm not the one writing the bash scripts :-)
<dim>
imagine that layer being written in CL, you would then be able to review it... and contribute to it... ;-)
ggole has quit [Quit: Leaving]
<dim>
anyway there's the Time To Market too, so v1 in bash might be the best move after all
<drmeister>
koenig: What would large scale mean to the community?
<koenig>
Admittedly, NAMD runs on Charm++ which is oriented toward the supercomputing community. But for example it was one of the acceptance codes for Summit at Oak Ridge National Laboratory where it'd run across the entire machine with ~4,096 nodes each with something like 4 or 8 GPUs per node.
<drmeister>
Within Cando I can write code with loops that can generate any number of parallel AMBER jobs with a single function call. At what point would the calculation become impressive to the computational chemistry community?
<koenig>
Like, that'd be the acceptance test.
<drmeister>
I could take the ZINC database and solvate every molecule and set up a minimization, heating, pressurization and replica-exchange molecular dynamics run.
<koenig>
The machine itself is somewhere around 200 petaflops, although I wouldn't know anymore what to expect NAMD would do on a machine like that.
loli has joined #lisp
nirved is now known as Guest24340
nirved has joined #lisp
<drmeister>
Now - that's running different molecular dynamics simulations or one large simulation? With 4,096 nodes you won't be anywhere near a linear speedup of one job - right?
<koenig>
One large simulation.
<koenig>
No, you'd expect to not get linear speedup.
<drmeister>
Good grief - ok.
<drmeister>
Ok, that's not what we are trying to do here. We need lots of different jobs.
<koenig>
Ok, Summit has 4,608 nodes and 6 Volta GPUs per node.
<koenig>
Yeah, okay, I understand your use case a little betternow.
<drmeister>
You are talking something like simulating 10,000,000 atoms of chromatin or a big chunk of membrane - right?
<koenig>
Yes.
<koenig>
If you look at Klaus Schulten's (RIP) group's work, those are the kinds of molecular systems they seemed to focus on.
<koenig>
I'm a computer scientist, however, not a molecular dynamicist.
<koenig>
Although I did spend a year in his group.
Guest24340 has quit [Ping timeout: 258 seconds]
<koenig>
But I don't know AMBER at all.
<drmeister>
Right - no - that's not what we want to do. We have lots of simulations with lots of automation to handle the messy problems of setup and analysis of those simulations.
schjetne has quit [Ping timeout: 255 seconds]
<koenig>
So Clasp's contribution is as a rich way of configuring and orchestrating your computations?
<drmeister>
Yes.
<koenig>
Do you have any publications outlining the benefits that Common Lisp brings to your work vs. using something like Python?
<koenig>
Because, having worked most of my life in supercomputing centers, I could envision that as the big pushback I'd get if I were to say I was going to use Common Lisp as my glue language.
schjetne has joined #lisp
<koenig>
And this isn't a criticism of your fine work, by the way. I'm genuinely interested in the answer.
<drmeister>
The entire molecular mechanics toolchain of loading structures, building structures, solvating structures, adding ions, assigning force-field parameters, saving topology files, generating input scripts for the MD engine, loading dynamics trajectories, analyzing dynamics trajectories - it's all under control of Common Lisp.
<koenig>
So, you have an actual domain specific language to do this toolchain?
<drmeister>
I think we are about to demonstrate the benefits of Common Lisp over the mess that Python has made in the computational chemistry community.
<koenig>
That'd be pretty compelling, IMHO.
<koenig>
At one point when I worked at ORNL, I ported ECL to the Cray (Titan) and tried to develop some domain specific languages to do work on a couple of systems-related domains, similar to what you're describing.
<koenig>
Mostly people rolled their eyes at the idea, though.
<drmeister>
We are talking to pharmaceutical companies right now. I'll be demonstrating all of this at the AMBER developers meeting.
<koenig>
That's probably a decent way to get traction for your work.
<drmeister>
We could always bring up and run cl-python inside of Cando for those that really, really want python.
<koenig>
You'd have to appeal to the business case, of course. That's all the pharma companies will care about.
<koenig>
Like, their margins are so small these days that they're trying to wrestle out as much productivity as possible.
<koenig>
If you can automate a lot of that "lift", that'd matter to them.
<drmeister>
Sure - it's all based on open source and academic software (Cando and AMBER).
<koenig>
Yep.
nowhere_man has joined #lisp
<koenig>
I'll be interested in seeing how this works for you.
<drmeister>
Right now they pay a lot of annual licensing fees for closed source, black box software.
<koenig>
I've been watching your work on Clasp for a while with great interest.
<drmeister>
Thank you.
cage_ has joined #lisp
moei has joined #lisp
Ukari has quit [Ping timeout: 268 seconds]
robdog has joined #lisp
schweers has quit [Ping timeout: 268 seconds]
robdog has quit [Ping timeout: 264 seconds]
rumbler31 has joined #lisp
robdog has joined #lisp
Ukari has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
rumbler31 has quit [Remote host closed the connection]
matijja has joined #lisp
jb__ has joined #lisp
q3d has quit [Ping timeout: 256 seconds]
anewuser has quit [Quit: anewuser]
jb has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
quazimodo has quit [Remote host closed the connection]
warweasle has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
selwyn has quit [Remote host closed the connection]
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
jb__ has quit [Read error: Connection reset by peer]
bendersteed has joined #lisp
jb has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
discardedes has joined #lisp
robdog has joined #lisp
trafaret1 has joined #lisp
<trafaret1>
hi there
<discardedes>
hello trafaret1
robdog has quit [Ping timeout: 264 seconds]
<trafaret1>
discardedes: can you in a few word explain me what means this -> : in common lisp?
<trafaret1>
:
<trafaret1>
I'm just learning lisp by reading git soruce code
<random-nick>
in a symbol, it denotes in which package to search for the symbol
<random-nick>
common-lisp:if is the symbol IF from the package COMMON-LISP
<trafaret1>
random-nick: yeah I see it when people add pacakges
makomo_ is now known as makomo
<trafaret1>
but very often it used like (def_something foo1 :bar1 foo2 :bar1)
<random-nick>
oh, without a package name it refers to the package KEYWORDS
<random-nick>
symbols from the KEYWORDS package are special because they are self-evaluating
<trafaret1>
if I get it right it's like classes with variables and methods but initialized under some name
<verisimilitude>
Using package:symbol references SYMBOL in package PACKAGE; using :symbol references SYMBOL in package KEYWORD; related but not quite the same is #:symbol, which references SYMBOL in no package.
robdog has joined #lisp
<verisimilitude>
That is, (CONS #:SYMBOL #:SYMBOL) creates a CONS with two distinct symbols in it.
<verisimilitude>
Oh, well you need to QUOTE them, too.
<trafaret1>
hm
<trafaret1>
tricky langauge
<verisimilitude>
It's simple, really.
<verisimilitude>
Care to know the primary use of these symbols without a package?
<trafaret1>
no
<verisimilitude>
Alright; my point is that it's not so tricky once you learn more. Which languages do you already know?
slyrus_ has joined #lisp
<trafaret1>
pascal
ikki has quit [Remote host closed the connection]
<trafaret1>
I picked lisp it helps to learn english
<verisimilitude>
Oh, a one-pass language; Lisp doesn't require you declare things before using them in every case, as one difference.
<trafaret1>
and alongside I learning programmign :)
<verisimilitude>
English is the language of programming; your English is decent already; what's your first language?
<trafaret1>
russian
<verisimilitude>
Would you believe that was my guess, based on your name?
<trafaret1>
who knows :)
<trafaret1>
maybe
<verisimilitude>
Well, good luck with CL.
<trafaret1>
I tryed to pick nickname stupid as fuck for fun :)
robdog has quit [Ping timeout: 268 seconds]
gxt has quit [Ping timeout: 240 seconds]
nowhere_man has quit [Ping timeout: 258 seconds]
<trafaret1>
thanks all of you for help
robdog has joined #lisp
Zaab1t has joined #lisp
robdog has quit [Ping timeout: 244 seconds]
didi has joined #lisp
vms14 has joined #lisp
discardedes has quit [Read error: Connection reset by peer]
discardedes has joined #lisp
bendersteed has quit [Remote host closed the connection]
trafaret1 has quit [Remote host closed the connection]
Zaab1t has quit [Quit: bye bye friends]
quazimodo has joined #lisp
rozenglass has quit [Ping timeout: 255 seconds]
gxt has joined #lisp
fkac has joined #lisp
orivej has joined #lisp
bendersteed has joined #lisp
rumbler31 has joined #lisp
vms14 has quit [Quit: Doing something with my shit life :D]
rumbler31 has quit [Ping timeout: 246 seconds]
sauvin has quit [Remote host closed the connection]
random-nick has quit [Read error: Connection reset by peer]
discardedes has quit [Remote host closed the connection]
discardedes has quit [Remote host closed the connection]
random-nick has joined #lisp
rumbler31 has joined #lisp
<ioa>
hi, does anyone know, whether there will be an ELS-banquet during the ELS days, or just the Programming banquet on Wednesday?
cage_ has quit [Remote host closed the connection]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
jb__ has joined #lisp
moldybits has joined #lisp
jb has quit [Ping timeout: 246 seconds]
Nilby has quit [Ping timeout: 245 seconds]
varjag has joined #lisp
<no-defun-allowed>
hopefully there'll be, else I have to socialise with non-Lisp programmers, eugh
<no-defun-allowed>
[wait! no-defun-allowed! you're not going, so you don't have to socialise with anyone!] well, you hopefully won't have to either
Jesin has quit [Quit: Leaving]
robdog has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
asarch has joined #lisp
robdog_ has joined #lisp
<moldybits>
not sure if this is the place for slime questions? say i've modified bits and pieces all across a buffer and want to re-evaluate everything, how can i do that without excepting on defconstants?
<asarch>
One stupid question: In this Emacs GNU Emacs 26.1 (build 1, x86_64-unknown-openbsd, GTK+ Version 3.22.30) M-x package-refresh-contents works perfectly. However, in this one GNU Emacs 25.2.2 (x86_64-pc-linux-gnu, GTK+ Version 3.22.21) from Xubuntu, it doesn't