<Psybur>
_death, so the order of the denominations actually doesnt matter, and I still get 292.
taiju has joined #commonlisp
akoana has left #commonlisp [Leaving]
prxq_ has quit [Ping timeout: 252 seconds]
Psybur has quit [Remote host closed the connection]
prxq has joined #commonlisp
CrashTestDummy2 has quit [Quit: Leaving]
Bike has quit [Quit: Lost terminal]
jealousmonk has quit [Quit: ERC (IRC client for Emacs 27.1)]
gaqwas has quit [Ping timeout: 265 seconds]
srhm has joined #commonlisp
gaqwas has joined #commonlisp
heisig has quit [Ping timeout: 245 seconds]
<beach>
Good morning everyone!
<beach>
Josh_2: There is an interesting way of doing what you want that I don't think anyone pointed out. You make an API package that contains only exported symbols, and no code has (in-package <that-API-package>). Instead, each your 8 different code packages either :USE the API package or (better) use package local nicknames, so that API symbols are referred to as API:symbol.
lisp123 has joined #commonlisp
<beach>
Josh_2: CLIM requires this organization in the specification, and that's where I learned it. So I copied it for SICL, but for SICL, I just (:USE #:COMMON-LISP) since the API is that of Common Lisp.
<Josh_2>
Wait so this is like an inverse?
<beach>
Yes, very strange at first, but also the best way of doing it.
<Josh_2>
Each of my api would not export but instead use a package that exports the symbols it actually uses?
<beach>
Yes, exactly.
<Josh_2>
Okay, I'll give that a shot
<Josh_2>
Thanks
<beach>
Sure.
<akater[m]>
Is there a deep reason why Common Lisp doesn't support `(setf (if test place-1 place-2) value)`?
<beach>
Probably that it would make SETF arbitrarily complicated.
karlosz has joined #commonlisp
<GreaseMonkey>
that would be quite an awful thing to implement
<GreaseMonkey>
well ok, maybe not so horrible if one were to extend setf to expand macros
<GreaseMonkey>
unless one were to do macro expansions inside of setf, you'd be stuck with having to support it as (funcall #'(setf if) new test place-1 place-2)
<beach>
I think perhaps akater[m] imagines that places are first-class objects in Common Lisp, which is a common mistake.
<Josh_2>
beach: that worked thanks :)
<beach>
Josh_2: Sure. Spread the word! This is the best way!
semz has quit [Ping timeout: 265 seconds]
<beach>
Most people seem to not think about that possibility, and most people haven't read the CLIM specification. :)
srhm has quit [Quit: Konversation terminated!]
<akater[m]>
beach: > Imagine (setf (let ..) ..)
<akater[m]>
Does having expander for if implies there has to be an expander for (setf let)?
<beach>
akater[m]: No, but I can imagine someone like you wanting that later, and then someone who wants it for every special operator.
<beach>
akater[m]: And there would be no particular reason to allow for IF and not for the others.
<beach>
In fact, that is probably how the reasoning went that did not include it in the standard.
karlosz has quit [Quit: karlosz]
waleee has quit [Ping timeout: 245 seconds]
semz has joined #commonlisp
<akater[m]>
I didn't say I want it. It's just that Elisp has it, and it's convenient.
<beach>
I see. Well the situation is very different. Elisp does not have a standard to conform to, so it can do whatever it pleases. When a standard is written, a lot of thought has to go into deciding what to include, what to exclude, and why.
<beach>
And you asked why the Common Lisp standard does not include it, so I was guessing that a lot of thought was given, and that the conclusion was that if IF were supported, then so should the other special operators.
<beach>
Also, given the usual complaints we see here about the standard, usually from newbies, I imagined a host of complaints of the type "I can do (setf (if ...) ...) but not (setf (let (..)...)), why does the standard not allow that?"
patrice has quit [Quit: Leaving]
winning-luser has joined #commonlisp
CptKirk has joined #commonlisp
<dieggsy>
Is it possible to iterate over only symbols in the current package ? I thought do-symbols did this, but I guess it iterates over inherited too ?
<mfiano>
How is the compiler supposed to know what you mean by "in"?
<mfiano>
You would have to tell it to look for internal symbols yourself
<mfiano>
See FIND-SYMBOL
lisp123 has quit [Quit: Leaving...]
karlosz has joined #commonlisp
<dieggsy>
mfiano: ...huh, I found with-package-iterator, which appears to do what I want
<mfiano>
dieggsy: do-symbols is general in that it locates accessible symbols. It doesn't care if they are internal or inherited. If you want one of those, then put a test in the body form to filter them.
<mfiano>
(when (find-symbol (symbol-name x)) (print x)) or something
<dieggsy>
Hm, I might prefer the package iterator anyway. But I appreciate your help! Now I understand better how do-symbols works
<mfiano>
Yes, the important bit is there are multiple types of "accessibility
<mfiano>
"
<mfiano>
and the implementation is free to extend that definition
<mfiano>
In your case, you wanted 2 of the 3 standard types
taiju has quit [Ping timeout: 245 seconds]
taiju has joined #commonlisp
abrantesasf has quit [Remote host closed the connection]
notzmv has quit [Ping timeout: 265 seconds]
kakuhen has joined #commonlisp
karlosz has quit [Quit: karlosz]
makomo has joined #commonlisp
karlosz has joined #commonlisp
shka has joined #commonlisp
karlosz has quit [Quit: karlosz]
CptKirk has quit [Ping timeout: 256 seconds]
amb007 has quit [Ping timeout: 245 seconds]
amb007 has joined #commonlisp
Cymew has joined #commonlisp
pve has joined #commonlisp
shka has quit [Ping timeout: 265 seconds]
hendursaga has quit [Remote host closed the connection]
hendursaga has joined #commonlisp
selwyn has joined #commonlisp
hendursaga has quit [Ping timeout: 276 seconds]
kakuhen_ has joined #commonlisp
hendursaga has joined #commonlisp
kakuhen has quit [Ping timeout: 265 seconds]
amb007 has quit [Ping timeout: 245 seconds]
amb007 has joined #commonlisp
notzmv has joined #commonlisp
kakuhen_ is now known as kakuhen
cranium has joined #commonlisp
kakuhen has quit [Remote host closed the connection]
Nilby has joined #commonlisp
Th30n has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
kpoeck has joined #commonlisp
<pve>
Hi! Does anyone know of a utility that will take an asdf system (or asd file) and produce a "loader" lisp file containing '(load "/some/lib/foo.fasl") (load "/some/other/lib/bar.fasl") ... (load /my-system/app.fasl")'?
<pve>
I.e. a file I could load without having to load a userinit file (that includes asdf and quicklisp init stuff)
<beach>
pve: I don't know of anything existing, but I programmed ASDF to "load" files into a SICL first-class global environment, and it wasn't that hard.
<pve>
beach: so getting a list of fasl files in the correct order shouldn't be that hard?
selwyn has quit [Read error: Connection reset by peer]
<jackdaniel>
pve: you will need to hack into the 'plan' object I think
<beach>
No harder than the code on that page I would think. Probably easier.
<pve>
beach: ok thanks, I'll check it out
<jackdaniel>
afair asdf constructs the plan for an operation and then executes it
<pve>
jackdaniel: aha, I'll try it out
hendursa1 has joined #commonlisp
<mfiano>
You can also take a look at POIU which extends ASDF with a new plan.
<mfiano>
plan strategy?
<mfiano>
I don't know the asdf vocabulary very well.
<pve>
I'd like to have a light-weight alternative to saving a core, which sometimes feels too heavy for a simple, tiny utility
<pve>
and this kind of loader file would suit me (and my ancient workstation) fine
<mfiano>
You might want to look into CLPM.
<pve>
mfiano: hmm that's a new one for me
<mfiano>
It is very nice. #clpm then for questions.
<pve>
alright, thanks
hendursaga has quit [Ping timeout: 276 seconds]
scymtym has quit [Ping timeout: 245 seconds]
taiju has quit [Ping timeout: 245 seconds]
Inline has joined #commonlisp
Inline has quit [Remote host closed the connection]
Inline has joined #commonlisp
<pjb>
pve: asdf can do that itself.
<pve>
pjb: do you mean the "concatenate" ops?
<pjb>
Yes. Search for the various "monolithic" ops
<pjb>
in the ASDF Manual.
<pve>
ok, I had some vague idea that those existed, but never really used them
<pjb>
compile-bundle-op will create a single fasl file for each of the systems needed
<pjb>
monolithic-compile-bundle-op will create a single fasl file for the target system and all its dependencies, so you can deliver your entire application as a single fasl.
cosimone has joined #commonlisp
elderK has quit [Quit: Connection closed for inactivity]
brettgilio7 has joined #commonlisp
brettgilio has quit [Ping timeout: 240 seconds]
brettgilio7 is now known as brettgilio
hendursa1 has quit [Ping timeout: 276 seconds]
hendursa1 has joined #commonlisp
makomo_ has joined #commonlisp
taiju has joined #commonlisp
derwolf has quit [Remote host closed the connection]
derwolf has joined #commonlisp
<pve>
Here is my first attempt, it *seems* to do what I want :)
<pve>
It gives me a loader file that successfully loads with sbcl --script (quite quickly, too)
<beach>
Congratulations!
<pve>
(I decided to try to make this for the exercise)
scymtym has joined #commonlisp
attila_lendvai has joined #commonlisp
xaotuk has joined #commonlisp
<pve>
CL doesn't specify that concatenating fasls must work, does it?
taiju has quit [Ping timeout: 245 seconds]
amb007 has quit [Ping timeout: 245 seconds]
amb007 has joined #commonlisp
frgo has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
frgo has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
perrierjouet has quit [Quit: WeeChat 3.2.1]
perrierjouet has joined #commonlisp
<pjb>
pve: no, it does not. It says nothing about that. But it's nice that it works with some implementations.
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
loskutak has joined #commonlisp
Cymew has quit [Ping timeout: 245 seconds]
igemnace has quit [Remote host closed the connection]
Cymew has joined #commonlisp
<pve>
pjb: Yeah, I kinda guessed it didn't. It is a nice feature.
<pve>
I also appreciate that SBCL makes fasls executable, which means I can compile my "loader" file and easily run it from ~/bin without a shell wrapper
Cymew has quit [Ping timeout: 252 seconds]
<phantomics>
Hi, a question. I'm working on a system where data is stored in nested plists. I want to be able to set a "current path" creating a context where assignment operations will implicitly happen inside the nested plist corresponding to that path
<phantomics>
(set-path pl :c :f) ; the path is set
<phantomics>
(path-set :i 3) ; element assigned
<phantomics>
pl → (:a 1 :b 2 :c (:d 1 :e 2 :f (:g 1 :h 2 :i 3))) ; the element is added at the end of the 'pl :c :f' path
<phantomics>
Any advise on the most expedient way to make something like this work? I've been looking at rather complicated methods of wrapping variable references in macros
<jackdaniel>
I gather that path-set accesses some dynamic context because it doesn't take the result of set-path as an argument?
<Nilby>
phantomics: I'm not sure about expedient, but I might make a dynamic var, e.g. *plist-path*, and a (with-path (pl) …) macro which sets it to the sublist, and make sure that path-set updates the *plist-path* when it has to change the first cons, but otherwise is mostly (setf (getf … Maybe that's what you've done already?
<phantomics>
That's more or less what I've done
<Nilby>
or rather (with-path (pl &rest path …). set-path could work, as long as you're okay with the scoping, nestability, etc.
<phantomics>
jackdaniel: correct that (path-set) accesses the content of the dynamic var set in (set-path)
<Nilby>
When I made such a thing, I was lazy and just used full path accessors.
<Nilby>
Of course concurrent mutators could be trouble as usual.
cranium has quit [Read error: Connection reset by peer]
cranium has joined #commonlisp
<Nilby>
I guess if you were very concerned about speed, you could have a path cache or something.
tyson2 has joined #commonlisp
<xaotuk>
phantomics: Try something like this, sorry for adding an additional parameter of path plist. https://pastebin.com/011EmyQ9
<xaotuk>
Looks like a school homework.
<beach>
xaotuk: You need to work on your indentation.
<beach>
... and your variable naming.
<xaotuk>
beach: Thank you, I'll have a deep meditation on that.
<pjb>
phantomics: instead of using a global variable, I would encapsulate that abstraction in a CLOS object.
<beach>
I suggest using the right tools rather than meditation.
<pjb>
phantomics: the problem you have without a CLOS object, is that there are no list in lisp, no a-list, no p-list. There are only cons cells.
<phantomics>
Ok, so the storage format would be a custom object instead of a generic plist?
<pjb>
phantomics: the object would just be a wrapper, you could still use a plist inside (a ptree, since it's a plist of plist).
pjb has quit [Quit: ERC (IRC client for Emacs 27.2)]
<phantomics>
Ok
pjb has joined #commonlisp
<xaotuk>
phantomics: Tell me if it worked for you.
<phantomics>
I'm writing for output from a compiler, so the Nilby approach is more or less what I'm doing, since I can wrap all variable references with a macro that applies the path if present
<phantomics>
pjb: the main problem with using an object is that I want the ptree objects I create to be easily usable outside of the context where they're created, for instance converting them to and from JSON
<phantomics>
But I have control over how any references to variables are formatted, so I can just wrap their references in a macro that implements the list logic
<jackdaniel>
s/defun/defmethod/ etc
<phantomics>
jackdaniel you can certainly do that, but it creates an extra step to remember for someone receiving output from the system
<pjb>
phantomics: (ptree wrapper) -> (:a 1 …)
sjl has quit [Ping timeout: 260 seconds]
sjl has joined #commonlisp
taiju has joined #commonlisp
<jackdaniel>
phantomics: if you want to export to json you need to call /something/ even on a plist
<jackdaniel>
so if that something recognizes your class object then you are set, do I miss something? user doesn't care
<phantomics>
The JSON converters take plists, so to convert from the object to a plist you need an extra step
<jackdaniel>
then tell users to call (phantomics-json-converter-with-extra-sauce …) instead of an operator you don't have control over
makomo_ has quit [Ping timeout: 245 seconds]
NeoCron has joined #commonlisp
tfeb has joined #commonlisp
igemnace has joined #commonlisp
<phantomics>
I could do that, but it adds a degree of inflexibility for not much gain as far as I can see. The user may want to use a variety of JSON converters, which they can but with more steps. I'll implement the system as I've been planning and if there are significant roadblocks I'll look into wrapping the plists in objects
random-nick has joined #commonlisp
<pjb>
phantomics: actually, using a clos object has the advantage, even for client code, to be able to dispatch on in client methods.
<pjb>
phantomics: if the client receives data from different libraries and it's all just cons cells, he cannot define methods dispatching on them. But if the different libraries return objects of different classes, then methods can be written.
<phantomics>
Right, I can configure it to intelligently handle certain types of interaction
<pjb>
Just provide a simple method to return the plist, and you have the best of both worlds.
<phantomics>
That's an interesting point
<pjb>
If we could subclass cons, that'd be the best…
<phantomics>
I was mulling over what kind of plists to use, because I typically use keywords as the keys but in that case importing arbitrary JSON creates an opportunity for a type of DOS attack
<phantomics>
Where the attacker sends JSON with tons of unique keys that gobble memory when they are instantiated in the keyword package
Psybur has joined #commonlisp
patrice has joined #commonlisp
makomo_ has joined #commonlisp
<tfeb>
I'd intern things like that somewhere you csn drop them...
<phantomics>
But I could create classes to wrap different types of plists which could be identified as less secure (and faster) and more secure (suitable for environments with arbitrary input)
<tfeb>
... or just make a package and then delete it (or remove all its symbols) which is as fast as using keywords but slets you nuke them
<pjb>
I would say that json data is not lisp data, so it'd require its own specific data types. You can still provide a lisp API to access the JSON DOM eg. (json-get json-dict :my-key) even if internally, the json-dict doesn't use keywords (but, eg strings) for keys. string= is there for something.
<pjb>
but a (json-dict-keys json-dict) --> (list of strings)
tfeb has quit [Quit: died]
<phantomics>
Make a specific type for JSON? Could work, could clear up some of the ambiguities in how things like nil, {} and [] are converted
<phantomics>
But that's probably a longer-range project
<phantomics>
Creating a package for JSON import would work if I'm working on the JSON data within a limited context, for instance if I import a JSON object, extract certain things from it and then I'm finished with it
<phantomics>
If I may want to keep the object around a while and its lifespan is more open-ended the package solution may not work as well
<phantomics>
The safest solution would probably be to use strings as keys: ("a" 1 "b" 2) but comparing the strings is O(n)
ec has joined #commonlisp
Bike has joined #commonlisp
xaotuk has quit [Ping timeout: 245 seconds]
makomo_ has quit [Ping timeout: 265 seconds]
Inline has quit [Ping timeout: 252 seconds]
xaotuk has joined #commonlisp
srhm has joined #commonlisp
shka has joined #commonlisp
waleee has joined #commonlisp
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
Th30n has quit [Quit: WeeChat 3.3]
makomo_ has joined #commonlisp
pve has quit [Ping timeout: 265 seconds]
jealousmonk has joined #commonlisp
pve has joined #commonlisp
Inline has joined #commonlisp
xaotuk has quit [Ping timeout: 265 seconds]
xaotuk has joined #commonlisp
cosimone has quit [Quit: ERC (IRC client for Emacs 27.1)]
Cymew has joined #commonlisp
Psybur has quit [Remote host closed the connection]
Psybur has joined #commonlisp
<pjb>
phantomics: comparing string is actually quite fast in general. Only when the strings are equal does it go to O(n). In general, they don't have the same size, so the characters are even not compared, or they mismatch early.
makomo_ has quit [Ping timeout: 252 seconds]
makomo_ has joined #commonlisp
<phantomics>
Right, the n is the number of characters to read until there is no match
<phantomics>
But comparing "string" to "string" is still O(6) vs O(1) for symbol comparison
<phantomics>
And I guess they'll mismatch at O(1) for different length strings, that's a good point
<gin>
is there a LOOP COLLECT trick that will collect only unique values? like (loop for x in '(10 20 30 10 10 20 20 30 30) unique-collect x) => (10 20 30) ?
<pjb>
gin: (loop for x in (remove-duplicates '(10 20 30 10 10 20 20 30 30)) collect x) ;-)
<gin>
pjb: thanks
<phantomics>
You don't even need to use the loop in that case correct? (remove-duplicates) alone gets what you want
<pjb>
indeed. let's assume there's some more processing.
<gin>
yes, I am getting those values from some processing, so I will use remove-duplicates on what (loop ...) returns.
xaotuk has quit [Ping timeout: 265 seconds]
taiju has quit [Ping timeout: 245 seconds]
cage has joined #commonlisp
taiju has joined #commonlisp
cranium has quit [Quit: Leaving]
makomo has quit [Ping timeout: 245 seconds]
Cymew has quit [Ping timeout: 245 seconds]
johnjay has joined #commonlisp
<johnjay>
when I download something with quicklisp is it literally download source files?
igemnace has quit [Quit: WeeChat 3.3]
<johnjay>
and then interpreting them from the ~/quicklisp folder?
jealousmonk has quit [Remote host closed the connection]
jealousmonk has joined #commonlisp
makomo has joined #commonlisp
jealousmonk has quit [Remote host closed the connection]
jealousmonk has joined #commonlisp
makomo_ has quit [Ping timeout: 265 seconds]
<etimmons>
johnjay: It is downloading source files. What happens then is up to you/your implementation, but for the most part they're compiled and then loaded.
<johnjay>
sbcl
<johnjay>
but i'm also trying to install and use CCL since I tried to install something in sbcl and it didn't work
<johnjay>
and the github page suggested CCL as an alternative
<johnjay>
it was using something called ros as well, i didn't get how ros is different from quicklisp
euandreh has quit [Ping timeout: 245 seconds]
euandreh has joined #commonlisp
dec0d3r has quit [Remote host closed the connection]
makomo_ has joined #commonlisp
jealousm` has joined #commonlisp
jealousmonk has quit [Read error: Connection reset by peer]
jealousm` is now known as jealousmonk
karlosz has joined #commonlisp
pok has quit [Ping timeout: 252 seconds]
pok has joined #commonlisp
pok has quit [Changing host]
pok has joined #commonlisp
pok has quit [Ping timeout: 245 seconds]
pok has joined #commonlisp
pok has quit [Changing host]
pok has joined #commonlisp
karlosz has quit [Quit: karlosz]
NeoCron has quit [Remote host closed the connection]
frgo has quit [Read error: Connection reset by peer]
dbotton has quit [Read error: Connection reset by peer]
frgo has joined #commonlisp
dbotton has joined #commonlisp
utis_ has quit [Ping timeout: 252 seconds]
NeoCron has joined #commonlisp
d4ryus has quit [Ping timeout: 268 seconds]
hisacro has quit [Ping timeout: 264 seconds]
gabc has quit [Ping timeout: 246 seconds]
anddam has quit [Ping timeout: 250 seconds]
CodeBitCookie[m] has quit [Ping timeout: 260 seconds]
Mrtn[m] has quit [Ping timeout: 260 seconds]
bhyde[m] has quit [Ping timeout: 260 seconds]
etimmons has quit [Ping timeout: 260 seconds]
hayley has quit [Ping timeout: 260 seconds]
Bi[m] has quit [Ping timeout: 260 seconds]
Inline has quit [Ping timeout: 245 seconds]
Nilby has quit [Ping timeout: 245 seconds]
d4ryus has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
hisacro has joined #commonlisp
gabc has joined #commonlisp
CodeBitCookie[m] has joined #commonlisp
hayley has joined #commonlisp
utis has joined #commonlisp
kakuhen has joined #commonlisp
lottaquestions has quit [Ping timeout: 245 seconds]
etimmons has joined #commonlisp
Mrtn[m] has joined #commonlisp
bhyde[m] has joined #commonlisp
ec has quit [Ping timeout: 276 seconds]
amb007 has quit [Ping timeout: 265 seconds]
mortemeur has joined #commonlisp
Bi[m] has joined #commonlisp
amb007 has joined #commonlisp
<jmercouris>
johnjay: ROS installs versions of Lisp
<jmercouris>
johnjay: so, you might install CCL, SBCL, CLASP, etc with ROS
<jmercouris>
johnjay: and then you would use Quicklisp to install Alexandria, Serapeum, etc
<pjb>
cesarum
tyson2 has joined #commonlisp
jasom has quit [Quit: WeeChat 2.9]
selwyn has joined #commonlisp
lottaquestions has joined #commonlisp
xaotuk has joined #commonlisp
<johnjay>
jmercouris: i tried to install ccl with it but it gave an error about QL not being present so i gave up
<johnjay>
i was able to download and bootstrap and compile CCL from source i think. not sure what to do next
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
makomo_ has quit [Ping timeout: 245 seconds]
Skyfire has quit [Quit: WeeChat 3.3]
winning-luser has quit [Quit: Leaving]
ec has joined #commonlisp
bwestbro has quit [Remote host closed the connection]
Skyfire has joined #commonlisp
Inline has joined #commonlisp
lottaquestions has quit [Ping timeout: 252 seconds]
<pjb>
johnjay: ccl doesn't need quicklisp to be installed! 1- install ccl, 2- install ql, 3- have fun.
<johnjay>
i know but that's what ros said
<johnjay>
i don't know how to use ros
<johnjay>
next i need to figure out how to get quicklisp into CCL
jealousmonk has quit [Remote host closed the connection]
<johnjay>
apparently doing that (rebuild-ccl :full t) updated the lx86cl64 file to 1.12.1
jealousmonk has joined #commonlisp
srhm has quit [Read error: Connection reset by peer]
ec has quit [Ping timeout: 276 seconds]
srhm has joined #commonlisp
kakuhen has quit [Quit: Leaving...]
lottaquestions has joined #commonlisp
kpoeck has quit [Quit: Client closed]
ec has joined #commonlisp
anddam has joined #commonlisp
cosimone has joined #commonlisp
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
scymtym has quit [Ping timeout: 265 seconds]
ec has quit [Ping timeout: 276 seconds]
zazzerino has joined #commonlisp
<saltrocklamp[m]>
i'm watching the atlanta funcprog study group talk on screamer - this is wild stuff
<saltrocklamp[m]>
i'm only about 30 minutes into the video so far, but i'm curious if anyone here has used this in a practical project & what they used it for
<saltrocklamp[m]>
it looks like it could be useful for certain kinds of simulation projects
ec has joined #commonlisp
johnjay has quit [Ping timeout: 245 seconds]
Inline has quit [Ping timeout: 260 seconds]
johnjay has joined #commonlisp
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #commonlisp
lisp123 has joined #commonlisp
<patrice>
saltrocklamp[m]: you have link for the video?
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
ec has quit [Ping timeout: 276 seconds]
ec has joined #commonlisp
cage has quit [Quit: rcirc on GNU Emacs 27.1]
pve has quit [Quit: leaving]
tyson2 has joined #commonlisp
<Arcsech>
<patrice> "salt rock lamp: that talk..." <- If you like this talk, check out his new book, "Software Design for Flexibility". I'm not very far in yet, but this talk seems to stem from many of the ideas discussed in the book.
ec has quit [Ping timeout: 276 seconds]
kevingal has joined #commonlisp
ec has joined #commonlisp
<patrice>
Arcsech: yes, I have it, started reading it a couple of weeks ago (after watching the video I linked), screamer seems to be embodiment of the ideas in the book.
<patrice>
or is it the other way around, based on the dates...
shka has quit [Ping timeout: 245 seconds]
<greyrat>
`(time (load quicklisp-init))` takes from 0.6 seconds to 1.2 for me. Is this normal? I don't think it used to get this much time.
<greyrat>
(Does it change depending on what packages are installed?!)
zazzerino has quit [Remote host closed the connection]
<Arcsech>
Looks like Screamer had its roots at MIT, so I wouldn't be surprised if there was direct cross-pollenation between screamer and GJS
lisp123 has joined #commonlisp
<saltrocklamp[m]>
<Arcsech> "If you like this talk, check out..." <- i willl, thank you!
<patrice>
yes indeed. I'm curious to read the book further now, see if they use CPS in GJS at all.
<patrice>
but just like SICP it's very dense book
iamFIREc1 has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 245 seconds]
iamFIREcracker has quit [Ping timeout: 265 seconds]
travv0 has quit [Ping timeout: 250 seconds]
dbotton has quit [Ping timeout: 245 seconds]
splittist has quit [Ping timeout: 252 seconds]
jsatk has quit [Ping timeout: 250 seconds]
<lisp123>
patrice: Which book is GJS?
Lord_of_Life has joined #commonlisp
drmeister has quit [Ping timeout: 246 seconds]
gendl has quit [Ping timeout: 268 seconds]
stylewarning has quit [Ping timeout: 250 seconds]
sgithens has quit [Ping timeout: 250 seconds]
elderK has quit [Ping timeout: 245 seconds]
IUSR has quit [Ping timeout: 268 seconds]
iisi has quit [Ping timeout: 268 seconds]
conjunctive has quit [Ping timeout: 260 seconds]
victor has quit [Ping timeout: 240 seconds]
griffinmb has quit [Ping timeout: 250 seconds]
jcowan has quit [Ping timeout: 250 seconds]
jhi has quit [Ping timeout: 250 seconds]
hubvu has quit [Ping timeout: 260 seconds]
alanz has quit [Ping timeout: 268 seconds]
ullbeking has quit [Ping timeout: 250 seconds]
pl has quit [Ping timeout: 252 seconds]
amb007 has quit [Ping timeout: 245 seconds]
jmercouris has quit [Ping timeout: 268 seconds]
jhi has joined #commonlisp
d_run has quit [Ping timeout: 260 seconds]
gendl has joined #commonlisp
amb007 has joined #commonlisp
<patrice>
lisp123: Gerald Jay Sussman - Software Design for Flexibility
hubvu has joined #commonlisp
<lisp123>
patrice: Cheers
d_run has joined #commonlisp
iisi has joined #commonlisp
jmercouris has joined #commonlisp
griffinmb has joined #commonlisp
IUSR has joined #commonlisp
pl has joined #commonlisp
conjunctive has joined #commonlisp
<pjb>
"Software Design for Flexibility -- How to avoid Programming Yourself in a Corner" is co-authored by Chris Hanson & Gerarld Jay Sussman.
<pjb>
SDF-HTAPYINAC
alanz has joined #commonlisp
jsatk has joined #commonlisp
victor has joined #commonlisp
<pjb>
SDF-HTAPYIAC
elderK has joined #commonlisp
lisp123 has quit [Ping timeout: 260 seconds]
patrice has quit [Changing host]
patrice has joined #commonlisp
patrice has quit [Quit: Leaving]
patrice has joined #commonlisp
scymtym has joined #commonlisp
jcowan has joined #commonlisp
ullbeking has joined #commonlisp
dbotton has joined #commonlisp
travv0 has joined #commonlisp
splittist has joined #commonlisp
drmeister has joined #commonlisp
stylewarning has joined #commonlisp
sgithens has joined #commonlisp
patrice has quit [Quit: Leaving]
dra has joined #commonlisp
selwyn has quit [Read error: Connection reset by peer]
<_death>
here's how perl programmers avoid corners: on one side of a string, they tie themselves; on the other, a stick or a tree.. then they start walking
hayley has joined #commonlisp
hayley has quit [Changing host]
<greyrat>
_death: Coincidentally, today I wrote my first non-one-liner perl script. It was pretty great! Rather arcane and some rough edges, but I did what I wanted surprisingly easily.
<greyrat>
How do I dump a lisp image using `sb-ext:save-lisp-and-die` with all my dependencies loaded, and then load scripts using this image as a base?
<pjb>
By dumping a lisp image using `sb-ext:save-lisp-and-die` with all my dependencies loaded, and then load scripts using this image as a base.
akoana has joined #commonlisp
<greyrat>
pjb: I can dump, but I have no idea how to load a script file `a.lisp` using this image.
cosimone has quit [Quit: ERC (IRC client for Emacs 27.1)]
beach` has joined #commonlisp
<_death>
I have a shell script (say called 'mysbcl') that passes --core and a final "$@" to sbcl, and then in a script I can have #!/path/to/mysbcl --script
<_death>
check the manpage for more info.. night
beach has quit [Ping timeout: 260 seconds]
tyson2 has quit [Remote host closed the connection]
patrice has joined #commonlisp
gaqwas has quit [Ping timeout: 245 seconds]
selwyn has joined #commonlisp
patrice has quit [Client Quit]
patrice has joined #commonlisp
dec0d3r has joined #commonlisp
tyson2 has joined #commonlisp
Inline has joined #commonlisp
<greyrat>
Thanks, I'll check it out.
frgo has quit [Remote host closed the connection]
frgo has joined #commonlisp
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
<pjb>
greyrat: dump an executable image. Then use that executable as interpret of your script.
<greyrat>
Dump it without specifying a `:toplevel`?