<charles`>
flip214: by ignore package nickname I didn't mean "not have to type it", I meant "change the package definition to not have a nickname without changing the source code" and before or while ASDF is loading it.
nmg has joined #lisp
<fiddlerwoaroof>
charles`: you can dynamically modify all of these things
<fiddlerwoaroof>
I _believe_ there's an ASDF extension somewhere that has some sort of file-local package nicknames
todun has quit [Quit: todun]
<charles`>
Yes, I see RENAME-PACKAGE, but how to use it with asdf
<charles`>
basically I have two packages that have names CL-BASE64 and BASE64; I need both because they are dependencies for different dependencies. CL-BASE64 has nickname BASE64. I just need to remove that.
chateau1942 has left #lisp [#lisp]
<fiddlerwoaroof>
I wonder if ASDF has a mechanism for overriding dependencies
<fiddlerwoaroof>
I'd be inclined to force one system in this case and then add a bit of code to emulate the other one to the BASE64 package
<charles`>
It isn't that simple. cl-base64 and base64 have differently named functions and cl-base64 has some functions that base64 doesn't have at all
<fiddlerwoaroof>
Yeah, what I'm thinking is take the one with the more complicated to implement function, and then write your own code to implement the missing names
<fiddlerwoaroof>
(in-package :cl-base64) (defun base64->string (v) (parse v)) or whatever
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
aeth has quit [Ping timeout: 246 seconds]
<charles`>
so what you're suggesting is just don't use BASE64 package at all
<fiddlerwoaroof>
This is really why package nicknames should not be used in libraries, especially generic terms like "base64"
<charles`>
Good morning to beach
<aeth>
nicknames are fine if you have a unique nickname
<aeth>
so, not 'json'
nicktick has quit [Ping timeout: 246 seconds]
<aeth>
"unique nickname" would be a bit of a contradiction because it doesn't scale to large communities, but reasonable nicknames could work
nicktick has joined #lisp
<fiddlerwoaroof>
aeth: I'd generally say, if you're writing an application, use global nicknames as much as you want
<fiddlerwoaroof>
Where application is defined as "code not intended to be used as the dependency of another system"
<aeth>
An example of a reasonable nickname would be e.g. firefox for firefox-browser or something like htat, although that's an application.
<fiddlerwoaroof>
I guess alexandria uses nicknames for versioning
<fiddlerwoaroof>
alexandria is a nickname for alexandria.1.dev or something
<aeth>
And the larger the framework/engine, the more likely it will behave like an "application" by your view, though, imo
matryoshka has joined #lisp
<fiddlerwoaroof>
That's probably right
<aeth>
A big game engine or web framework probably can get away with a nickname
<aeth>
as long as it's not a ridiculously colliding one like "game"
<aeth>
or "web"
<fiddlerwoaroof>
Well, I'd generally think those would be ok for an "end user"
<fiddlerwoaroof>
Because then they'd be guaranteed to be unique
dbotton has quit [Quit: This computer has gone to sleep]
<fiddlerwoaroof>
As long as your dependencies obey the contract of "not defining package nicknames"
<aeth>
fiddlerwoaroof: I'd argue that a game engine would be wrong to use "game" and a web framework would be wrong to use "web"... however, they could in their documentation (or even in a project autogenerator) use that as the default for the *user* and *their* project, rather than for a library.
<aeth>
Although I guess you might want to run several websites or several game servers together in one image.
<fiddlerwoaroof>
What I mean by "end user" is "system that is never depended on by any other systems"
nicktick has quit [Ping timeout: 240 seconds]
<fiddlerwoaroof>
For the other problem, you need a virtualization layer for CL
<beach>
First-class global environments might help.
<fiddlerwoaroof>
Yeah, that's basically what I mean, as far as I understand it
<aeth>
absolutely
<beach>
There is not much to understand. It's just a protocol with a bunch of generic functions that look like the standard ones, but with an additional environment parameter, so find-class, find-package, fdefinition, etc.
<aeth>
You'd ideally want first-class global environments if you want to run multiple server things of the same type (games, websites, app servers, etc.) on one image
<aeth>
Otherwise, there are too many global variables in the language to be sure that they won't interfere with each other in unexpected ways.
<beach>
Is this going to be a "Let's define an improved version of Common Lisp with fewer global variables" discussion?
<fiddlerwoaroof>
beach: I'd rather just define a way to "fork" the common lisp environment so that changes in one part can't directly affect changes in the other
<fiddlerwoaroof>
The only thing you'd need then is a protocol to pass data between the two sides
dbotton has joined #lisp
<beach>
I am planning a way to define incremental first-class global environments.
<fiddlerwoaroof>
This is, incidentally, what unix did
<beach>
Oh?
<fiddlerwoaroof>
Docker containers are just namespaces for all the global resources: PIDs, ports, etc.
<beach>
I see.
<aeth>
beach: No. You don't need to remove the globals if you have different global environments so COMMON-LISP:*FOO* can refer to different things depending on the environment.
<fiddlerwoaroof>
Most of them bundle an entire OS image inside the namespace, but there's no necessity for that
<beach>
aeth: Got it.
<aeth>
It already can refer to different things depending on the thread in most implementations... so my concern probably isn't as big of a problem as I think.
<fiddlerwoaroof>
A docker container can be a single executable, as long as it has no dependencies
andreyorst has joined #lisp
dbotton has quit [Quit: This computer has gone to sleep]
<charles`>
fiddlerwoaroof: in your example you used SB-KERNEL:SIMPLE-PACKAGE-ERROR. isn't that specific to sbcl? is there a portable way?
thinkpad has quit [Read error: Connection reset by peer]
epony has quit [Remote host closed the connection]
epony has joined #lisp
aartaka has joined #lisp
thinkpad has joined #lisp
emaczen has joined #lisp
Misha_B has joined #lisp
thinkpad has quit [Ping timeout: 240 seconds]
rumbler31_ has joined #lisp
thinkpad has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
pillton has quit [Quit: ERC (IRC client for Emacs 27.1)]
refpga has quit [Read error: Connection reset by peer]
galex-713 has joined #lisp
<charles`>
I've found that the path of least resistance is to not use the library that depends on base64
<charles`>
I still think, as a community, something should be done about cl-base64, not only does it use a generic nickname, the git repository and maintainer are not accessible.
ppbitb has quit [Quit: WeeChat 2.9]
ppbitb has joined #lisp
<beach>
charles`: The only way that will happen is if someone decides to work on it. There is no community decision process that will make it happen in any other way.
nicktick has joined #lisp
<fiddlerwoaroof>
charles`: my suggestion would still work, you just have to put the system that depends on cl-base64 as the dependency of the system with the patch
<aeth>
charles`: or create a superior library with a compatible API and get the library that uses cl-base64 to switch
ebrasca has quit [Remote host closed the connection]
narimiran has joined #lisp
orivej has joined #lisp
aartaka_d has joined #lisp
dbotton has quit [Quit: This computer has gone to sleep]
karlosz has quit [Remote host closed the connection]
aartaka has quit [Ping timeout: 260 seconds]
dbotton has joined #lisp
mankaev has quit [Read error: Connection reset by peer]
j0nd0e has joined #lisp
sauvin has joined #lisp
mankaev has joined #lisp
thinkpad has quit [Ping timeout: 246 seconds]
waleee-cl has quit [Quit: Connection closed for inactivity]
mbomba has joined #lisp
thinkpad has joined #lisp
judson_ has joined #lisp
frodef has joined #lisp
thinkpad has quit [Ping timeout: 246 seconds]
karlosz has joined #lisp
thinkpad has joined #lisp
PuercoPop has quit [Quit: WeeChat 2.8]
Stanley00 has quit [Ping timeout: 256 seconds]
Stanley00 has joined #lisp
andreyorst` has joined #lisp
andreyorst` has joined #lisp
andreyorst has quit [Ping timeout: 260 seconds]
emaczen has quit [Ping timeout: 256 seconds]
dbotton has quit [Quit: This computer has gone to sleep]
msk has quit [Remote host closed the connection]
mbomba has quit [Quit: WeeChat 3.0]
thinkpad has quit [Ping timeout: 256 seconds]
shka_ has joined #lisp
thinkpad has joined #lisp
thinkpad has quit [Ping timeout: 265 seconds]
thinkpad has joined #lisp
rumbler31 has quit [Read error: Connection reset by peer]
rumbler31 has joined #lisp
skapata has quit [Remote host closed the connection]
karlosz has quit [Remote host closed the connection]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
rumbler31 has quit [Read error: Connection reset by peer]
rumbler31 has joined #lisp
thinkpad has quit [Ping timeout: 246 seconds]
gaqwas has quit [Remote host closed the connection]
thinkpad has joined #lisp
liberliver has joined #lisp
iskander- has joined #lisp
iskander has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
heisig has joined #lisp
saganman has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
rgherdt has joined #lisp
iskander- has quit [Ping timeout: 246 seconds]
iskander has joined #lisp
ljavorsk has joined #lisp
attila_lendvai has quit [Ping timeout: 265 seconds]
<shka_>
how quiet
varjag has joined #lisp
anticrisis has quit [Read error: Connection reset by peer]
hendursaga has quit [Ping timeout: 240 seconds]
pankajsg has joined #lisp
<beach>
OK, so here is some food for thought to break the silence... How hard would it be to create a Linux/BSD/whatever "desktop" in Common Lisp?
<beach>
That would involve the window manager (we have two of those I think), a workspace manager, and a bunch of little gadgets like the volume control and stuff like that. And could it be done incrementally, so that one could gradually replace existing gadgets?
<beach>
I am asking because I am tired of the existing "desktops" and I don't see myself improving them, given the language used.
<beach>
Mezzano must have some of that stuff already. How portable is it?
pve has joined #lisp
<frodef>
Does Mezzano do X11?
<beach>
Good question. I don't know.
<beach>
But either way, the display server would have to be isolated from the rest so that it could be easily replaced.
<frodef>
I just submitted a bug report for CL-WHO, is Edi Weiz active these days?
<mfiano>
No, infact he recommends people to use other libraries, as cl-who has a lot of bugs and he can't recommend using it (from an email discussion I had with him a few years ago), which is why his book, Common Lisp Recipes, recommends alternatives.
<frodef>
ok thanks. Is there consensus on what is a good alternative for simple html syntax?
<mfiano>
I personally recommend spinneret
<mfiano>
I don't know what others prefer. I don't think there is any consensus
<moon-child>
beach: stumpwm is written in cl
nicktick has quit [Ping timeout: 260 seconds]
madage has quit [Ping timeout: 240 seconds]
Aurora_v_kosmose has quit [Ping timeout: 240 seconds]
ech has quit [Ping timeout: 240 seconds]
gxt has quit [Ping timeout: 240 seconds]
<Cthulhux`>
and it is rather good
ech has joined #lisp
<Cthulhux`>
or you could try exwm which is written in emacs lisp.
<beach>
moon-child: yes, hence "we have two of those". The other one is called Eclipse.
<frodef>
is hunchentoot similarly abandoned?
cyraxjoe has quit [Ping timeout: 260 seconds]
<ralt>
I think it has a new maintainer
ljavorsk has quit [Ping timeout: 240 seconds]
<ralt>
beach: stumpwm is clearly the one that has a community. writing new modules is not too hard.
<ralt>
it starts a server in a thread, and whenever gpg-agent or ssh-agent is trying to grab a key, it hits that server, which draws a new x11 window to ask for your password, and replies to gpg/ssh-agent
ech has quit [Ping timeout: 240 seconds]
<beach>
I guess I should have a closer look at stumpwm.
<frodef>
beach: It does look very interesting, and pretty much what you originally suggested?
<beach>
That would be great, if so.
<pranavats>
beach: There's also EXWM which allows one to manage X windows using Emacs, in case you are interested in extending "desktop" using Elisp.
<beach>
Thanks, but no, not really. I would like to see it in Common Lisp.
VincentVega has joined #lisp
<beach>
So if everything is done with the keyboard, how do I get applications like the one that lets me slide little pictures of my monitors to determine their relative position? I think I am saying that I am not sure that all mouse-based applications should be banned.
<frodef>
Spinner apparently won't do the syntax ((:sometag :someattr value) <content>), only (:sometag :someattr value <content>), which means source code formatting/indenting is not great at all...
<frodef>
...any tips/experiences with this? Is there some slime integration etc?
<frodef>
s/spinner/spinneret/
igemnace has quit [Ping timeout: 260 seconds]
Lord_of_Life has quit [Excess Flood]
Nilby has joined #lisp
Lord_of_Life has joined #lisp
nmg has left #lisp ["ERC (IRC client for Emacs 27.1)"]
ljavorsk has joined #lisp
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
larme has quit [Quit: WeeChat 2.3]
larme has joined #lisp
<VincentVega>
Hi, all! Is there a way define a setf which would work like this https://pastebin.com/bB8kHwSu ? I was thinking of defining a slot named approximate-x but that seems hackish since I don't really need an extra slot, just the setf capability.
<phoe>
VincentVega: new-value goes first
<phoe>
it'll work afterwards
<VincentVega>
oh me
<VincentVega>
thanks, man
igemnace has joined #lisp
<flip214>
Is there an easier way than my own DEFCLASS* so that the accessors by default modify an object referenced by a special variable? Like with HUNCHENTOOT:HEADERS-IN* and similar.
<beach>
What makes them accessors if they don't modify the class instance?
<shka_>
beach: i was thinking about this myself
<shka_>
i mean, DE in lisp
<flip214>
they read and write _a_ class instance still, just a "default" instance if none is given
<dbotton>
To not have tons of symbols in a let describing a GUI form
<pranavats>
dbotton: (let ((a 5)) a (let ((a 4)) ...))
<Alfr_>
dbotton, your (create-form-element f1 :submit :value "OK") might get collected, like beach said.
cage_ has joined #lisp
Bahman has quit [Quit: Connection closed]
thinkpad has quit [Ping timeout: 256 seconds]
<dbotton>
It is ok in this case if collected
thinkpad has joined #lisp
<dbotton>
The actual Lisp side after creating the elements on the browser side are not needed. In fact unless I actually need to set a property or event or need request a property value the Lisp side no longer matters
<nwoob>
mfiano: I commented out loading of theme in .emacs and now without theme syntax highlighting loooks like this https://ibb.co/nsHt6SV
<dbotton>
But I'll document it all that in the tutorial before writing the next one.
<Alfr_>
dbotton, you may wish to have a look at LTK's with-widget macro. I think it deals with the same problem for using tcl/tk.
<dbotton>
Appreciated I'll take a look
gareppa has joined #lisp
jeosol has joined #lisp
<beach>
dbotton: Most people who say what you did mean "standard object"
<dbotton>
So I would say just object or should I say standard object?
a0 has joined #lisp
<beach>
"object" means "any Lisp datum" as the Common Lisp HyperSpec explains.
lucasb has joined #lisp
<beach>
"standard object" is what you typically get when you instantiate a class defined using DEFCLASS.
<charles`>
the problem with highlighting builtin functions is the almost everything becomes highlighted. there is nothing to differentiate, builtin macros like loop, if, and let should be highlighted
<shka_>
yeah,
<shka_>
after years of programming i just accepted that I am getting information overload way quicker then i would like to admit
<charles`>
nwoob to get that level of syntax highlighting requires just a little regex
<charles`>
it seems that basically you want all functions to be colored, and all non function symbols to be colored a different color
<nwoob>
yes charles`
devon has quit [Remote host closed the connection]
<charles`>
do you know about add-font-lock-keywords emacs function?
<nwoob>
no i don't have knowledge about elisp
<charles`>
I believe that is what you are going to need. You will need regexes to identifiy all macro forms where you can define variable, let, destructuring bind, multiple value bind, loop and select variable names, then a regex to select function names, maybe also in flet and labels
eliteuwmyp has joined #lisp
<nwoob>
I will search on this function and try to write regex
<nwoob>
thanks for guiding
<nwoob>
:)
<charles`>
You can use M-x regex-builder to test the regex since emacs-lisp regex is not pcre
<charles`>
I might actually work on this since I'm slightly interested
eliteuwmyp has quit [Read error: Connection reset by peer]
<charles`>
and it will help to use groups to select the variables
Cymew has quit [Ping timeout: 260 seconds]
frodef` has joined #lisp
judson_ has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
frodef`` has joined #lisp
frodef` has quit [Ping timeout: 240 seconds]
matryoshka has quit [Read error: Connection reset by peer]
matryoshka has joined #lisp
gareppa has joined #lisp
ebrasca has quit [Read error: Connection reset by peer]
devon has joined #lisp
matryoshka has quit [Read error: Connection reset by peer]
matryoshka` has joined #lisp
Lord_of_Life_ has joined #lisp
gareppa has quit [Remote host closed the connection]
frodef``` has joined #lisp
thinkpad has quit [Ping timeout: 246 seconds]
Lord_of_Life has quit [Ping timeout: 264 seconds]
Lord_of_Life_ is now known as Lord_of_Life
luckless has quit [Ping timeout: 240 seconds]
VincentVega has quit [Quit: Connection closed]
frodef`` has quit [Ping timeout: 264 seconds]
ggole has quit [Quit: Leaving]
thinkpad has joined #lisp
luckless has joined #lisp
Aurora_v_kosmose has quit [Ping timeout: 240 seconds]
eden has quit [Ping timeout: 240 seconds]
ech has quit [Ping timeout: 240 seconds]
eden has joined #lisp
Aurora_v_kosmose has joined #lisp
andreyorst has quit [Ping timeout: 256 seconds]
jeosol has quit [Quit: Connection closed]
ukari has quit [Remote host closed the connection]
aorst is now known as andreyorst_
ukari has joined #lisp
jeosol has joined #lisp
ech has joined #lisp
l1x has joined #lisp
sauvin has quit [Read error: Connection reset by peer]
VincentVega has joined #lisp
thinkpad has quit [Ping timeout: 246 seconds]
rumbler31 has quit [Read error: Connection reset by peer]
borodust has quit [Remote host closed the connection]
nwoob has left #lisp ["Killed buffer"]
devon has quit [Ping timeout: 256 seconds]
rumbler31_ has joined #lisp
rogersm has quit [Quit: Leaving...]
devon has joined #lisp
secretmyth has joined #lisp
elimik31 has joined #lisp
elimik31 has quit [Read error: Connection reset by peer]
heisig has quit [Quit: Leaving]
ebrasca has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
xificurC has joined #lisp
<xificurC>
Reading the iterate docs I hit into this: "There is one crucial difference between using a the form and actually declaring the variable: explicit declarations are always placed in the generated code, but type information from a the form is not turned into an actual declaration unless you tell iterate to do so using iterate:declare-variables". What
<xificurC>
is then the actual difference of using `declare` and `the`?
judson_ has joined #lisp
mindCrime has joined #lisp
[d]_ has quit [Remote host closed the connection]
luni has joined #lisp
TMA has joined #lisp
<Alfr_>
xificurC, (iter (for (the fixnum i) :below 7)) would not expand to something declaring i to be a fixnum, whereas (iter (for (the fixnum i) :below 7) (declare (iterate:declare-variables))) would.
<Alfr_>
xificurC, but in iterate's case the iterate macro walks its body forms and in some places treats the THEs specially, mainly providing appropriate initial values instead of nil and declaring the types.
narimiran has quit [Ping timeout: 256 seconds]
<xificurC>
Alfr_ yes I read that but didn't completely grok it. Re-reading the fourth time it seems to suggest it is merely a type-check, but if the type doesn't match the consequences are undefined
shka_ has quit [Ping timeout: 264 seconds]
<Alfr_>
xificurC, the special operator is more like a promise to the compiler that what form returns is of that type. I don't think there's a requirement to type check. And yes, it's ub when you break your promises.
<aeth>
xificurC: afaik, in general, THE counts as a type declaration of sorts and so should behave similarly to DECLARE. It will check, ignore, or assume the type. Only the last one is problematic.
<aeth>
In general, you should only see that last case with (safety 0)
<aeth>
(I mean, it's entirely UB, but those are the only three possibilities you'll see in practice)
<xificurC>
Alfr_ OK, if it's a promise to the compiler, how is that different from a declaration? Is there a runtime difference you can tell/show me?
<xificurC>
I'm trying to differentiate the two
<aeth>
ITER's THE appears to be different, perhaps just a concise way to declare?
<Alfr_>
xificurC, I don't think there is any.
<aeth>
Usually, you'd use THE in place of DECLARE if you don't want to have to name it as a variable first, e.g. (the fixnum 42) but the example of the (the fixnum i) is declaring a new binding rather than using the value of i.
<Alfr_>
aeth, and specifying the initial binding for the variable to be of the appropriate type.
<aeth>
Alfr_: yes, but that should be redundant with a DECLARE
<xificurC>
the docs say there's a *crucial* difference, which seems to suggest I'm missing something. Also, if there isn't any difference, why does `iterate:declare-variables` exist?
luna_is_here has quit [Read error: Connection reset by peer]
<Alfr_>
aeth, iterate usually generate (let ((i nil)) ... (setf i -1) ...] .
<aeth>
the more I learn about iterate, the less I like it :-)
dbotton has quit [Quit: Leaving]
luna_is_here has joined #lisp
<Alfr_>
aeth, I mean that w/ initial binding.
<aeth>
I don't like how any advanced usage of LOOP is going to be indented poorly because it's not s-expression-based (even with the SLIME extensions... try to do a complicated nested conditional), but, wow, iterate makes mistakes that come up in #lisp all of the time
<Alfr_>
aeth, it also parses declare forms in its body, so it's not that bad.
<xificurC>
aeth what are those mistakes
<xificurC>
also, I'm still not sure why does `iterate:declare-variables` exist if you claim there's no difference to `the` and `declare`
<Alfr_>
xificurC, shorter hand I think and the THEs only take effect if declare-variables is declared.
<Alfr_>
short*
Cymew has quit [Quit: Konversation terminated!]
[d] has joined #lisp
borodust has joined #lisp
<aeth>
xificurC: in general, it tries to be too smart, see: above
xificurC has quit [Quit: Connection closed]
<saturn2>
THE only promises what the type will be at the moment a particular form is evaluated, DECLARE promises a variable will always have a particular type where the declaration is in scope
frodef``` has quit [Ping timeout: 246 seconds]
wsinatra has quit [Quit: WeeChat 3.0]
Krystof has joined #lisp
surabax has quit [Quit: Leaving]
orivej has joined #lisp
mmmattyx has quit [Quit: Connection closed for inactivity]
cage_ has quit [Quit: Leaving]
mmmattyx has joined #lisp
aartaka_d has joined #lisp
l1x has quit [Quit: Connection closed for inactivity]
frodef has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
<aeth>
saturn2: right, but you can kind of think of THE as the LAMBDA to DECLARE's DEFUN
<aeth>
sort of, because, yes, SETF kind of ruins that illusion
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
aartaka_d has quit [Ping timeout: 240 seconds]
pillton has joined #lisp
kaftejiman has quit [Remote host closed the connection]
judson_ has joined #lisp
akoana has joined #lisp
pve has quit [Quit: leaving]
PuercoPo1 has joined #lisp
PuercoPop has quit [Ping timeout: 256 seconds]
dbotton has joined #lisp
caret has quit [Quit: Leaving]
PuercoPo1 has quit [Ping timeout: 246 seconds]
PuercoPo1 has joined #lisp
anticrisis has joined #lisp
also_uplime has quit [Quit: quit]
PuercoPo1 has quit [Ping timeout: 246 seconds]
Steeve has quit [Quit: end]
Steeve has joined #lisp
Steeve has quit [Client Quit]
PuercoPo1 has joined #lisp
nicktick has quit [Ping timeout: 246 seconds]
nicktick has joined #lisp
<fiddlerwoaroof>
Xach: I must have misremembered an old blogpost or something
<fiddlerwoaroof>
I vaguely remember someone talking about loading every system distributed with Quicklisp into a single image as a sanity check of sorts
amb007 has quit [Read error: Connection reset by peer]
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
amb007 has joined #lisp
nicktick has quit [Ping timeout: 256 seconds]
nicktick has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
lotuseater has quit [Remote host closed the connection]
lotuseater has joined #lisp
frodef has quit [Quit: ERC (IRC client for Emacs 26.3)]
frodef has joined #lisp
PuercoPo1 is now known as PuercoPop
v88m has quit [Read error: Connection reset by peer]
v88m has joined #lisp
luni has quit [Quit: Connection closed]
Blukunfando has quit [Ping timeout: 264 seconds]
<Xach>
fiddlerwoaroof: many have tried. it is a fool's errand. not possible.
nicktick has quit [Ping timeout: 265 seconds]
<fiddlerwoaroof>
Xach: makes sense, I'd be interested in a "stable" dist that only accepts pure lisp packages (no FFI) that can be loaded together
<fiddlerwoaroof>
I've occasionally tried to figure out how to host my own diet, for reasons, but never really seriously enough to have anything to show
dbotton has quit [Quit: This computer has gone to sleep]
<Xach>
fiddlerwoaroof: i had hoped that dists would be very common, with people hosting lispworks-only software, or other thematic dists, but a combination between a lack of interest and a lack of documentation and probably other factors has made it not happen yet
<Xach>
i think a pure-lisp dist would be quite interesting
iskander has quit [Ping timeout: 246 seconds]
iskander has joined #lisp
sjl has quit [Ping timeout: 264 seconds]
<charles`>
I would think if you were a company writing internal libraries you would want to host your own dist for those.
igemnace has joined #lisp
iskander- has joined #lisp
<aeth>
fiddlerwoaroof: pure-lisp wouldn't be as interesting as zero-foreign-dependency
iskander has quit [Ping timeout: 264 seconds]
<aeth>
fiddlerwoaroof: there is a distinction... outside of systems with X Windows (where CLX exists and can use the protocol), you can't do anything graphical without some degree of FFI
<aeth>
But if someone made a graphical toolkit on top of just the OSes themselves, then it would be useful.
<Xach>
aeth: what is the distinction between pure lisp and zero foreign dependency?
<aeth>
Xach: basically, OS and graphics drivers as the only dependencies
<Xach>
charles`: sometimes it's just easier to have a git repo for that
<Xach>
aeth: that's neither pure lisp nor zero foreign dependencies?
<aeth>
Xach: Sorry, I'm unclear, I mean zero distributed foreign dependencies. So if someone wants to just wrap the WinAPI, then that should be OK, to complement something like CLX, but OS-agnostic.
<aeth>
As opposed to something like cl-sdl2 where you have to have SDL2, a giant C dependency, at some point.
<Xach>
Oh. Well, I'm thinking of users with semi-exotic platforms, where binding to some "it's installed everywhere! (if you use linux/windows/macos)" is a failure
<Xach>
so pure lisp is a true advantage
<aeth>
Yes, but it also means no portable graphical apps, since most platforms don't have X
<Xach>
it doesn't mean anything of the sort
<Xach>
having a curated dist available does not prevent you from using more than one dist
gaqwas has quit [Ping timeout: 256 seconds]
<Xach>
you are allowed to have multiple categories of things in use