<White_Flame>
aeth: I think that you could (destructuring-bind (...whatever... &rest rest) data (setf next-iteration rest)), then the iteration could use the 'next-iteration' variable to dynamically hop through the list. i think
xkapastel has quit [Quit: Connection closed for inactivity]
<aeth>
White_Flame: You absolutely can use destructuring-bind in a loop to setf variables each iteration. I prefer this to LOOP's built-in destructuring because they're semantically slightly different, and destructuring-bind sides more on the side of having an error when the data doesn't match the expected pattern, instead of implicitly trying to get things to work
<aeth>
It does make things look a lot uglier, though
<aeth>
You similarly have to work around LOOP's limitations when you need to do a MULTIPLE-VALUE-BIND because otherwise you have to cons a MULTIPLE-VALUE-LIST and then destructure it right away.
Oladon_work has quit [Ping timeout: 260 seconds]
<aeth>
Both are limitations that I hope to fix with DO-LOOP when I have the time to write that macro.
lnostdal has quit [Ping timeout: 258 seconds]
alexanderbarbosa has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
mrcom has quit [Read error: Connection reset by peer]
lnostdal has joined #lisp
X-Scale` has joined #lisp
mrcom has joined #lisp
X-Scale has quit [Ping timeout: 248 seconds]
X-Scale` is now known as X-Scale
mrcom has quit [Read error: Connection reset by peer]
mrcom_ has joined #lisp
Oladon has quit [Quit: Leaving.]
Marlin1113 has left #lisp [#lisp]
Bike has quit [Read error: No route to host]
milanj has quit [Quit: This computer has gone to sleep]
Bike has joined #lisp
pfdietz has quit [Remote host closed the connection]
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 268 seconds]
X-Scale` is now known as X-Scale
fragamus has joined #lisp
<fragamus>
Hi I’m writing a lisp and I wanted to ask if there is a consensus on the use of brackets and braces as in Clojure
<fragamus>
Should I omit them and just stick with parentheses for all data structures?
<no-defun-allowed>
Clojure is not a lisp, so best not let it influence your design decisions.
<fragamus>
Do they get in the way when meta programming?
<fragamus>
Ok that’s interesting
<no-defun-allowed>
I do like [] in Scheme though in some places, like (let ([x 2]) x) where they are there to make sure you know you're working with special forms, so you know X isn't getting funcalled or something.
<no-defun-allowed>
And yeah, I'd guess they would, but in Scheme, {}, [] and () are equivalent.
<fragamus>
Yeah I was thinking that making them equivalent would reduce the nastiness of having to step over them in meta programming
<no-defun-allowed>
wrt "Clojure is not a lisp", see http://www.loper-os.org/?p=42, and from there we should stick to discussing design issues that are in Common Lisp.
<fragamus>
Sorry didn’t mean to stir up the jihad
<no-defun-allowed>
Well, we can't stop you from inventing another pseudo-Clojure, but it's not something I would reccomend.
<fragamus>
No I simply want to make good design decisions
<White_Flame>
similarly, I like prolog's distinction between "compounds" and "lists", where there's a special place for a head. With sexprs, you never quite know if a list is intended as code or not, or more generally if the 1st term is special or not
akoana has joined #lisp
fragamus has joined #lisp
<fragamus>
Holy mackerel
<fragamus>
Do we mind strong static type systems like hindley-milner
<fragamus>
With type inference
<fragamus>
And type variables
<fragamus>
Is that in any way antithetical to lisp
<White_Flame>
there have been custom lisps that are strong/statically typed
<White_Flame>
but in general, type inference brings a ton of the performance without demanding every single type be specified
<Bike>
hindley milner is also type inference.
<White_Flame>
it's way better that it remains optional, because that allows you to change your program first, without having to deal with all the optimization at that stage
<White_Flame>
and then lock in optimizations as performance indicates, after the design has settled
<White_Flame>
which of course, then makes the program more difficult to change
<White_Flame>
(I define "change" generally as making it more flexible to handle things it didn't before, which would interfere with static overly specific types)
<fragamus>
If you let the type inference work for you, it feels a bit dynamically typed
<White_Flame>
right, but when it can't infer something, does it refuse to compile, or does it just handle type decisions at runtime?
<Bike>
in HM it can always refer something. the type system is correspondingly restricted.
<White_Flame>
being able to run with the latter is way better for development productivity
<fragamus>
It has to do it at compile time but in lisp that’s any time we say
<Bike>
always infer something*
<fragamus>
It can be undefined until someone calls it
<White_Flame>
well, there would be no new static type information at call time either
torbo has quit [Remote host closed the connection]
ltriant has joined #lisp
shka_ has joined #lisp
akoana has left #lisp ["Leaving"]
ltriant has quit [Ping timeout: 245 seconds]
lavaflow_ is now known as lavaflow
anewuser has joined #lisp
anewuser has quit [Read error: Connection reset by peer]
Colleen has quit [Ping timeout: 246 seconds]
Necktwi has quit [Ping timeout: 245 seconds]
varjag has quit [Ping timeout: 272 seconds]
Jeanne-Kamikaze has quit [Quit: Leaving]
Colleen has joined #lisp
sauvin has joined #lisp
shka_ has quit [Ping timeout: 245 seconds]
ltriant has joined #lisp
ltriant has quit [Ping timeout: 246 seconds]
SaganMan has joined #lisp
jprajzne has joined #lisp
benderst` has joined #lisp
bendersteed has quit [Ping timeout: 246 seconds]
frgo has joined #lisp
flamebeard has joined #lisp
JohnMS_WORK has joined #lisp
ltriant has joined #lisp
vlatkoB has joined #lisp
benderst` has quit [Read error: Connection reset by peer]
benderst` has joined #lisp
faheem has quit [Remote host closed the connection]
Guest35617 has joined #lisp
gravicappa has quit [Ping timeout: 245 seconds]
Necktwi has joined #lisp
steiner has joined #lisp
sauvin has quit [Ping timeout: 248 seconds]
benderst` has quit [Ping timeout: 244 seconds]
xantoz has joined #lisp
iskander has quit [Ping timeout: 276 seconds]
steiner has quit [Remote host closed the connection]
sauvin has joined #lisp
schweers has joined #lisp
ltriant has quit [Ping timeout: 268 seconds]
dpl has joined #lisp
iskander has joined #lisp
slyrus1 has joined #lisp
slyrus2 has quit [Ping timeout: 268 seconds]
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
Lord_of_Life has quit [Ping timeout: 268 seconds]
Lord_of_Life has joined #lisp
slyrus has joined #lisp
isoraqathedh has quit [Quit: Verhatenad!]
oni-on-ion has quit [Ping timeout: 264 seconds]
jprajzne has quit [Quit: jprajzne]
isoraqathedh has joined #lisp
jprajzne has joined #lisp
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
xkapastel has joined #lisp
umgeher3 has joined #lisp
umgeher2 has quit [Ping timeout: 248 seconds]
hhdave has joined #lisp
dddddd has joined #lisp
stepnem_ is now known as stepnem
umgeher4 has joined #lisp
umgeher3 has quit [Ping timeout: 246 seconds]
DGASAU has quit [Remote host closed the connection]
DGASAU has joined #lisp
mulk has joined #lisp
SaganMan has quit [Ping timeout: 245 seconds]
manualcrank has quit [Quit: WeeChat 1.9.1]
themsay has quit [Ping timeout: 248 seconds]
themsay has joined #lisp
cosimone has joined #lisp
trinityhex has joined #lisp
Necktwi has quit [Quit: leaving]
kbtr has quit [Quit: leaving]
kbtr has joined #lisp
amerlyq has joined #lisp
kbtr has quit [Remote host closed the connection]
Necktwi has joined #lisp
Necktwi has quit [Client Quit]
Necktwi has joined #lisp
wigust- has joined #lisp
kbtr has joined #lisp
wigust has quit [Ping timeout: 244 seconds]
themsay has quit [Ping timeout: 245 seconds]
karayan has quit [Ping timeout: 250 seconds]
<no-defun-allowed>
How can I print a number with commas every three digits (using ~$ or ~f)?
themsay has joined #lisp
gravicappa has joined #lisp
themsay has quit [Read error: Connection reset by peer]
themsay has joined #lisp
<ck_>
don't you want ~r? hold on
dplan has joined #lisp
<no-defun-allowed>
Something like 123,456.00
<beach>
Careful with that kind of stuff. The conventions are different in different places.
<ck_>
I don't think the float directives do that
SaganMan has joined #lisp
<ck_>
separate the integer part and use ~:d, if you must use floats
<beach>
no-defun-allowed: Is this for the accounting software?
<no-defun-allowed>
beach: I heard in parts of Europe, it's 123.456,00?
<beach>
It could be.
<no-defun-allowed>
Yeah, I'm writing a report generator now.
<beach>
I am used to thin space between groups of 3 digits and comma for decimals.
<beach>
If so, never ever use floats for monetary calculations.
dplan has quit [Quit: Leaving]
<jprajzne>
it's 123456,00 here
* no-defun-allowed
quickly adjusts her code
<beach>
no-defun-allowed: You can use floats for the report I guess, since no calculations are performed that will change the result.
zotan has quit [Ping timeout: 252 seconds]
<beach>
But not for the accounting code itself.
<ck_>
.. but if you don't need fractional cents, do integer arithmetic instead
<jprajzne>
maybe check the locale first and then obtain the correct format for the operating system?
<jprajzne>
for/from
<no-defun-allowed>
Well, I haven't declared any number types more specific than REAL, so I'm just adjusting to represent everything in cents.
zotan has joined #lisp
<beach>
jprajzne: I am not so sure I would trust the operating system. Mine say "jeudi juillet 18" for today's date for instance.
<beach>
... which is no doubt a translation of Thursday July 18, except that in France, the date comes before the name of the month.
<ck_>
no-defun-allowed: mm that's pretty daring of you. For our consultancy, please authorize payment of 3+4i AUS
<ck_>
yeah come on the french system is no standard :)
<ck_>
of that, I am four-times-twenty-plus-ten-plus-nine percent sure
<beach>
Bah, that's nothing compared to the Danish system.
<no-defun-allowed>
ck_: I said REAL. Please don't make me think of an imaginative pun.
<no-defun-allowed>
s/make/make me have to/
<beach>
ck_: Then you would be five and half five sure.
<lieven>
beach: could be worse. It could have said 30 Messidor de l'an 227 :)
<ck_>
Or "Thursday July 18th, 2019 = Prickle-Prickle Confusion 53rd, YOLD 3185"
<beach>
"five and half five" stands for 5 + 4.5 * 20.
<ck_>
But i said 99% not 95%. I get your point though
<beach>
Oh, sorry.
<beach>
Then "nine plus half five"
<jprajzne>
beach: do you have it set correctly? :)
<ck_>
is that a direct (word-for-word) translation? I don't know any danish unfortunately
<beach>
jprajzne: Well, it displays it in French, but with English order.
<ck_>
nine plus half five sounds like someone is reading a clock and taking timezone differences into account
<beach>
jprajzne: I don't know what locale would do that.
xkapastel has quit [Quit: Connection closed for inactivity]
<jprajzne>
if you have set French locale but English formatting, it'd do that
<beach>
I guess I don't know about formatting being different from locale.
<beach>
And I don't know why anyone would want to do that.
<ck_>
"because they can"
<jprajzne>
i have language En(US) and formats US(En)
<ck_>
Welcome to the wonderful world of locales. What would Sir like? LC_COLLATE? _CTYPE? _MESSAGES? _MONETARY? _NUMERIC?
<jprajzne>
language is one thing, formats another
<beach>
By the way, if you type "99 in Danish" to the Google search engine, you can see how it is spelled too.
<jprajzne>
ck_: spot on :)
<beach>
I think I'll just leave it as it is.
<beach>
... and work on Acclimation instead so that CLOSOS gets it right.
<jprajzne>
beach: if you have french-french but it displays french-english it's a bug
<beach>
I believe you. I tried to set everything to US English using the GUI tools. But it doesn't take it into account.
<jprajzne>
what's the os?
<beach>
Ubuntu GNU/Linux.
<beach>
And GitHub still puts Sunday first in the week. :(
<beach>
Very disturbing.
<jprajzne>
then you're lucky in a way that you can report it and t may even get fixed :)
<beach>
I might try that some day. Thanks.
<beach>
What I really want is "Thursday 2019-07-18".
CloseToZero has quit [Ping timeout: 248 seconds]
<ck_>
oh the week-starts-on-sunday crap is so aggravating to me as well
<no-defun-allowed>
Oh, speaking of clomptroller, I have to present a prototype tomorrow, so I'm currently finishing off implementing my UI design.
<jprajzne>
sunday being the 1st day of the week is US format
<jprajzne>
thus if you have set something else than US format and this happens, it's a bug again
CloseToZero has joined #lisp
random-nick has joined #lisp
spoeplau has joined #lisp
<jprajzne>
lunch question
orivej has quit [Ping timeout: 268 seconds]
<jprajzne>
technically, there's been so much crap written that we should not be writing code anymore
<jprajzne>
so why are we doing so? :)
<ck_>
There's the quote about the star developer who said he should be measured by the lines of code he could remove, not the ones he added
<no-defun-allowed>
Has anyone had any experience with cl-typesetting? I want to change the font to Computer Modern (I have the CMU family) but I'm not sure how PDF font names work.
<ck_>
no-defun-allowed: I have used cl-pdf but that was a long while ago
<no-defun-allowed>
jprajzne: "In the old days, you would chastise people for reinventing the wheel. Now we beg, 'Oh, please, please reinvent the wheel.'" Though, this might be #lispcafe material.
cosimone has quit [Quit: WeeChat 2.4]
<no-defun-allowed>
Oh, the names correspond to AFM files bundled with cl-pdf for some Adobe fonts.
<moldybits>
can (declare (ignore x)) help a compiler optimize code? or more specifically, does it ever happen in practice?
ltriant has joined #lisp
<jackdaniel>
it will help you to notice, that you've started using something you've declared as ignored
<jackdaniel>
(i.e compiler will issue a warning)
ltriant has quit [Ping timeout: 246 seconds]
orivej has joined #lisp
m00natic has joined #lisp
v88m has quit [Ping timeout: 268 seconds]
v88m has joined #lisp
<beach>
no-defun-allowed: I wish you good luck with your presentation.
Ricchi has quit [Remote host closed the connection]
trinityhex has quit [Ping timeout: 276 seconds]
bendersteed has joined #lisp
SaganMan has quit [Quit: WeeChat 1.6]
<no-defun-allowed>
beach: Thanks!
EvW has joined #lisp
igemnace has quit [Read error: Connection reset by peer]
igemnace has joined #lisp
amerlyq has quit [Quit: amerlyq]
martylake has joined #lisp
<ebzzry>
Using ASDF, is there a way to determine the name of the system that is currently being loaded?
ggole has joined #lisp
EvW has quit [Ping timeout: 250 seconds]
orivej has quit [Ping timeout: 272 seconds]
lucasb has joined #lisp
orivej has joined #lisp
EvW has joined #lisp
j0nd0e has joined #lisp
v88m has quit [Remote host closed the connection]
ggole has quit [Ping timeout: 250 seconds]
orivej has quit [Ping timeout: 268 seconds]
EvW has quit [Remote host closed the connection]
<jprajzne>
no-defun-allowed: we should be just reusing sw, not writing anything
<White_Flame>
I think you want #javascript
<beach>
jprajzne: Not necessarily. If the existing software is written in an unsafe language, or in a language that makes the software difficult to maintain, or in a language that is not supported by some operating system we are thinking of, then writing a better version is justified.
j0nd0e has quit [Ping timeout: 248 seconds]
<jackdaniel>
English term "reinventing the wheel" is terrible at what it tries to illustrate, because wheel was reinvented many times for many reasons (i.e we do not drive on wooden wheels)
<jackdaniel>
in Polish it is called "to break down opened door"
<jprajzne>
beach: yes, in reality. but aside from that, if it was good to run in production, we should be able to reuse it
<jackdaniel>
I'm sure wooden wheels were good in production for pretty long time
<jprajzne>
but i rarely see people taking implementation x and reusing it with much of writing new code somewhere else?
<beach>
jprajzne: There is a lot of crappy software in production.
<jprajzne>
beach: agreed
<jprajzne>
but somehow, 'we' managed
etwert has joined #lisp
<beach>
jprajzne: Good for you. Congratulations!
<jprajzne>
:))
<beach>
jackdaniel: Apparently, "kicking at open doors" is an idiom in English.
<beach>
Or "kicking at an open door"
<jackdaniel>
oh, thank you, I didn't know that. next time I'll bring that up against the "wheels" instead of Polish idiom
<beach>
Sounds good to me.
milanj has quit [Quit: This computer has gone to sleep]
pfdietz has quit [Remote host closed the connection]
<ck_>
do you know, as in do you collect stats for, how often these are requested through quicklisp?
<Xach>
ck_: i do collect stats and occasionally publish them
oni-on-ion has joined #lisp
<ck_>
do the broken legacy ones appear in any significant way? If some authors are no longer contactable, maybe someone else would take over and do the p-port
<ck_>
what.. github/e40 is @franzinc? with the rorschach avatar
<Xach>
It's one of the franz folks, kevin layer maybe?
<Xach>
It's somewhere in my brain but I can't pull it at the moment.
<ck_>
I have forgotten all the names of their people I had contact with, so I can't help
<ck_>
anyway has this happened before in quicklisps lifetime? Are there -legacy repositories where the maintainership has changed?
smazga has quit [Ping timeout: 272 seconds]
random-nick has quit [Ping timeout: 246 seconds]
<Xach>
ck_: yes, many times.
<Xach>
ck_: if people care a little bit, projects get moved to sharplispers
heisig has joined #lisp
anaphoric has quit [Quit: anaphoric]
anaphoric has joined #lisp
bytesighs has quit [Ping timeout: 257 seconds]
gendl has quit [Ping timeout: 257 seconds]
bytesighs has joined #lisp
gendl has joined #lisp
fowlduck has quit [Ping timeout: 258 seconds]
tfb has quit [Ping timeout: 258 seconds]
rvirding has quit [Ping timeout: 258 seconds]
tfb has joined #lisp
p_l has quit [Ping timeout: 258 seconds]
boeg has quit [Ping timeout: 257 seconds]
fowlduck has joined #lisp
rvirding has joined #lisp
boeg has joined #lisp
p_l has joined #lisp
cosimone has quit [Quit: WeeChat 2.4]
femi has quit [Ping timeout: 272 seconds]
cosimone has joined #lisp
Bike has quit [Remote host closed the connection]
anaphoric has quit [Quit: anaphoric]
<ck_>
ah, that's what that group is for, great
smazga has joined #lisp
random-nick has joined #lisp
Bike has joined #lisp
anaphoric has joined #lisp
igemnace has quit [Read error: Connection reset by peer]
comborico1611 has joined #lisp
themsay has quit [Ping timeout: 245 seconds]
femi has joined #lisp
comborico1611 has quit [Client Quit]
mrcom_ has quit [Read error: Connection reset by peer]
sauvin has quit [Ping timeout: 272 seconds]
mrcom__ has joined #lisp
EvW1 has joined #lisp
smazga has quit [Ping timeout: 248 seconds]
CloseToZero has quit [Quit: WeeChat 2.5]
karayan has quit [Ping timeout: 258 seconds]
heisig has quit [Quit: Leaving]
karayan has joined #lisp
karlosz_ has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
themsay has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
JohnMS has quit [Quit: Konversation terminated!]
werrwer has joined #lisp
Bike has quit [Remote host closed the connection]
Bike has joined #lisp
etwert has quit [Read error: Connection reset by peer]
martylake has quit [Read error: Connection reset by peer]
ggole has quit [Quit: Leaving]
martylake has joined #lisp
ltriant has quit [Ping timeout: 258 seconds]
t58_ has joined #lisp
t58 has quit [Ping timeout: 245 seconds]
martylake_ has joined #lisp
Lord_of_Life_ has joined #lisp
martylake has quit [Ping timeout: 252 seconds]
Lord_of_Life has quit [Ping timeout: 245 seconds]
Lord_of_Life_ is now known as Lord_of_Life
karlosz_ has quit [Quit: karlosz_]
anaphoric has quit [Quit: anaphoric]
bars0 has joined #lisp
bars0 has quit [Client Quit]
bars0 has joined #lisp
mindCrime has quit [Ping timeout: 245 seconds]
t58_ is now known as t58
femi has quit [Ping timeout: 245 seconds]
martylake_ has quit [Read error: Connection reset by peer]
martylake has joined #lisp
lnostdal has quit [Quit: "Fascism, Nazism, Communism and Socialism are only superficial variations of the same monstrous theme—collectivism." -- Ayn Rand]
warweasle has quit [Quit: going home]
mindCrime has joined #lisp
gravicappa has quit [Ping timeout: 246 seconds]
vlatkoB has quit [Remote host closed the connection]
milanj has joined #lisp
femi has joined #lisp
femi has quit [Ping timeout: 248 seconds]
nydel has quit [Remote host closed the connection]
bars0 has quit [Quit: leaving]
pdv has joined #lisp
martylake has quit [Ping timeout: 258 seconds]
martylake has joined #lisp
femi has joined #lisp
mindCrime has quit [Ping timeout: 245 seconds]
martylake has quit [Read error: Connection reset by peer]
<nullnullnull>
"library manager for Common Lisp" nice mate ;)
<nullnullnull>
a beta version but will do
<aeth>
nullnullnull: You'll want to use GNU Emacs with SLIME. That gives you a separate buffer (in-Emacs frame) for the debugger instead of having to deal with command line input there. It also gives you readline-like control in the REPL (since readline defaults to Emacs-style keys) without having to do rlwrap (which is the in-terminal option... if you're using it in the terminal, you should setup rlwrap)
<nullnullnull>
aeth, im using atm vscode, is it good?
<aeth>
nullnullnull: Also, current SBCL is 16 releases ahead of 1.4.5 so you might want to use Debian's SBCL to compile the latest SBCL (it requires a CL compiler to compile) because there might be bugfixes and other improvements since then.
<aeth>
nullnullnull: If you're using another editor other than Emacs+SLIME, then the important thing is that you're using an editor with Swank integration, since Swank is the TCP protocol that's used to communicate between the editor/IDE and the implementation. Vim probably has the second best support, but vscode might have something.
<aeth>
It's possible that there might be some LSP (Language Server Protocol) layer on top of or instead of Swank, idk, I've never looked into that.
<aeth>
if it exists I hope it's called lisp-lsp or something
<aeth>
otherwise that's a missed opportunity
<nullnullnull>
but lets say that I want my script to work for all platforms
<nullnullnull>
it's better to not use any external-packages I think
<aeth>
nullnullnull: Well, you have two different CLs, the development CL and the deployment CL. You usually develop CL interactively from the REPL with editor integration. Then, you can have some launch file that will call your main function when run with your implementation-specific launch command
<nullnullnull>
it's like source and executables right?
<aeth>
You can build a standalone executable, which is heavyweight but means the user doesn't need CL installed. This basically bundles the whole implementation with the script. Or you can have a script file. With SBCL you can just run it with a #! but the problem is that you need to hardcode the path and it could be in /usr/bin or /bin or somewhere else.
<aeth>
For running a script with SBCL --script works, but for some reason I prefer "sbcl --non-interactive --load path/to/script.lisp" instead of --script. Slight difference in semantics, I guess.
<nullnullnull>
yeah btw I can use this trick: #!/usr/bin/env something
<aeth>
That doesn't work in SBCL unless you make it a bilingual file that is both bash and CL, which actually can work since #| .. |# is a block comment in SBCL and # is a line comment in bash, so #| will be ignored, and then in bash everything after a line that contains "exit" will be ignored
<nullnullnull>
oh
<aeth>
s/comment in SBCL/comment in CL/
<aeth>
It's a bit of a hack, though.
<nullnullnull>
yeah confusing a bit ;)
varjag has joined #lisp
<aeth>
The easiest thing to do for scripting without a hardcoded implementation path would be to have a shell script that contains one line with the line being something like this: sbcl --non-interactive --load path/to/script/entry/point.lisp
ltriant has joined #lisp
<aeth>
You would only run that file when running as a script, not in development, since that file will probably include something like a top-level (main) call
<nullnullnull>
--eval is the same thing right?
<aeth>
Well, you can do --eval but it's easier to put it in its own file imo if it's anything more complicated than a simple --eval "(main)"
karswell has quit [Read error: Connection reset by peer]
<nullnullnull>
for oneliner script yeah
<aeth>
I tried lots of different approaches for my CI script but went with --load instead
Oladon_work has quit [Ping timeout: 260 seconds]
<aeth>
That's because the script file will probably be doing a bunch of (ql:quickload :foo) which you normally wouldn't do.
karswell has joined #lisp
<aeth>
e.g. sbcl --non-interactive --load $SCRIPT_PATH/launch.lisp
<aeth>
then launch.lisp could be as simple as: (ql:quickload :your-script-system) (your-script-package:main)
<nullnullnull>
yeah I got your point ;)
<aeth>
Eval could technically work but it will probably bloat past a one-liner as things tend to do.
<nullnullnull>
but eval will run faster right?
<aeth>
It might not run faster. launch.lisp after first run will be compiled and placed in the cache at ~/.cache/common-lisp/your-implementation-name/path/to/script/launch.fasl (if not SBCL, the extension won't be fasl)
<aeth>
I mean, for a one-liner it might still be faster to just eval it, but that's kind of a microoptimization
EvW has joined #lisp
<nullnullnull>
so at first time will be normal but second run: the load will be faster because it's saved on cache right?
<aeth>
For a large enough file. There might be an upfront overhead that makes eval faster for simple enough commands.
<nullnullnull>
why im asking u this: because in javascript for example they used to convert code to onliner script to load page faster (it's like a production code)
<aeth>
that's because the script is transfered over the network as text
<nullnullnull>
ah
<aeth>
With typical CL, after the first compilation you won't see the text again and will just load the FASL, unless the dependencies have changed or you delete the cache or you upgrade your implementation. Although, I'm actually not sure if launch.lisp would experience that because this might be done through ASDF. The vast majority of your program would be an ASDF system defined in an asdf:defsystem in a foo.asd file, though.
<nullnullnull>
aeth, oh thanks for the info mate, I learned a lot of stuff from you ;)
slyrus1 has joined #lisp
slyrus__ has joined #lisp
<aeth>
You'll probably have four files at a minimum if you're going for a script with this approach, which isn't the only approach. (The shell script that launches it from the shell, the launch.lisp that it calls, the your-project.asd that defines your project, and the script.lisp... but there would usually be at least one more, called package.lisp, where you do the defpackage... especially if there's more than one file that shares one package)
random-nick has quit [Ping timeout: 268 seconds]
slyrus2 has quit [Ping timeout: 246 seconds]
<aeth>
In development, you'd usually use the REPL directly and skip the first two steps, which is part of the reason why you'd want to have the separate files.
slyrus_ has quit [Ping timeout: 245 seconds]
<aeth>
If you can't expect the target machine to have CL, you can build a binary which bundles the implementation with it, which would make the deployment process different. There are portability libraries that handle this use.
<nullnullnull>
yeah, I'm only worrying about the packages atm (need to install on every development machine)
<nullnullnull>
im just trying to use a socket connect (client)
mrcom__ has quit [Read error: Connection reset by peer]
mrcom has joined #lisp
Bike has joined #lisp
alexanderbarbosa has quit [Remote host closed the connection]
torbo has joined #lisp
ebrasca has quit [Remote host closed the connection]
varjag has quit [Remote host closed the connection]