<nij>
Hello! If I have a lisp program that's compiled in a binary, is it possible to get access to the variables defined within in a repl?
<nij>
In other words.. can I "quickload" the binary in a repl, or by means of some other equivalence?
raeda has quit [Read error: Connection reset by peer]
raeda_ has joined #lisp
mmontone has quit [Ping timeout: 240 seconds]
DHARMAKAYA has joined #lisp
random-nick has quit [Ping timeout: 260 seconds]
<tychoish>
nij: you can start a swank server in the binary and then lime into it?
<tychoish>
slime into it
<nij>
Hm.. what if I want many binaries' functions at the same time? For example, with uncompiled lisp files I can (ql:quickload :alexandria) (ql:quickload :local-time) .... etc.
<nij>
But if I use swank, I can only get into one of them (iirc).
slyrus has joined #lisp
mrSpec` has quit [Ping timeout: 246 seconds]
antoszka has quit [Ping timeout: 248 seconds]
mrSpec has joined #lisp
mrSpec is now known as Guest107
antoszka has joined #lisp
<tychoish>
perhaps I'm misunderstanding what your goal is, but I don't think that's true? once you've got a repl, it's a repl
<tychoish>
becuase the "lisp binary" is just the lisp
slyrus has quit [Ping timeout: 265 seconds]
<nij>
tychoish: hmm.. I mean if I have pkg1 and pkg2 both in binary form.
<nij>
I can start pkg1, start a swank, and link to that swank from emacs. Now I'm in a repl that's linked to pkg1.
<nij>
How to further get reach of pkg2?
<tychoish>
compile them both into the same binary
<tychoish>
do (use-package) etc
<nij>
If that's not an option? I'm working with guix, where the cl packages are all packaged.
<nij>
(separately)
Oladon has quit [Quit: Leaving.]
<nij>
I can of course repackage them.. but that doesn't make much more sense to me..
Guest107 has quit [Ping timeout: 265 seconds]
antoszka has quit [Ping timeout: 260 seconds]
mrSpec` has joined #lisp
Oladon has joined #lisp
antoszka has joined #lisp
antoszka has quit [Quit: WeeChat 2.8]
mrSpec` has quit [Remote host closed the connection]
slyrus has joined #lisp
karlosz has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
slyrus has quit [Ping timeout: 240 seconds]
casual_friday_ has quit [Read error: Connection reset by peer]
casual_friday has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
taof has joined #lisp
taof has quit [Remote host closed the connection]
Codaraxis has joined #lisp
Guester8 has joined #lisp
hypercube has quit [Ping timeout: 246 seconds]
lotuseat` has joined #lisp
lotuseater has quit [Ping timeout: 250 seconds]
ramHero has quit [Ping timeout: 252 seconds]
sz0 has joined #lisp
<tychoish>
sorry, nij I was away... I dunno, I think you can either deal with guix and it's packages or have userland quicklisp packages and static binaries, but it's really hard to live in both worlds, and doesn't really get you much. I'd talk to the guix people if you're still having problems?
semz has quit [Ping timeout: 250 seconds]
prxq has quit [Ping timeout: 252 seconds]
prxq has joined #lisp
slyrus has joined #lisp
semz has joined #lisp
slyrus has quit [Ping timeout: 240 seconds]
srhm has joined #lisp
defaultxr has joined #lisp
sloanr has quit [Remote host closed the connection]
karlosz has quit [Ping timeout: 268 seconds]
slyrus has joined #lisp
slyrus_ has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
karlosz has joined #lisp
slyrus_ has quit [Ping timeout: 240 seconds]
Bike has joined #lisp
<Bike>
nij: when you say a lisp "binary", what do you mean? an executable?
Oladon has quit [Quit: Leaving.]
<nij>
Bike, yes, an executable.
<Bike>
so like, guix gives you an executable of, say, sbcl with local-time loaded into it?
<Bike>
and a different executable of sbcl with alexandria loaded into it?
<nij>
i think so
<nij>
Or more generally, I think I am more comfortable with the code in itself.. but for it to run faster, they should be compiled. And I want to be comfortable with them too.
akoana has left #lisp ["Leaving"]
<Bike>
you could distribute FASLs, though formats are unfortunately unstable.
<Bike>
but i don't think doing separate executables would be reasonable. a lisp executable is usually a memory image dump. you can't compose them.
Alfr is now known as Guest48588
Alfr has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
Guest48588 has quit [Ping timeout: 250 seconds]
contrapunctus has joined #lisp
slyrus has joined #lisp
<beach>
Good morning everyone!
<nij>
lemme try to really get a compiled file on guix.
<nij>
good morning!
<Bike>
fasls are compiled, to be clear
<Bike>
but as far as i remember sbcl makes no guarantees that fasls produced by even different runtimes of the same version are compatible, which isn't really amenable for packaging things up
<nij>
just not to the binary form?
hineios2 has joined #lisp
<Bike>
fasls contain machine code
<Bike>
i mean, depending on the implementation
<Bike>
but usually. sbcl's do, ccl's do, etc
hineios has quit [Ping timeout: 252 seconds]
hineios2 is now known as hineios
<Bike>
it's just not a system object file.
slyrus has quit [Ping timeout: 268 seconds]
<nij>
Hmm.. maybe lemme ask a more practical question.
<nij>
Here's a directory tree structure that contains alexandria on guix: https://bpa.st/FZVA
long4mud has quit [Quit: WeeChat 3.0.1]
<nij>
Suppose I have many of them (so not just alexandria, but also other lisp systems), how to I make use of them while developing?
<Bike>
(asdf:load-system :alexandria) probably
<nij>
I used to use (ql:quickload) and am happy with that. At the end of my work, I'd move xyz in (ql:quickload xyz) to asd file.
<nij>
Hmm lemme try that!
<Bike>
i mean, that's pretty much the same as quickload, or rather that's what quickload does
<nij>
Right.. but now all these directories are scattered in /gnu/store on guix systems..
<Bike>
what?
<Bike>
it looks like it configures your asdf so it will find the systems in whatever directories
<nij>
you mean guix configures my asdf so .. ?
elderK has quit [Quit: Connection closed for inactivity]
slyrus has joined #lisp
<Bike>
that's what the source-registry.conf.d stuff does, i believe
<nij>
Hmm.. on my side it doesn't take care of that for me at least.
<Bike>
(gotta be honest - i do not understand that part of asdf at all)
<Bike>
(i just have a broad understanding of what it does)
<nij>
I have to push the following to asdf:*central-registry* so that alexandria loads
<Bike>
unfortunately i haven't used this enough to give you specific advice
<nij>
Before I dive in the whole chapter 8, may I ask about the big picture?
<nij>
Do you mean that maybe there's a smarter way for asdf to search for packages?
<nij>
Rather than just look through the load paths and seek for asd files?
<nij>
> i haven't used this enough ==> that's fine. If the big picture is that, I can handle the details :)
slyrus has quit [Ping timeout: 240 seconds]
<Bike>
right. if you look at "Configuration DSL" a little farther down you can see what you can specify
<nij>
Great to know! I will dive into this! Thanks so much :D
<Bike>
i believe this all is basically in place to allow you to use asdf in concert with whatever system package manager. but i honestly just let quicklisp dump everything into its own directory, sooooo
<Bike>
good luck, hope this helps
thmprover has quit [Quit: Up, up, and away]
<nij>
:)
<nij>
btw, what's the difference between a fasl file and a system object?
<nij>
I was trying to search for it but couldn't find an explanation.
<Bike>
so when i say "system object" i mean like a .o or .so or something - on linux an ELF file
<Bike>
something you can link in C programs
zbigniew has joined #lisp
<Bike>
object files mostly consist of a mapping from symbol names to functions (blocks of machine code)
<nij>
I'm actually more familiar with lisp than C ;).. given my shallow knowledge about lisp :P
<nij>
oh
<Bike>
lisp, however, is very side effect based, and a fasl is more of a recording of side effects - so that loading a fasl is equivalent to loading the file which is equivalent to evaluating all the expressions in order
semz has quit [Ping timeout: 250 seconds]
<Bike>
so for example if you have (defun foo ...) the side effect is to add a function binding for the FOO symbol to whatever function
<nij>
Can I make a fasl file an .o/.so easily? and vice versa?
<nij>
(Theoretically, of course, any thing is possible.)
<Bike>
No, because they are different things. an object is a mapping, a fasl is a sequence of effects.
<nij>
Yeah that's what I guess. I see.
<Bike>
(also because object code will probably use a C ABI and lisp code will probably not)
<nij>
You say an object is a mapping, which maps a name to a C function, for example.
<nij>
What is that C function? an fasl file?
<Bike>
well what an object is is a mapping from symbols to addresses, and some of those addresses are to the beginning of a block of machine code
<Bike>
fasl is a lisp-specific concept
<nij>
OH I see.
<nij>
And fasl file is different from an executable?
<beach>
Yes.
<Bike>
yes. usually a lisp executable is a smallish runtime concatenated onto a memory image. when you start the executable, it loads the entire image into memory
<Bike>
it's more like a save/load function
slyrus has joined #lisp
<Bike>
whereas a fasl is an encoding of a sequence of side effects to do.
<nij>
I see..
<nij>
With asdf:load-system, it can load fasl files, but not executables.. is that correct?
asarch has joined #lisp
<nij>
(Back to asdf.. finally :D)
<asarch>
One very stupid question: Is it valid to do? (format t "This
<asarch>
is
<Bike>
yes, asdf can't load an executable into a running lisp image.
<asarch>
…
<nij>
asarch: no.. parenthesis unbalance.
<asarch>
long
<asarch>
line")
<asarch>
Or should I use here documents?
<nij>
asarch: you mean with many newlines in between? yes it works for me
<nij>
Bike: that's clear. Basically I should stay away from executables..
<nij>
unless i need to ship something out to the *world*.
<copec>
I think I’m going to get a custom license plate: X3J13
<Bike>
asarch: you can put newlines into a string literal, yes.
<nij>
reality:*world*
imode has quit [Quit: WeeChat 3.1]
<beach>
nij: An executable is an OS concept. Only the OS knows how to start such a thing.
<nij>
I see. That matches my impression. Thanks beach :)
Bike has quit [Quit: Connection closed]
slyrus has quit [Ping timeout: 240 seconds]
<nij>
HMMM Then I'm a bit confused! Looking at the tree structure of the directory - https://bpa.st/FZVA
<nij>
Why do they (the guix folks) put .asd with .lisp files, but not with .fasl files?!
<nij>
They should put .asd with the .fasl files, no? So that when it's loaded, the faster versions (fasl) are loaded, rather than the lisp files?
<beach>
nij: On my machine, fasl files are kept separately in .cache and ASDF is configured to know that place.
<beach>
nij: They are stored in versions that depend on the Common Lisp implementation and the version of that implementation.
<nij>
Did you configured asdf to know that place by yourself? Or it's by default?
<beach>
I did no configuration.
<nij>
Hmm.
slyrus has joined #lisp
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
asarch_ has joined #lisp
asarch_ has quit [Client Quit]
asarch has quit [Ping timeout: 260 seconds]
lotuseat` has quit [Remote host closed the connection]
lotuseat` has joined #lisp
slyrus has quit [Ping timeout: 265 seconds]
waleee-cl has quit [Quit: Connection closed for inactivity]
slyrus has joined #lisp
CrashTestDummy3 has joined #lisp
CrashTestDummy has joined #lisp
CrashTestDummy2 has quit [Ping timeout: 268 seconds]
slyrus has quit [Ping timeout: 240 seconds]
CrashTestDummy3 has quit [Ping timeout: 268 seconds]
zaquest has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
zaquest has joined #lisp
slyrus has quit [Ping timeout: 252 seconds]
slyrus has joined #lisp
slyrus has quit [Ping timeout: 268 seconds]
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
andrei-n has joined #lisp
vaporatorius__ has joined #lisp
Vaporatorius has quit [Ping timeout: 252 seconds]
srhm has quit [Quit: Konversation terminated!]
slyrus has joined #lisp
countvajhula has quit [Ping timeout: 258 seconds]
slyrus has quit [Ping timeout: 252 seconds]
skapata has quit [Remote host closed the connection]
lawt has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
slyrus has quit [Ping timeout: 252 seconds]
Guester8 has quit [Ping timeout: 252 seconds]
lawt has joined #lisp
slyrus has joined #lisp
slyrus has quit [Ping timeout: 246 seconds]
yonkunas has quit [Quit: Connection closed for inactivity]
imode has joined #lisp
wildlander has joined #lisp
surabax has joined #lisp
zxcvz has joined #lisp
slyrus has joined #lisp
orivej has joined #lisp
daphnis has joined #lisp
slyrus has quit [Ping timeout: 240 seconds]
yacatuco has joined #lisp
Kundry_Wag has joined #lisp
gaqwas has joined #lisp
gaqwas has joined #lisp
slyrus has joined #lisp
Kundry_Wag has quit [Ping timeout: 265 seconds]
stux|RC-only has quit [Ping timeout: 265 seconds]
stux|RC has quit [Ping timeout: 240 seconds]
slyrus has quit [Ping timeout: 240 seconds]
chipolux has quit [Quit: chipolux]
stux|RC-only has joined #lisp
stux|RC has joined #lisp
stux|RC-only has quit [Ping timeout: 246 seconds]
stux|RC has quit [Ping timeout: 240 seconds]
stux|RC-only has joined #lisp
slyrus has joined #lisp
wildlander has quit [Quit: Konversation terminated!]
stux|RC has joined #lisp
surabax has quit [Quit: Leaving]
Posterdati has quit [Remote host closed the connection]
shka_ has joined #lisp
imode has quit [Ping timeout: 260 seconds]
slyrus has quit [Ping timeout: 252 seconds]
slyrus has joined #lisp
slyrus has quit [Ping timeout: 252 seconds]
Posterdati has joined #lisp
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
varjag has joined #lisp
madrik has joined #lisp
pve has joined #lisp
indathrone has quit [Quit: Leaving]
slyrus has joined #lisp
slyrus has quit [Ping timeout: 268 seconds]
anticrisis has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
edgar-rft has joined #lisp
slyrus has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
hypercube has joined #lisp
rjcks has joined #lisp
rjcks has quit [Client Quit]
<alanz>
nij, re the guix discussion earlier. It would make sense for a guix package to provide fasl files. It completely specifies the context they are used in terms of machine, compiler, other system deps, so they should be reproducable, relevant to your system
rjcks has joined #lisp
<phoe>
as long as they are fully reproducible, sure, why not
<phoe>
and I don't know if FASLs are 100% reproducible
<beach>
What does it mean for a FASL to be "reproducible"?
<phoe>
different compilations produce byte-for-byte identical results
<phoe>
there's a general term, "reproducible builds", that aims for compiled artifacts to be identical for the purpose of assuring that they have not been tampered with in any way
<phoe>
and I assume that the same would apply to FASLs
<beach>
The difference between a compiler for Common Lisp and a compiler for a traditional batch language is that the Common Lisp compiler does not start with an empty compilation environment, so one must somehow specify the exact contents of the startup environment then.
<phoe>
yes, that would be necessary
<phoe>
but I'll leave figuring that out to the guix people
<beach>
Yeah, me too.
mindCrime has quit [Ping timeout: 246 seconds]
<MichaelRaskin>
beach: picking the very specific build of the Common Lisp implementation, and the precise list of other code loaded before compiling the file in question is assumed in the discussion of reproducibility
<MichaelRaskin>
(and it's not like these questions don't have close analogues even when compiling C, it's just that the C analogues of these questions are less useful from the point of view of expressiveness)
cyraxjoe has quit [Ping timeout: 268 seconds]
_jrjsmrtn has joined #lisp
slyrus has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 260 seconds]
<beach>
MichaelRaskin: Makes sense.
slyrus has quit [Ping timeout: 268 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
slyrus has joined #lisp
ebrasca has joined #lisp
ebrasca has quit [Remote host closed the connection]
ramHero has quit [Remote host closed the connection]
ldb has quit [Ping timeout: 252 seconds]
l1x has quit [Quit: Connection closed for inactivity]
madrik has quit [Ping timeout: 240 seconds]
aartaka has joined #lisp
slyrus has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
zbigniew has quit [Remote host closed the connection]
slyrus has quit [Ping timeout: 240 seconds]
amb007 has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
random-nick has joined #lisp
curtosis has joined #lisp
Kundry_Wag has joined #lisp
vegansbane6963 has joined #lisp
mindCrime has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
ldb has joined #lisp
slyrus has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
mindCrime has quit [Ping timeout: 252 seconds]
slyrus has quit [Ping timeout: 268 seconds]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
lotuseat` is now known as lotuseater
karlosz has quit [Quit: karlosz]
cosimone has joined #lisp
<nij>
good morning
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
<nij>
alanz: Yes, I think it makes sense for guix to provide fasl files. In fact, I think that should be where the asd files point to, right? Because they run faster..
<nij>
But the asd file currently stays with the .lisp files, instead of the .fasl files, as indicated in the tree structure of a directory - https://bpa.st/FZVA
<ldb>
given that the cost of compiling CL projects is a lot cheaper than C++ or Rust, it is still good to do source distribution
<splittist>
nij: the real file is the lisp file; the fasl file is a FASt Loading version of that file. If the lisp file is newer, it should be loaded, no?
<nij>
If the lisp file is newer, it should be first turned into a newer fasl file, which should be pointed to by the asd file.. this is what I think that makes more sense..
slyrus has joined #lisp
<Alfr>
No it doesn't, considering that asdf mostly is your build system.
cosimone has quit [Remote host closed the connection]
<nij>
Which part is wrong?
<Alfr>
And loading a systems usually uses the cached fals if the source files aren't newer.
cosimone has joined #lisp
cosimone has quit [Remote host closed the connection]
<Alfr>
Telling asdf about the fasls and not the source files, is wrong in my opinion.
cosimone has joined #lisp
<Alfr>
s/fals/fasls/
<nij>
Oh wait! I might be confused. Lemme try something and get back to this quickly.
<nij>
Ok.. I'm pretty confused - given this tree structure, what should I tell asdf in order to load th fasl files? - https://bpa.st/FZVA
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<nij>
Alfr: may I ask in which way it works for you?
<nij>
Does it store the fasls in the same directory with your lisps?
<nij>
Or it loads the fasls automatically even when they are not in the same directory as your asd file is?
<Alfr>
nij, as a regular user, loading a system creates fasls somewhere in ~/.cache/common-lisp/implementation/...
<nij>
I see. So you mean asdf knows that it should look at ~/.cache/common-lisp/implementation/... for the fasl files, provided that the lisp files are not renewed?
<Alfr>
That's the default behaviour, it's described at the end of section 9.3.
<nij>
Thanks so much! I'd have to see how guix configure that part. :D
Codaraxis_ has quit [Remote host closed the connection]
Codaraxis_ has joined #lisp
Inline has quit [Read error: Connection reset by peer]
curtosis has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
Codaraxis_ has quit [Remote host closed the connection]
Codaraxis_ has joined #lisp
slyrus has joined #lisp
Codaraxis_ has quit [Remote host closed the connection]
Codaraxis_ has joined #lisp
kevingal has joined #lisp
zaquest has quit [Ping timeout: 240 seconds]
slyrus has quit [Ping timeout: 240 seconds]
Nilby has quit [Ping timeout: 258 seconds]
zaquest has joined #lisp
andrei-n has quit [Quit: Leaving]
cosimone has quit [Ping timeout: 250 seconds]
<attila_lendvai>
nij, ASDF has two concepts here: a registry of paths for source files, and something called output-translations that can be used to configure where the fasl files (any output files) are to be found
frodef has quit [Ping timeout: 260 seconds]
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
slyrus has joined #lisp
slyrus has quit [Ping timeout: 265 seconds]
ldb has quit [Ping timeout: 240 seconds]
ramHero has joined #lisp
frost-lab has joined #lisp
daphnis has quit [Ping timeout: 240 seconds]
theBlackDragon has quit [Quit: Boom.]
Inline has joined #lisp
Krystof has joined #lisp
gzj has joined #lisp
<nij>
attila_lendvai: I figure. I think I should dig into guix's source code to see what it actually does..
gzj has quit [Remote host closed the connection]
contrapunctus has left #lisp ["Disconnected: closed"]
gzj has joined #lisp
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
attila_lendvai has quit [Quit: Leaving]
orivej has quit [Ping timeout: 240 seconds]
ech has joined #lisp
orivej has joined #lisp
ech has quit [Client Quit]
contrapunctus has joined #lisp
slyrus has joined #lisp
theBlackDragon has joined #lisp
slyrus has quit [Ping timeout: 240 seconds]
gzj has quit [Remote host closed the connection]
Bike has joined #lisp
slyrus has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<lukego>
on nixos I do: NIX_LISP_ASDF_PATHS=/home/luke/git/myproj common-lisp.sh ...
ebrasca has joined #lisp
arpunk has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
mmontone has quit [Ping timeout: 240 seconds]
amb007 has joined #lisp
frost-lab has quit [Quit: Connection closed]
pagnol has joined #lisp
pagnol has left #lisp ["ERC (IRC client for Emacs 25.2.2)"]
xkapastel has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<nij>
lukego - do you get cl packages/systems from nix channel? How do you #'asdf:load-system from your personal nix profile?
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
amb007 has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
daphnis has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
slyrus has joined #lisp
slyrus_ has joined #lisp
slyrus has quit [Read error: Connection reset by peer]
slyrus_ has quit [Ping timeout: 260 seconds]
wooden has quit [Ping timeout: 252 seconds]
Josh_2 has joined #lisp
wooden has joined #lisp
wooden has quit [Changing host]
wooden has joined #lisp
slyrus has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
thmprover has joined #lisp
remby has joined #lisp
aartaka has joined #lisp
<remby>
has anyone done make in common lisp? I suppose they have but those terms are hard to google
slyrus has quit [Ping timeout: 246 seconds]
<lukego>
I'm using a package called ql2nix. This snapshots quicklisp and (via that same script) puts that into the load path. then I add my own code separately via the NIX_LISP_ASDF_PATHS var
<lukego>
nij: So I'm not using Lisp packages from upstream nixpkgs mostly because I don't think that is terribly complete. it would actually suit me fine to do that - I'm only pulling the default version of everything from the latest quicklisp anyway.
<lukego>
I haven't integrated build of my own code into nix yet actually... I'm still doing that manually from slime...
aartaka_d has quit [Ping timeout: 240 seconds]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 252 seconds]
Sheilong has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Ping timeout: 260 seconds]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<beach>
remby: Do you mean just a Common Lisp version of the Unix utility?
<Josh_2>
Hi
<beach>
Hello Josh_2.
<Josh_2>
Does anyone have any suggested reading for handling financial transactions? The transaction will be in JS but my backend is all CL
<remby>
beach: yeah
<remby>
seems like the type of thing someone would have made with CL's macro abilities et al.
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<beach>
remby: Oh, so use Common Lisp syntax for the Makefile?
<remby>
yeah
<remby>
basically, you get to use CL functions in the Makefile too
<beach>
I see.
<beach>
Josh_2: What kind of "financial transactions"? Buying and selling shares, bonds, etc?
<remby>
and like the dependencies would be specified with macros I guess
<beach>
remby: I doubt it exists, but it sounds like a nice little project.
<remby>
hmm, well ok then :D
amb007 has joined #lisp
<remby>
makefiles are not bad, but after reading one where the author tried to be ambitious I realize something like this would be a lot better
<beach>
The syntax is downright bizarre.
<remby>
I've always thought so too, but I wasn't sure if new syntax would make it easier to use
<remby>
what would be truly cool is if I could somehow translate from a makefile to this new CL makefile, but one thing at a time
amb007 has quit [Read error: Connection reset by peer]
<Josh_2>
beach: nope, just selling access to software basically
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<Josh_2>
well access to a feature
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
contrapunctus has left #lisp ["Disconnected: closed"]
amb007 has joined #lisp
<Josh_2>
it something I've never done before so I don't want to screw it up
slyrus has joined #lisp
contrapunctus has joined #lisp
imode has joined #lisp
slyrus has quit [Ping timeout: 268 seconds]
slyrus has joined #lisp
krjli has joined #lisp
slyrus has quit [Ping timeout: 260 seconds]
<jcowan>
beach, remby: "Make is a beautiful little Prolog for the file system." --foof (aka Alex Shinn)
<remby>
nice, didn't even think of that
srhm has joined #lisp
mindCrime has joined #lisp
slyrus has joined #lisp
slyrus has quit [Ping timeout: 252 seconds]
mindCrime has quit [Ping timeout: 268 seconds]
Bike has quit [Quit: Connection closed]
zbigniew has joined #lisp
aartaka_d has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
slyrus has joined #lisp
surabax has joined #lisp
aartaka_d has joined #lisp
<MichaelRaskin>
remby: isn't it more or less ASDF? It seems to have some support for non-Lisp-compilation actions
aartaka has quit [Ping timeout: 252 seconds]
rogersm has joined #lisp
saganman has joined #lisp
srhm has quit [Ping timeout: 265 seconds]
toorevitimirp has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
<nij>
lukego: oh yes, that's similar to my situation in guix
<nij>
i still have to rely on quicklisp..
<nij>
but i do hope to manage my cl systems with guix (or nix or other similar pm)
hendursaga has quit [Ping timeout: 240 seconds]
hendursaga has joined #lisp
<remby>
MichaelRaskin: I have not looked at asdf
slyrus_ has joined #lisp
adlai has joined #lisp
<adlai>
how much root-th of worse-is-betterness is it to supply, as the generalized boolean to the :type argument, a chosen subtype out of the hierarchy, more specific than the class name, structure name, etc?
<adlai>
"chosen subtype" is not precise; however, there are often plausible other types that may make much more #<unreadable-object> readability
<adlai>
obviously, implementations could do undefined gymnastics if the object isn't TYPEP the requested type, without actually verifying.
nij has quit [Quit: ERC (IRC client for Emacs 27.2)]
<adlai>
the purpose of this would be to print a type name that is more specific than a CLOS class name, where the type itself is possibly even as badly specified as a SATISFIES
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<adlai>
my preemptive justification for printing something other than the builtin type immediately following '#<' is that implementations obviously have tag-sized error margins with what closes the unreadable object form.
* adlai
must admit actually using print-unreadable-object on readable objects quite often, for several purposes outside the scope of this digression
gzj has joined #lisp
remby has quit [Quit: remby]
gzj has quit [Ping timeout: 260 seconds]
IIsi50MHz has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
slyrus_ has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
theothornhill has joined #lisp
attila_lendvai_ has joined #lisp
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
attila_lendvai has quit [Ping timeout: 268 seconds]
hendursaga has quit [Ping timeout: 240 seconds]
amb007 has joined #lisp
slyrus_ has quit [Ping timeout: 260 seconds]
hendursaga has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
remby has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<Shinmera>
Wishlisting and sharing would be much appreciated, if it seems interesting!
Oladon has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
* adlai
cedes topic-of-conversation by footnoting that the return value of the following function is a good candidate for exactly such a type, since it's a built-in that can be pretty much anything, although is almost certainly not a satisfies type
<Josh_2>
What does adding to my wishlist do Shinmera?
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<phoe>
Shinmera: a VN engine in Common Lisp? you're getting further and further with all of that coding of yours
* phoe
claps
adlai has left #lisp ["redaction of :PART text considered censorious"]
cosimone has joined #lisp
<Shinmera>
Josh_2: It means steam will let you know when the game releases, but for us it's important because more wishlists tells the steam algorithm that the game is interesting, and will thus cause it to show it to more people on the steam site itself.
<Shinmera>
Josh_2: so it's important for us to reach a wider audience.
<Shinmera>
phoe: I hope to tear parts like that out of kandria and this and make them available in Trial is generic modules sometime.
<phoe>
yes, I see
yonkunas has joined #lisp
slyrus_ has joined #lisp
<Josh_2>
okay I will add to wishlist
<Shinmera>
Thank you very much!
hendursaga has quit [Ping timeout: 240 seconds]
cobax has joined #lisp
hendursaga has joined #lisp
<cobax>
Does lisp have a reasonable and secret-weapon-like alternative to kubernetes and all that bloated insanity surrounding "scaling" a program to many servers horizontally more or less automatically and without configuration?
<Shinmera>
no
<Shinmera>
scaling a program well requires a lot of design that isn't down to tooling at all, though.
zxcvz has quit [Quit: Leaving]
<phoe>
"scaling" is not a well-defined term
<cobax>
That is what I keep being told, but I don't know if that is actually true. How do you know that is true? Or that it is necessarily true? Is there a paper that goes into the Computer Science reasons why scaling needs to be so complex and "require a lot of design" and can't just be "throw N computers into this pool of servers and it'll do what you
<phoe>
that's the main issue
<cobax>
want"?
<phoe>
cobax: what do you mean by "scaling"?
<Josh_2>
just get a faster vps, ezpz
<cobax>
What people that use kubernetes mean by it. Whatever it means, in my opinion it needs to be pushed down the abstraction stack and be as buried as "garbage collection" is, i.e. zero configuration and it happens automatically. I'm trying to understand why we're not there yet.
<Shinmera>
there's a lot of research on this that shows this in various ways, but it's also easy to realise because you can just think about things in terms of message overhead. the more you need to communicate between parts, the more overhead there is, the slower things go.
<imode>
clojure has some interesting stuff in the "highscale" whatever.
slyrus_ has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
<phoe>
what does your input look like? what does your output look like? what is the amount of data you need to process per second? what is the amount of data you need to store in some sort of databases per second? what are the latency constraints on your processing? does your input data come as a single stream, or as multiple streams? what about your output data? how does consensus look like in your system? how do
<phoe>
you want to handle network partitions and partial system outages?
amb007 has joined #lisp
<phoe>
and that's just the tip of the iceberg
<cobax>
Shinmera: I don't understand. How many function calls I make is part of the reasoning about the program. Every program needs to think about it.
<Shinmera>
cobax: take a course on parallelism at your local university.
amb007 has quit [Read error: Connection reset by peer]
mindCrime has joined #lisp
<cobax>
phoe: why can't all that be answered within the program (i.e. in-band) and not on infrastructure configuration (i.e. config files for kubernetes, out-of-band of the code)?
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
hendursaga has quit [Remote host closed the connection]
<cobax>
Shinmera: I am already a functional programmer, parallelism for me is automatic in all code I write, so why can't I just give my program a pool of N servers and it figures out what it needs? Why do I have to babysit it? I don't babysit the garbage collector. I am trying to understand the real difficulty here.
<Shinmera>
it's not "automatic" though
<Shinmera>
that's just a lie you've been sold.
<cobax>
Garbage collection is not automatic?
<Shinmera>
no, it doesn't scale well automatically.
amb007 has quit [Read error: Connection reset by peer]
<Shinmera>
you /do/ need to babysit it at scale.
amb007 has joined #lisp
<cobax>
but you can change it behind the scenes without caring about the program. Just observe its behavior: does it cons a lot? switch to a generational garbage collector; does it not? switch to another... whatever. Just self-observe the program running and make choices automatically based on need.
<Shinmera>
I mean if you want to pretend everything is as simple as that then sure.
<remby>
you are asking about distributed computing?
<remby>
not sure why that would be lisp specific
amb007 has quit [Read error: Connection reset by peer]
<cobax>
Well, let's say that is "some solution" but not "the best" solution. I am looking for the "some solution" that is the alternative to crazyland kubernetes.
<cobax>
Because lisp tends to solve problems more simply and smartly
<cobax>
and kubernetes is too bloated for me to be convinced it is smart
amb007 has joined #lisp
<remby>
kubernetes is there because of other reasons
hendursaga has joined #lisp
<remby>
it looks more like an os problem to me, not language problem
<cobax>
Look at qooxlisp or clog, no other language has that type of solutions
amb007 has quit [Read error: Connection reset by peer]
<cobax>
Lisp has smart people that don't care when the world tells us "oh that is too complex", lisp is where we make the impossible possible
<imode>
appreciate the enthusiasm but lisp is a design aesthetic, not a magic bullet.
<cobax>
So is "kubernetes" the final boss that we'll never simplify? I find that hard to believe. So I was trying to understand what the hullaballo is about, why the pretense that this is so complex when it just seems to be "N computers in a pool, sharing their resources". Why is that so complex?
amb007 has joined #lisp
<Shinmera>
because it just is
<imode>
kubernetes is an overengineered mess brought to "market" by a company which.. overengineers stuff, what a surprise.
<imode>
go build and host your own servers.
hendursaga has quit [Remote host closed the connection]
<imode>
or colocate and build a lisp-controlled cluster or something.
<cobax>
imode: there you go, you get me. Which tech is doing what k8s do, but sanely, and without bloat? Can you help me?
hendursaga has joined #lisp
<imode>
k8s does everything, so.
<cobax>
But how to achieve the "horizontal scale" people so love, where I can throw more machines at the problem?
<imode>
you don't really throw "more machines" at a problem, you throw more containers/"pods" which then tile across the available machines.
<imode>
that's a service level design decision. where you can just add more instances of your program to handle requests.
<Alfr>
cobax, in general you can't. Some algorithms are inherently sequential.
<imode>
which is fine. but you kinda have to design with that.
<cobax>
imode: I understand what you are saying but I am skeptical that this is such an inherent problem that the scaling software needs to be "coupled" with the program being scaled such that it knows about it so its design can be tailored to it. Garbage collectors at least come with a default. Where is the default "non-ideal scaling that at least scales
<cobax>
most programs reasonably"?
<imode>
"we need to be able to scale up and scale down our service to handle load at different times, and scaling down is important to save money." "okay, I'll make these specific parts of our service scalable, which means that we can continually add more of them and remove them depending on our load."
amb007 has quit [Read error: Connection reset by peer]
<imode>
literally the conversation about "scale" that every company has.
shka_ has quit [Ping timeout: 268 seconds]
<imode>
so it's not about.. garbage collection or any small stuff, it's a larger architectural thing.
amb007 has joined #lisp
<cobax>
imode: as a lisper I had rather all those decisions be in-band i.e. that I can make them within my lisp code and not having to configure the "general scaling software" underneath it. Just like I can switch garbage collectors from within a language.
<cobax>
I don't understand why I need to go outside my program code to make those decisions... it's un-lisp-like to be going out-of-band.
<imode>
a garbage collector is not equivalent to automatic parallelization or "automatic scalifierieriers".
<cobax>
Okay, what is equivalent to automatic parallelization? Is it a totally unique problem?
amb007 has quit [Read error: Connection reset by peer]
<imode>
how about you describe what you want.
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<cobax>
imode: okay, give me a minute to phrase it in my head
Kundry_Wag has joined #lisp
slyrus_ has joined #lisp
<Josh_2>
imode: I think I've killed a few werewolves with lisp
slyrus_ has quit [Read error: Connection reset by peer]
<Josh_2>
silver is a pretty good consolation
trokotech has joined #lisp
slyrus_ has joined #lisp
<cobax>
imode: if I code 100% functionally, no state, as I do (I use algebraic effects, the call/cc's disappear when I compile), then I want to take advantage of the fact that my code (as 100% FP) can scale automatically without my having to do anything to it. Kubernetes can't appreciate the work I did on my code. I need a smart thing that appreciates it
<cobax>
and runs it at scale, on this or that server, I don't care, just scale as needed and without my input.
amb007 has quit [Read error: Connection reset by peer]
<imode>
the problem is that, again, data dependencies within your program dictate whether or not you can auto-parallelize things.
<cobax>
imode: so then the program in charge of scaling can see that and not try to scale the unscalable bits. Still, should be zero configuration, no?
<imode>
but that's, again, parallelism on a single machine.
amb007 has joined #lisp
<cobax>
Yeah, I want across many machines = horizontal scaling.
<imode>
hadoop is your friend, then.
Kundry_Wag has quit [Ping timeout: 240 seconds]
<cobax>
I want to seamlessly run a program on top of however many computers, and I want those two things as decoupled as possible.
<imode>
"horizontal scaling" doesn't mean "on many machines", necessarily.
trokotech has left #lisp [#lisp]
<imode>
could be multiple processes on a single machine that are exact replicas of each other.
<cobax>
imode: another way to phrase it: I want a super-duper-pro DevOps person to scale a Hello World awesomely and professionaly for me so I can grab what he did and replace the Hello World with whatever program I want, forever into the future.
trokotech has joined #lisp
<cobax>
That is what I don't understand why we don't have.
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<cobax>
imode: I stand corrected re horizontal scaling.
amb007 has joined #lisp
<imode>
you should probably learn how existing services are implemented in a "scalable" fashion before trying to dissect why something isn't present in a language ecosystem.
slyrus_ has quit [Ping timeout: 265 seconds]
<imode>
k8s was designed to work with heterogeneous workloads, meaning stuff written in different languages communicating over network protocols.
VincentVega has joined #lisp
<imode>
which is neat. means you can spin up pods and have them talk to other pods.
<Josh_2>
cobax: sounds to me like you have a cool project to start
<cobax>
imode: I am a Computer Scientist. DevOps people give me lots of excuse, but they never tell me the Computer Science reason why I can't automatically scale a 100% functional program on multiple hardware and cpus with zero config. I wanted to know that reason so I can go against it on my own and win over it and show people it's silly. Because I bet
<cobax>
it is silly.
<remby>
just use plan9 m8
amb007 has quit [Read error: Connection reset by peer]
<cobax>
"heterogenous workloads" sounds like something the programming language should care about and not the thing in charge of making the bytes run in many machines.
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
hjudt has joined #lisp
amb007 has joined #lisp
<cobax>
Josh_2: yes but first I need to understand which Computer Science problem I am tackling here.
<cobax>
No one can tell me that despite everyone being an expert in what I cannot do.
slyrus_ has joined #lisp
<markasoftware>
There are no large-scale practical "pure fp" applications, so there's no need for such software
<imode>
well, as a computer scientist, and a software engineer for a large company (read: amazon), there's a lot more to "making code run fast" than just parallelizing the nonsense out of it.
<markasoftware>
almost every large scale application i can think of uses a persistent database, for one
<cobax>
markasoftware: that is true but no out of impossibility. It is true simply out of inertia. I am ahead of the curve so yes, my software as of today is 100% functional. And I don't have anything to configure that I want to say, I just want my code to run in as many computers as it needs, I should only care about paying the bills.
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<imode>
"I am ahead of the curve" vibe check.
<markasoftware>
how would you code Twitter with pure fp? Where would you store the tweets?
cage_ has joined #lisp
<remby>
markasoftware: what if it's in memory :P
<cobax>
imode: ah, so you profit from trying to convince me that this is so complex so I should just use AWS to scale...
<cobax>
wrong person to ask!
<imode>
yeah, despite not working within AWS.
<imode>
I'm totally a shill for lex lutho- I mean, bezos.
<remby>
lmao
<markasoftware>
dbnr datastore will conquer all
<cobax>
sure, but still. You're going to believe that what Amazon is doing is necessary.
<markasoftware>
s/dbnr/bknr
<imode>
nice assumption but I'm there for the pay.
<imode>
here's a conversation. "I want this part of my app, which communicates with this other part of my app, to be tiled across multiple machines." "okay, now how will you get the two parts of your app to communicate when they're not on the same machine, network protocols?" "I dunno, I want that figured out for me." "kinda depends on what you want, whether you need fast or reliable transports." "Can't my
<imode>
compiler figure that out for me?" "not without hints, because it doesn't understand your intent."
<remby>
cobax: this topic you want to look into is distributed computing
nij has joined #lisp
<mister_m>
Hi I want to ensure that when developing in emacs+slime the code I am compiling and intereacting with is "single steppable". I know with SBCL I can simply say, ``(declaim (optimize (debug 3)))'' and the debug mode should ensure that. Is that something I should just add to my .sbclrc file? Is there any real downside to doing that?
slyrus_ has quit [Ping timeout: 268 seconds]
<cobax>
imode: isn't all the information needed on my code already? can it not be inspected? would it help if I coded in a reflexive language so the scaling software can ask all the question it thinks it needs to my code directly?
<cobax>
remby: I appreciate the input.
<imode>
again, not unless you specifically demarcate the boundaries between parts of your code.
<Josh_2>
mister_m: pretty sure debug 3 is the default
<imode>
which is what erlang and clojure let you do.
<cobax>
imode: I would be okay with demarcating whatever in code as that is in-band so I am fine with that
<cobax>
precisely what I want is to stay in-code
<cobax>
I never understood this "you gotta configure this outside the code", Smalltalk never seems to have to abide by that rule, so why should anyone else accept less?
<imode>
smalltalk never really did the things that people are doing these days.
<IIsi50MHz>
Cobax, maybe the reason you have trouble finding the answer you want is that you're looking for a short+simple reason and the real answer is more complicated than that?
<imode>
^
<cobax>
How do they serve a third of the world's shipping container companies without doing scaling?
<cobax>
Did they bypass the problem? If so, can I bypass it too?
<imode>
in what world do shipping container companies run on smalltalk.
<IIsi50MHz>
+1 "distibuted computing"
<IIsi50MHz>
er… s/sti/stri
<cobax>
IIsi50MHz: you are correct. And have you seen how many times lispers have simplified things beyond anyone's belief? Many times! I have faith in lispers.
<imode>
like I need to know the source for that statistic now.
<imode>
lisp evangelism is alright but the point of evangelism is that it's backing practical things.
<IIsi50MHz>
^
<imode>
and you need to understand practical problems and their structure before you evangelize technology X as a solution to that problem.
<remby>
monads didn't even pull up until the 90s iirc
amb007 has quit [Read error: Connection reset by peer]
<cobax>
imode: if the 35% figure is not there, continue googling that company name with Smalltalk and/or "35%" until you find it. It's somewhere.
hendursaga has quit [Ping timeout: 240 seconds]
<cobax>
remby: monads have been replaced by algebraic effects today in academia and for all practical purposes, fyi, you can see my code I linked above for an example usage.
<remby>
I don't actually know what a monad is, I just thought that was an important point.
<remby>
people have been handling io for a while without it
<imode>
"As a pure object-oriented database and object server, GemStone/S "
<cobax>
remby: monads are possibly the most complex isomorphism of algebraic effects; therefore, they are useless today.
<cobax>
imode: right, I do believe Gemstone/S is what helps them scale. Is that what you are saying?
<imode>
not that big of a surprise that it's a database. wouldn't really call it "powering" something, but fair point, a single shipping company.
<cobax>
imode: it's a "4gl-ish" database which is not the same as what people understand when you just say "database"
<cobax>
Gemstone/S is actually a Smalltalk.
hendursaga has joined #lisp
<cobax>
with an embedded db.
<mister_m>
Josh_2: Maybe you are correct - I think what I mean to ask is how can I ensure that the debugger shows me the same "evaluating call" output as my code
<cobax>
Gemstone/S is a "database" in the same sense MUMPS is a "database" (i.e. both are complete languages with an embedded horizontally-scaling database)
<imode>
that's great. that's not a third of all shipping.
<imode>
still impressive.
<cobax>
imode: somewhere else it says 35% of all shipping is overseen by smalltalk code.
<cobax>
imode: my not being able to find the source does not mean the source does not exist.
<imode>
well, interested in seeing that figure.
<cobax>
imode: as soon as I can find it again I will show you.
<imode>
yeah, because that's how.. evidence works.
<cobax>
imode: you are correct.
<imode>
my girlfriend in canada surely exists, but I can't produce any evidence, doesn't mean she doesn't exist, right? /s
<cobax>
So but from your reading, what is Gemstone/S doing right? There is zero configuration for it.
<imode>
in what world is there zero configuration for an application like this.
<cobax>
I just can't believe scaling needs to be coupled with the program being scaled. That seems totally unbelievable. Can't people just scale "a very complex program" and then we can all replace our program instead of "very complex program"?
amb007 has quit [Read error: Connection reset by peer]
<imode>
I feel like you really need to dig into what the problems are behind distributed computing before you go randomly picking fights with problems you don't grasp.
<imode>
it takes people a while to grapple with that field because it is fairly complex.
amb007 has joined #lisp
<mister_m>
cobax: read about the CAP theorem maybe
<cobax>
imode: I do want to tackle that field, and I want to start from the side that is the "fact" that is "keeping me from scaling with zero config". What part of distributed computing needs to be so coupled with my program, such that it is impossible for me to ask someone to scale "the toughest program to scale in the world" and then the rest of the
<cobax>
world can just copy that infrastructure and replace "the toughest" with their code!
<cobax>
mister_m: thank you, I will do that.
<imode>
here's the thing. if it was possible, someone would be doing it.
<cobax>
imode: no. we are in 2021, we are not in "every year in the future". So you can't say that.
<cobax>
Maybe something is possible but someone will only have done it in 2022.
trokotech has quit [Remote host closed the connection]
<imode>
you can't simultaneously wonder "why are we not doing this" and then say that it's only possible when someone does it in a future year.
<imode>
you're implying it's not just possible, it's incredibly easy, in current year.
<cobax>
imode: I can because I see companies like Heroku approaching what I am saying
trokotech has joined #lisp
<cobax>
Heroku somehow managed to do a lot of work already to do with scaling without knowing yet anything about my code.
<imode>
heroku isn't.. even close to what you're describing you want.
<imode>
yeah because _they just spin up your service, which communicates over network protocols, over multiple computers_.
<cobax>
Yes it it. I want something I can throw an executable into and it figures out how many machines it needs or whatever, so long as it fits my budget.
<imode>
so.. k8s?
<imode>
so.. heroku? load balancers and autoscaling has been around for a decade+.
<cobax>
So why haven't they been wrapped up in some sort of docker thingy already such that I can drag and drop my executable there, and with no questions asked, it does all th autoscaling and load balacing for me? Everyone needs the same stuff: enough resources to serve clients comfortably while fitting my budget. I don't understand what further questions
amb007 has quit [Read error: Connection reset by peer]
<cobax>
are needed. Throw resources at my program until I have no more money. That should be simple, Heroku is almost there, it seems.
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<imode>
think you're talking in circles. the solutions exist... heroku, kubernetes, orchestration engines, etc.
* remby
is now interested in distributed programming
<remby>
nope, have to write my own distributed OS in common lisp now :D
<cobax>
imode: thank you for answering my questions with patience. I will leave and go ask some smalltalkers, maybe they will understand my automating instincts better. If we don't fix this, DevOps people will forever be doing the same exact thing: scaling software. To me it looks 100% automatable, but if you say it isn't... then I will just try alone.
<cobax>
Thanks again.
<cobax>
"everything in Computer Science is automatable except scaling" would be a weird world to be living in.
Sheilong has quit []
<imode>
not everything in CS is able to be automated.
<remby>
most things in CS have probably been solved before tbh
<remby>
which does not have a long history, so that's kinda sad lol
<imode>
remby: the design of cloudflare workers is awesome. they use the v8 runtime to spin up applications that are smaller than containers, but have fine-grained resource constraints.
<nij>
Hi #lisp! If I have two versions of pkgA, say v1 and v2, how to I specify for asdf to load pkgAv2?
<imode>
fwiw I'm working on an alternative language for this.
amb007 has quit [Read error: Connection reset by peer]
<remby>
but I don't want to drag this on
<phoe>
nij: ASDF doesn't deal with packages; you mean systems?
<nij>
right it's called system in CL! systems!
<phoe>
I'd say that you need to load the proper ASD file and then asdf:load-system; that should be enough
amb007 has joined #lisp
<nij>
:O I thought to asdf:load-system is to load the ASD file
<nij>
hmm
<phoe>
nope
trokotech has quit [Remote host closed the connection]
<Alfr>
nij, didn't I already link you to asdf's documentation earlier today? It's in section 8.
trokotech has joined #lisp
slyrus_ has joined #lisp
<nij>
Alfr: I'm trying to deal with another problem (namely, cl systems integration in guix..) and haven't really looked at it. I apologize.
terpri has quit [Remote host closed the connection]
trokotech has quit [Remote host closed the connection]
slyrus_ has quit [Ping timeout: 252 seconds]
<Alfr>
nij, you can configure asdf's source-registry to look at different locations, order does matter, as it will take the first asd file that fits the bill.
<nij>
Alfr, in guix I might have 10 different versions of the same lisp system. I'm trying to figure out a way to call any of them at will.
<phoe>
call, as in, load from inside Lisp?
<phoe>
(remember that you won't be able to have multiple versions of the same system loaded at the same time)
trokotech has joined #lisp
<Alfr>
nij, you can reconfigure it at run time, tough loading two different versions of the same system into the same image will likely turn out not to provide a working system.
<phoe>
but I assume that you could write a function or set of functions that is capable of reading Guix package data, and will then call LOAD-ASD on ASD files in proper locations, therefore "circumventing" the ASDF registry
<phoe>
this will allow you to run Lisp with various combinations of Lisp system versions, which is what you seem to be looking for
<Alfr>
nij, asdf:initialize-source-registry is what you're looking for where you should provide the source-registry configuration you'd like it to use.
<phoe>
...or stuff all the pathnames to individual system directories into the source registry, as Alfr says
<Josh_2>
can't believe after all this time that I could just use (getf ) to access properties in a plist
<Josh_2>
I always tried get which never worked
<Alfr>
nij, also phoe's load-asd idea might be more concise.
<Josh_2>
absolute smooth brain moment
remby has left #lisp ["Good Bye"]
<nij>
i see
Kundry_Wag has joined #lisp
mindCrime has quit [Ping timeout: 260 seconds]
<Josh_2>
Yesterday I found out you can use (apply #'make-instance <class-name> <plist of initargs and values>)
<Josh_2>
very useful
Kundry_Wag has quit [Ping timeout: 252 seconds]
<nij>
Josh_2: you mean you can use that sexpr for what?
<nij>
Make an instance of some class?
<Josh_2>
yes
<Josh_2>
like this (apply #'make-instance 'sticker '(:name "abc" :filename "abc.png")) etc
<nij>
Err what else would you do to make an instance?
<phoe>
Josh_2: #'APPLY + plists generally combine very well
<Josh_2>
hey I never said it was special, just that I never realized you could do that
<nij>
oh oh
<phoe>
errr, #'APPLY + &KEY + plists
waleee-cl has joined #lisp
trokotech has quit [Remote host closed the connection]
anticrisis has joined #lisp
<Josh_2>
apply has always been a bit of a mystery to me, not that I don't use it
<nij>
Yeah I think that #'APPLY splices its arguments is a brilliant design.
trokotech has joined #lisp
<nij>
(apply #'f a b c d e (g h i j) k l m (n o) p) =? (f a b c d e g h i j k i l m n o p)
theothornhill has quit [Ping timeout: 240 seconds]
slyrus_ has joined #lisp
trokotech has quit [Remote host closed the connection]
trokotech has joined #lisp
rjcks_ has joined #lisp
slyrus_ has quit [Ping timeout: 246 seconds]
ceblan has joined #lisp
rjcks has quit [Ping timeout: 252 seconds]
attila_lendvai_ has quit [Ping timeout: 240 seconds]
theothornhill has joined #lisp
Lord_of_Life_ has joined #lisp
slyrus_ has joined #lisp
theothornhill has quit [Remote host closed the connection]
Xach has quit [Ping timeout: 240 seconds]
ebrasca has quit [Remote host closed the connection]
Bike has joined #lisp
Lord_of_Life has quit [Ping timeout: 268 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<Bike>
only the final argument is spliced
<Bike>
you can just use append to do your own splicing, of course
Xach has joined #lisp
cage_ has quit [Quit: Leaving]
slyrus_ has quit [Ping timeout: 260 seconds]
DHARMAKAYA has joined #lisp
slyrus_ has joined #lisp
slyrus_ has quit [Ping timeout: 252 seconds]
OlCe has joined #lisp
Loplin has joined #lisp
choegusung has joined #lisp
pve has quit [Quit: leaving]
choegusung has quit [Client Quit]
daphnis has quit [Ping timeout: 240 seconds]
karlosz has joined #lisp
OlCe has quit [Ping timeout: 252 seconds]
slyrus_ has joined #lisp
long4mud has joined #lisp
slyrus_ has quit [Ping timeout: 252 seconds]
Bike has quit [Quit: Connection closed]
rumbler31 has quit [Ping timeout: 252 seconds]
slyrus_ has joined #lisp
zooey has quit [Ping timeout: 240 seconds]
zooey has joined #lisp
slyrus_ has quit [Read error: Connection reset by peer]
c2f0 has joined #lisp
mmontone has joined #lisp
gitgood has quit [Quit: Probably away to do something really awesome]
Loplin has left #lisp ["Killed buffer"]
slyrus_ has joined #lisp
renzhi has joined #lisp
karlosz has quit [Quit: karlosz]
slyrus_ has quit [Ping timeout: 246 seconds]
surabax has quit [Quit: Leaving]
mood has quit [Quit: Gone.]
mood has joined #lisp
gitgood has joined #lisp
hiroaki_ has joined #lisp
rjcks has joined #lisp
slyrus_ has joined #lisp
rjcks_ has quit [Ping timeout: 265 seconds]
gitgood has quit [Remote host closed the connection]
hjudt has quit [Ping timeout: 240 seconds]
varjag has quit [Ping timeout: 246 seconds]
slyrus_ has quit [Ping timeout: 265 seconds]
gaqwas has quit [Ping timeout: 246 seconds]
Jachy has quit [Ping timeout: 258 seconds]
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
krjli has quit [Remote host closed the connection]
Stanley00 has joined #lisp
random-nick has quit [Ping timeout: 240 seconds]
Stanley00 has quit [Remote host closed the connection]
slyrus_ has joined #lisp
rjcks has quit [Quit: leaving]
slyrus_ has quit [Ping timeout: 240 seconds]
slyrus_ has joined #lisp
VincentVega has quit [Quit: Connection closed]
slyrus_ has quit [Ping timeout: 240 seconds]
nicktick has quit [Ping timeout: 265 seconds]
spaethnl has joined #lisp
Jachy has joined #lisp
mmontone has quit [Quit: Connection closed]
curtosis has joined #lisp
slyrus_ has joined #lisp
akoana has joined #lisp
slyrus_ has quit [Ping timeout: 252 seconds]
mrSpec has joined #lisp
mrSpec has joined #lisp
mrSpec has quit [Changing host]
tempest_nox has joined #lisp
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 240 seconds]
X-Scale` is now known as X-Scale
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
mindCrime has joined #lisp
Kundry_Wag has joined #lisp
gzj has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
lotuseater has quit [Quit: ERC (IRC client for Emacs 27.1)]
Codaraxis has joined #lisp
mmontone has joined #lisp
Kundry_Wag has joined #lisp
slyrus_ has joined #lisp
Codaraxis_ has quit [Ping timeout: 252 seconds]
terpri has joined #lisp
Nilby has joined #lisp
mseddon1 has quit [Quit: Ping timeout (120 seconds)]
mseddon1 has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]