<nij>
fiddlerwoaroof: Hmm.. I'm not sure what you mean. Isn't guix only in charge of getting the dependencies? We can then load the dependencies in a running repl like we usually do, without turning the repl off.
<nij>
The problem is, guix can get you many different "versions" (written in hash) of CL-systems with the same name. So whatever function you used to "load" (e.g. asdf:load, ql:quickload) should be aware of that. But I don't think it's terribly hard to make that "load" function behave accordingly.
<nij>
I'm really just trying to change the usual version to hash. So instead of hello-2.10, I think it's better to have 0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i-hello-2.10.
aeth_ has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
amb007 has joined #lisp
lotuseater has quit [Quit: ERC (IRC client for Emacs 27.2)]
hjudt has joined #lisp
mindCrime_ has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
cchristiansen has quit [Read error: Connection reset by peer]
cchristiansen has joined #lisp
CL-ASHOK has joined #lisp
CL-ASHOK has quit [Ping timeout: 240 seconds]
psilotorp has joined #lisp
LispSporks has joined #lisp
psilotorp has quit [Ping timeout: 245 seconds]
psilotorp has joined #lisp
psilotorp has quit [Ping timeout: 250 seconds]
frost-lab has joined #lisp
psilotorp has joined #lisp
karlosz has joined #lisp
psilotorp has quit [Ping timeout: 250 seconds]
Spawns_Carpeting has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
Spawns_Carpeting has joined #lisp
aeth has quit [Ping timeout: 260 seconds]
aeth has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
bilegeek has joined #lisp
jlf has joined #lisp
nicktick has joined #lisp
orivej has joined #lisp
Josh_2 has quit [Ping timeout: 260 seconds]
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
Oladon has joined #lisp
Aurora_v_kosmose has quit [Ping timeout: 240 seconds]
Aurora_v_kosmose has joined #lisp
CrazyPython has quit [Ping timeout: 260 seconds]
prxq_ has joined #lisp
nicktick has quit [Ping timeout: 240 seconds]
prxq has quit [Ping timeout: 246 seconds]
LispSporks has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
CL-ASHOK has joined #lisp
CL-ASHOK has quit [Ping timeout: 240 seconds]
monolithic has quit [Remote host closed the connection]
<beach>
Good morning everyone!
hineios has quit [Read error: Connection reset by peer]
hineios has joined #lisp
<nij>
Good morning beach.
Bike has quit [Quit: Lost terminal]
psilotorp has joined #lisp
psilotorp has quit [Ping timeout: 276 seconds]
nij has quit [Quit: 1]
nij has joined #lisp
karlosz has quit [Quit: karlosz]
Jachy has joined #lisp
karlosz has joined #lisp
Bike has joined #lisp
<fiddlerwoaroof>
nij: my hope is to come up with a way to specify a set of git repositories to clone and generate an ASDF configuration from, all within lisp
<nij>
pjb: Would you mind explaining a bit how it reltaes? And if you think it makes sense to merge this into asdf?
bilegeek has quit [Quit: Leaving]
<pjb>
nij: oh, you mean a configuration for asdf, not an asd file? I thought you meant the later. That code reads lisp sources (notably defpackage forms), and generate file dependencies. This could be used to generate asd files.
<pjb>
nij: but if you just want to generate an asdf configuration the problem is simplier.
nij has quit [Ping timeout: 246 seconds]
<pjb>
I thought you wanted com.informatimago.common-lisp.make-depends.make-depends:generate-asd
<lukego>
luis: If CLIM feels heavyweight maybe an alternative solution could be a slimmed down CLIM? Maybe it even already exists e.g. an ASDF system within McCLIM that loads what we need for Emacs but not other parts e.g. X11 and PDF backends. The more I play with McCLIM lately the more it feels like the core APIs don't require /that/ much machinery.
aartaka has joined #lisp
aartaka_d has joined #lisp
waleee-cl has quit [Quit: Connection closed for inactivity]
aartaka has quit [Ping timeout: 260 seconds]
<fiddlerwoaroof>
nij: you get version pinning with my sample by specifying a git hash
<fiddlerwoaroof>
pjb: the code I shared clones the specified git repositories and generates and ASDF configuration that makes them loadable with load-systems, I think it's slightly different from what you're sharing
<fiddlerwoaroof>
lukego: isn't part of the issue with SLIME just that it has to be careful about depending on libraries that might conflict with the user's projects?
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
<fiddlerwoaroof>
I wonder if there's some-way to use the mechanism it has for picking sbcl/ccl/lispworks backends to also allow us to use mcclim if it's already been loaded
contrapunctus has joined #lisp
zacts has joined #lisp
karlosz has quit [Ping timeout: 265 seconds]
engblom has joined #lisp
<engblom>
Is it possible to compile a standalone binary? (asdf:make :my-project) is not standalone, as it still requires that all dependencies are installed.
<fiddlerwoaroof>
engblom: what do you mean by "dependencies"?
<fiddlerwoaroof>
Shared libraries?
Bike has quit [Quit: Connection closed]
<pjb>
engblom: you can save an executable image that contains all the dependencies, so standalone.
<pjb>
(apart of course, shared libraries).
<pjb>
engblom: in the case of ecl, it's different, since it generate elf binaries. But you can do essentially the same, for lisp dependencies.
<splittist>
lukego: I'll try not to go crazy (with the bit)
<pjb>
engblom: with ecl, the trick is to pass :monolithic t to asdf:make-build.
<splittist>
I seem to remember that refactoring the clim asd/loading mechanism was on a roadmap somewhere (possibly even as 'done'). If you don't need the font/CLX stuff then it's already pretty lightweight. And it's virtually nothing compared to the giant piles of js every tab in your browser is loading for no apparent reason.
<engblom>
fiddlerwoaroof: Lets say you have a project that got dependencies on a few library. When doing (ql:quickload :my-project), quickload will pull down all dependencines. If you then do (asdf:make) you get a binary, but it does not contain those libraries so if you move it to another computer it will not run
<engblom>
I meant (asdf:make :my-project)
aindilis has quit [Ping timeout: 252 seconds]
<lukego>
luis: current state of "nested presentations" in CLIME: Emacs sees just one image, but the mouse-sensitive presentation regions form a tree, with the innermost ones overriding the outer ones. for now those regions are all rectangles (bounding boxes) but Emacs can do polygons/circles too. if you (accept TYPE) then the non-matching presentations go away and don't occlude the acceptable ones
CL-ASHOK has joined #lisp
mrchampion has quit [Remote host closed the connection]
<engblom>
pjb: I have been using sbcl, but you mean ecl would be better for this?
CL-ASHOK has quit [Ping timeout: 252 seconds]
<White_Flame>
lukego: regarding heavyweight, GUIs really should be heavyweight. Good text support, complex layout, hardware acceleration, nice antialiasing, caching, etc can all be pretty large features that give good quality and offload work from the user. I think it's a resonable tradeoff
<White_Flame>
and IMO making a heavyweight GUI layer is the only way for complex things to run fast
<White_Flame>
(in a general programming sense, not a hpc/gaming sense which tends to seek fixed pipelines for everything)
<lukego>
White_Flame: Fine but in this context Lisp doesn't do that work anyway: it's outputting SVG and Emacs/imagemagick is doing that heavy lifting stuff.
<White_Flame>
and that's a good reuse of heavyweight tools :)
aartaka_d has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
<fiddlerwoaroof>
engblom: all the pure-lisp parts of the dependencies are in the image
<lukego>
more reuse potential would be to port the little bit of Elisp code to Javascript and then have browser-based CLIM too. but that's not really my wheelhouse.
aartaka has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
<fiddlerwoaroof>
What you're probably running into is shared libraries not being present: there's workarounds here (e.g. bundling the .so files with your executable or providing a shell script to install them with apt or various static linking mechanisms) in most cases I find that I can just cut the problematic dependency (osicat is one thing I try to avoid depending on, for example)
cantstanya has quit [Remote host closed the connection]
mathmech has quit [Quit: Lost terminal]
cantstanya has joined #lisp
Sauvin has joined #lisp
<White_Flame>
lukego: yeah, I've been threatening to do something like that for a long time, although I'd likely not go clim
<White_Flame>
the browser languages have a ton of cruft, but also great features & quality of rendering
<White_Flame>
so in my opinion it's something worth taking advantage of
zacts has quit [Quit: bbl]
cchristiansen has quit [Read error: Connection reset by peer]
cchristiansen has joined #lisp
<White_Flame>
(and putting behind a much nicer interface)
anticrisis has quit [Read error: Connection reset by peer]
narimiran has joined #lisp
pjb has quit [Ping timeout: 260 seconds]
anticrisis has joined #lisp
<fiddlerwoaroof>
:(
<nij>
fiddlerwoaroof: Oh yes that's quite neat. That would solved my issue for system fetching.
<nij>
However, while calling the systems as dependencies, can you also pin its git hash?
<fiddlerwoaroof>
Yeah, my code is just a proof of concept, really
Oladon has quit [Quit: Leaving.]
<fiddlerwoaroof>
But, the idea would be to define a specific commit with something like this: (:git "fwoar-lisputils" "https://github.com/fiddlerwoaroof/fwoar.lisputils.git" "751faf8a933f1a7a023945b544f0f1b563964391")
<fiddlerwoaroof>
the :git bit at the beginning lets you also pull down tarballs from an HTTP server or something, the next component is a directory name, then a source url and the commit hash
<nij>
Sounds great. Would it be easy to merge this into asdf?
<fiddlerwoaroof>
I realized at a certain point that it doesn't make sense as part of ASDF
<nij>
@_@?! how so?
<fiddlerwoaroof>
For similar reasons as why Quicklisp isn't part of ASDF
retropikzel has joined #lisp
<nij>
Would you elaborate?
<nij>
(I genuinely hope this issue can be resolved.)
<fiddlerwoaroof>
I think it's basically a good idea to separate the system definition facility from the facility that resolves the systems to urls
<fiddlerwoaroof>
e.g. if I fork CFFI, I should just be able to change the system -> url mapping without having to mess with ASDs or anything
<nij>
Oh. Do one thing and do it well. I see. Yeah I agree with that.
<nij>
Hmm.. but how about the dependency calling part?
<nij>
I mean, asdf is the de facto tool to call dependency.
<nij>
And in our case, we do want to call a dependency based on its hash.
<nij>
I don't see how this is orthogonal to what asdf does.
<fiddlerwoaroof>
So, all the code I have does is clone the git repositories to a project-specific directory and configures ASDF's source registry
<fiddlerwoaroof>
ASDF's dependency management handles all the rest
karlosz has joined #lisp
<fiddlerwoaroof>
I haven't thought this through entirely, but I like how ASDF just specifies a list of system names as dependencies
<fiddlerwoaroof>
I also generally just dislike the idea of version pinning: my experience with NPM and Maven has basically convinced me that version pinning just sort of enables dependency churn
<nij>
version pinning has its merit, but it's not complete yeah.
<nij>
If we can specify which dependency to use by the hash of the system, that would be a huge leap.
<fiddlerwoaroof>
I think version pinning trades short-term stability for long-term pain
<nij>
To my best knowledge, asdf doesn't do this yet.
<nij>
fiddlerwoaroof: yeah, I agree too, so let's use this instead: 0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i-hello-2.10.
<fiddlerwoaroof>
If you're forced to upgrade to the most recent release of all your dependencies every time they update, you'll just stop using third party libraries that are inconsiderate about breaking changes
<fiddlerwoaroof>
hsahes don't solve anything here
<nij>
Yep, exactly.
<nij>
Why not?
<fiddlerwoaroof>
Because they still are a form of version pinning
<nij>
At least you know that it works. There's almost no ambiguity.
<fiddlerwoaroof>
To me the only time something like hashes only make sense in CI
<fiddlerwoaroof>
The problem I have with version pinning is that it encourages you to not upgrade your code to the new version
<nij>
Another way is accretion, but that requires the whole community to acknowledge.. so I think hash pinning is one of the best practical ways so far.
<nij>
fiddlerwoaroof yeah hash pinning isn't perfect, but it's better than what we have now.
<fiddlerwoaroof>
I just have a rule: if a library makes too many breaking changes, I either fork it or I write my own version of the library
<nij>
fiddlerwoaroof that makes the next potential contributor's life harder..
<nij>
They would have to trust that you would maintain your, now personal, libraries well.
<fiddlerwoaroof>
It makes it easier because they don't have to deal with a maintainer that is inconsiderate of the library's users
<nij>
It makes your work easier, but it's stopping other to contribute..
<nij>
With hash-pinning, a build either works or not works. If it works, people can rebuild it with confidence.
<nij>
I think it makes a huge difference!
<no-defun-allowed>
How much do you pin?
<nij>
no-defun-allowed me?
<no-defun-allowed>
I am mostly unaware of any dependency pinning techniques, as libraries I use don't make breaking changes apparently. But it seems like you would have to pin everything in the general case.
CL-ASHOK has joined #lisp
<fiddlerwoaroof>
That's more or less standard practice in Java, npm, etc.
<no-defun-allowed>
Say, if a kernel changed the syscall interface, then code might not work. Or do you pin the kernel version?
<fiddlerwoaroof>
That's how you get containers
<fiddlerwoaroof>
Although, Linux's stated policy is "don't break userspace"
<no-defun-allowed>
Suppose most libraries don't make syscalls themselves, sure.
<no-defun-allowed>
I thought the policy was that Mauro had to shut up.
<fiddlerwoaroof>
no-defun-allowed: a nice thing about Linux is that Linus is pretty adament of not breaking syscalls, iiuc
<moon-child>
most userspace libraries break all the time, making the kernel policy not _super_ useful
<fiddlerwoaroof>
Yeah, which is where nix-ish package managers is helpful
<no-defun-allowed>
fiddlerwoaroof: Yes, my argument rests on unlikely circumstances. Though using *BSD or some other weirdo not-macOS-or-Linux Unix clone is an unlikely circumstance that some #lisp participants take part in.
<fiddlerwoaroof>
but, the stable syscall API means that containers are usually sufficient as opposed to VMs
<moon-child>
java/npm practice is to pin major version, but allow updates to minor versions. The theory being that minor versions will not break compatibility but major versions may. From what I can tell this works out ~~alright in practice
<fiddlerwoaroof>
no-defun-allowed: I use macOS, and Apple likes breaking userspace :)
<moon-child>
fiddlerwoaroof: or, more to the point, static linking
<fiddlerwoaroof>
moon-child: however, everyone ends up using package-lock.json which forces dependencies to have the correct hash
<fiddlerwoaroof>
maven's version conflict resolution algorithm is "pick an arbitrary version and hope it works"
<fiddlerwoaroof>
Which works surprisingly well, until you run into something like a transitive dependency on five different incompatible versions of Guava
johannes_ has joined #lisp
<nij>
no-defun-allowed: uh I think hash pinning can only guarantee reproducibility in terms of building.
<fiddlerwoaroof>
My experience with npm and java/clojure has lead me to think that _not_ pinning and just fixing breakage as it comes up ends up being better
<nij>
If the program is calling something else in run-time, then there's no way.
<fiddlerwoaroof>
Because it helps discourage breaking changes
<nij>
fiddlerwoaroof how do java/clojure community do? They explicitly ban any sort of pinning?
<fiddlerwoaroof>
No, Java does more or less standard semver pinning, for the most part
<nij>
I've heard of Hicky's idea on accretion. But I don't know how they force people to use that method.
<fiddlerwoaroof>
You end up with million-line codebases stuck on a 10 year old version of hibernate because it would take a week to upgrade
<fiddlerwoaroof>
And, the solution is generally to use CI tooling (e.g. Dependabot on Github) that automatically bumps the version whenever a new version of a dependency is released
<fiddlerwoaroof>
Clojure is a bit more like CL, though: most Clojure libraries I used are safe to upgrade and even go years without active maintenance because they're considered "done"
shka_ has joined #lisp
<jackdaniel>
lukego: you probably only need to depend on the system #:clim
gaqwas has joined #lisp
gaqwas has joined #lisp
cchristiansen has quit [Read error: Connection reset by peer]
cchristiansen has joined #lisp
cchristiansen has quit [Read error: Connection reset by peer]
cchristiansen has joined #lisp
andrei-n has joined #lisp
<moon-child>
the erlang creator once proposed--not entirely seriously--I think--but who knows-- a scheme where libraries would be obviated and functions would be identified exclusively by hash
<fiddlerwoaroof>
Nix does this, a module is basically just a function (although you can use imports to specify default argument values), and I think this sort of parameterized module system solves a lot of problems
gaqwas has quit [Ping timeout: 240 seconds]
<moon-child>
I thought nix operates on the level of whole libraries, not individual functions?
<fiddlerwoaroof>
I'm talking about the modules inside the nix language
<moon-child>
(and indeed, I don't know how you could do the latter unless the language were built for it, in the face of e.g. global variables)
<fiddlerwoaroof>
Which makes it really easy to spin custom versions of an expression
<engblom>
I saw Clojure and libraries being mentioned and there is one thing I think Clojure does better: When creating a new project all dependencies are pulled into the project folder and you specify exactly what version of the libraries you want to use. Like that you can ensure your application will compile even if the upstream library would be completely rewritten. But of course it put some responsibility on the
<engblom>
developer to bump the versions (and lein plugins can help you do that).
CL-ASHOK has quit [Ping timeout: 260 seconds]
<beach>
engblom: How does it handle the situation where two applications need different versions of the same library, and the two versions can't coexist in the same image?
<fiddlerwoaroof>
Unless you're doing fancy classloader stuff that few people actually does, Maven has a rule for resolving the conflict
<fiddlerwoaroof>
not Maven, aether
<fiddlerwoaroof>
it's basically pick the version closer to the root of the dependency tree
CL-ASHOK has joined #lisp
<beach>
I can't see how you can simultaneously respect the exact version that has been specified, and resolve the conflict by picking a different version.
skapata has quit [Quit: Hi, I'm a quit message virus. Please replace your old quit message with this one and help me take over the IRC world.]
<fiddlerwoaroof>
Of the languages I've used, only Javascript solves that problem
<fiddlerwoaroof>
The way modules work, a single module can be included multiple times with multiple versions
<fiddlerwoaroof>
And each dependency gets exactly the version it depends on
<fiddlerwoaroof>
I think Racket/various Schemes might also have a solution here, but I've never used them enough to find out
<engblom>
beach: You probably mean "one application need different versions of the same library". I have never tested that, so I do not know how that works. If two separate applications need the different versions that is no problem.
<fiddlerwoaroof>
engblom: I'm a bit surprised you haven't run into this. I've never worked on a substantial Clojure project that didn't have issues with version conflicts among the transitive dependencies
<engblom>
fiddlerwoaroof: The projects I have done in clojure are smaller, and often raspberry pi related, or some other small tools. I am the author of https://github.com/engblom/gpio which is a gpio library written in Clojure.
<luis>
lukego: slim-clim could work! re presentations, I have an optimisation that I want to commit (dropping overlays) that I might need to coordinate with you
<engblom>
fiddlerwoaroof: I have plans to make a gpio libary in CL, once I get time. The better startup time of CL is the motivation. Clojure takes a lot of time to start up on rpi.
<fiddlerwoaroof>
That's a very familiar complaint :)
<luis>
moon-child: if Linux didn't commit to not breaking user-space containers would be much less reliable wouldn't they since they share the host kernel
cosimone has joined #lisp
Lord_of_Life has quit [Read error: Connection reset by peer]
<engblom>
The Clojure library I wrote is using /sys for handing gpio. As it is on its way to get deprecated, I will make the CL library using some kind of ffi instead.
<beach>
engblom: No, I meant two different applications, running in the same image.
<beach>
engblom: The way I (and I assume many others) think of the Common Lisp image is that it replaces the operating system as a launcher of applications, so I want to have all my applications in one image, and I start them from the REPL.
<fiddlerwoaroof>
Yeah, that model mostly doesn't exist in Clojure
<beach>
engblom: Otherwise, if you are doing individual Unix executables, you deprive yourself of the more closely collaborating applications you can have when you run them all in one image.
<beach>
fiddlerwoaroof: Thanks, that explains it.
Lord_of_Life has joined #lisp
<jdz>
fiddlerwoaroof: What do you do when a library fixes critical security issues, but only in the maintained newer incompatible versions?
anticrisis has quit [Read error: Connection reset by peer]
<beach>
engblom: In other words, you probably wouldn't want to do something that you just described in Common Lisp.
<fiddlerwoaroof>
jdz: depends on the issue and the strategy
<beach>
... unless, of course, you are using first-class global environments and put each application in a separate first-class global environment.
<fiddlerwoaroof>
Oftentimes I just go the route of writing my own X, in which case there's no guarantee I'm affected. But, you can also backport/etc.
<fiddlerwoaroof>
beach: Java has classloaders (and more complicated things like OSGi) that are roughly in the same solution space as first-class global environments
<jdz>
fiddlerwoaroof: And any way you look at it, the "feature" of keeping and depending on exact versions of some libraries is not actually a feature, but a misfeature? And the real issue is breaking changes.
<fiddlerwoaroof>
There's a build tool for Clojure called "boot" that uses them to acheive the sort of isolation necessary
<beach>
fiddlerwoaroof: Oh, OK.
<MichaelRaskin>
I think there was a ELS talk that just renaming packages strategically works well enough in practice to load multiple versions of the same thing
<fiddlerwoaroof>
jdz: yeah, version pinning makes it easier for library maintainers to introduce breaking changes
<beach>
MichaelRaskin: I guess that would work. Was the talk this year? I guess I missed that aspect of it.
<MichaelRaskin>
Nope, a few years ago let me look up
<beach>
Whew!
<fiddlerwoaroof>
And, IMO, you generally want to set up the incentives to shift the cost of a breaking change more towards the library's maintainer
<jdz>
fiddlerwoaroof: Of course everybody wants to do that, because the then don't have to pay.
<jdz>
The sad story of open source.
<fiddlerwoaroof>
Well, if you think about it, library -> user is a one to many relationship
<jdz>
Too bad there's mostly no user --[ money ]--> library relationship.
<fiddlerwoaroof>
Breaking changes in most systems are externalized from the maintainer onto the end-developers
<MichaelRaskin>
Library -> users actually beneficial to the library is not always as obviously a one to many relation
<MichaelRaskin>
Not necessarily beneficial in money. In any way
<fiddlerwoaroof>
So, in terms of total cost, moving the cost of breaking changes away from the users lowers the total effort that goes into maintaining the language's ecosystem
Nilby has joined #lisp
<fiddlerwoaroof>
JS is sort of a nightmare here because there's so much churn that old libraries often just don't work
<beach>
MichaelRaskin: Don't worry about looking up the paper. I think I understand the idea.
<fiddlerwoaroof>
jdz: also, dropping maintenance of a library and releasing a new library under a different name is acceptable to me
<fiddlerwoaroof>
it means that if someone steps up to maintain the old library, they aren't competing with the new version
<jdz>
fiddlerwoaroof: Sure. My argument (and experience) is that library version pinning is a double-edged sword.
cranium_ has joined #lisp
<fiddlerwoaroof>
(that is, they don't have to deal with the backporting issues as much)
<fiddlerwoaroof>
Yeah, I may have an overly negative view of it because of the issues I've encountered of being stuck with obsolete versions
<fiddlerwoaroof>
Ultimately, I don't like practices that favor short-term development speed over long-term maintenance cost
<MichaelRaskin>
To be fair, as underlying implementations have no explicit goal to break everything twice a year (unlike Chromium), Common Lisp packages are typically not too prone to breaking changes, unless they are FFI wrappers of something constantly-breaking
<fiddlerwoaroof>
The thing I appreciate about CL is that my code stays as broken as I left it, for the most part
<beach>
MichaelRaskin: Thanks! Looks good.
CL-ASHOK has quit [Ping timeout: 252 seconds]
psilotorp has joined #lisp
<fiddlerwoaroof>
I've experimented with the technique in that paper before
<fiddlerwoaroof>
renaming packages works surprisingly well, most of the time
<MichaelRaskin>
beach: notice that speaking of multiple applications, package name conflicts are not the only problem in practice, say, on SBCL
<fiddlerwoaroof>
I think identifiers being objects rather than strings makes a big difference here
imode has quit [Ping timeout: 252 seconds]
<MichaelRaskin>
Well, if strings were patchable (like library references in ELF), it would also be not too bad to brute force…
surabax has joined #lisp
<MichaelRaskin>
fiddlerwoaroof: re: churn — I guess people who value active maintenance regardless of presence of reported bugs or whatever are succesfully filtered out by the stuck standard (which could benefit from maintenance but there is no clear path to do it…)
psilotorp has quit [Ping timeout: 250 seconds]
<fiddlerwoaroof>
Yeah, I like the stuck standard, all things considered :)
<fiddlerwoaroof>
Interestingly, I think linux control groups enable you to namespace things like ports and other system resources on a thread-by-thread basis
hiroaki has quit [Ping timeout: 260 seconds]
<fiddlerwoaroof>
I wonder if that could be leveraged to eliminate othe issues with multiple applications in the same lisp image
<beach>
MichaelRaskin: What are some of the other problems?
varjag has joined #lisp
zacts has joined #lisp
<MichaelRaskin>
fiddlerwoaroof: I don't like that we do not have any surviving venue to centrally recognise something the definitive list of minor mistakes in the standard, or something like that
<fiddlerwoaroof>
MichaelRaskin: yeah, although I think the compatability-library route like bt and usocket is fairly successful
<MichaelRaskin>
beach: I think I have tried to run StumpWM as just another thread in an image with an interactive REPL; I remember StumpWM doing interesting things with error handling globally
CL-ASHOK has joined #lisp
<beach>
I see.
nij has quit [Quit: #emacs]
<beach>
So we definitely need first-class global environments. :)
<MichaelRaskin>
Don't forget to include memory management as a part of a global environment
<fiddlerwoaroof>
beach: one of these days I've been planning to look into your "virtualization" technique you've mentioned a couple times
<fiddlerwoaroof>
The one you use for bootstrapping SICL
<beach>
MichaelRaskin: What aspect of memory management would that be?
<moon-child>
MichaelRaskin: hmm. I think your memory management structure looks a bit like a lattice in that case
<Nilby>
I run multiple applications in the image, but I try to avoid FFI except at the kernel level, and I try minimize dependencies.
<beach>
fiddlerwoaroof: It is still not very well documented.
<moon-child>
because you want both an environment-local and a thread-local cache, to optimize locality and reduce contention
<MichaelRaskin>
beach: well, depends on what happens when something tries to allocate too much…
<beach>
Ah, yes, that one.
<fiddlerwoaroof>
I'd like to see a lisp that tried to implement per-thread GCes
<Nilby>
But sadly I still have to "reboot" the image more than I would like.
<beach>
fiddlerwoaroof: That's the plan for SICL, but maybe you knew that.
<lukego>
I'd like to see a lisp that tried replacing threads with some proper way to do concurrency/parallelism :)
<MichaelRaskin>
fiddlerwoaroof: compatibility libraries are somewhat «worse than Javascript» in the sense of recognising just the implementation name and dispatching on that
<fiddlerwoaroof>
beach: I think so
hiroaki has joined #lisp
<MichaelRaskin>
So, a new implementation needs to be mentioned everywhere even if it mimics one of the existing ones (but different ones for different things)
<fiddlerwoaroof>
Yeah, although trivial-features could help with that
jrm2 has joined #lisp
<MichaelRaskin>
And, a very low level change an implementation can leave a wrapper without a good response to support both versions (see hu.dwim.walker)
jrm has quit [Ping timeout: 246 seconds]
jrm2 is now known as jrm
<Nilby>
lukego: What's a proper way?
<fiddlerwoaroof>
Isn't that sort of cupposed to be handled by manipulating *FEATURES*
<splittist>
My vision for the spec would be: 1. an acknowledged starting point - dpANS (+ issues); 2. a community-developed and recognized 'notebook' (for replication) that transformed that source material into 3. a canonical object representation (with spec-specific objects like 'glossary reference', 'return value', 'chapter'); and 4. as many output formats as folks wanted to create from that object representation - a pretty PDF
<splittist>
for printing; a pretty PDF for reading on devices; my-kewl-html version; your-kewler-js version; etc. etc.
engblom has quit [Changing host]
engblom has joined #lisp
<lukego>
Nilby: exactly! that's the right question to be asking :-)
<MichaelRaskin>
lukego: proper for _what_ underlying substrate?
nostoi has joined #lisp
<fiddlerwoaroof>
Most of the concurrency features I'm aware of are layered on top of threads
<Nilby>
I use thread pools with lparallel a lot, and run applications in threads from the repl.
<fiddlerwoaroof>
With maybe delimited continuations mixed in
nij has joined #lisp
<Nilby>
I have a sort of job control in the repl.
White_Flame has quit [Ping timeout: 250 seconds]
cchristiansen has quit [Read error: Connection reset by peer]
<lukego>
Maybe I'm channeling Graydon Hoare but for me if there are threads and shared state on the bottom layer then I don't want to even try building something reliable. Just too many things that can go wrong in too many places. This is the main reason I wouldn't even want a Lisp Machine if there was a modern one.
cchristiansen has joined #lisp
<fiddlerwoaroof>
It seems to me you're always going to have that, though
<lukego>
(Maybe I should be aware of the irony of typing that sentence on a Linux machine.)
<fiddlerwoaroof>
unless you're going to start from the processor
<no-defun-allowed>
Hm, yes, Graydon Hoare. Famous for avoiding mutable state. And making a language which attempts to make mutable state safe.
<MichaelRaskin>
fiddlerwoaroof: trivial-features would need to grow a decimal order of magnitude to approach being an answer to anything
<fiddlerwoaroof>
:)
<no-defun-allowed>
One of those parts is sarcastic. Guess which.
<lukego>
fiddlerwoaroof: okay, sure. but you can put in hard boundaries. Linux kernel-user barrier contains the threads there for example. Likewise BEAM. The application code is not exposed to the underlying shared memory threading at all.
<fiddlerwoaroof>
I dunno, I like being able to cross that layer :)
cchristiansen has quit [Client Quit]
<nij>
fiddlerwoaroof: I still don't see what the drawback of hash pinning is..
<fiddlerwoaroof>
Lisps are all about not having that sort of hard boundary between the system-designer and the end developer
<lukego>
fiddlerwoaroof: Yeah. I am usually that guy too, enthusiastically embracing features that scare off other people, but not on threads. I just say no.
<Nilby>
I do think if there was a Lispy way to properly optionally isolate threads / resources, that would be good.
<nij>
With that I can just call any library I like out there, without worring its updateing, no?
<lukego>
fiddlerwoaroof: Yeah. And I appreciate that about Lisp. But it's also the reason I wouldn't want to do too much important work inside a Lisp image.
<fiddlerwoaroof>
The thing is, if you have the necessary primitives, I think it can be mostly safe?
<no-defun-allowed>
But even Haskell and Clojure people don't complain about software transactional memory.
nicktick has joined #lisp
<fiddlerwoaroof>
I think you basically just need CAS and a thread pool
<fiddlerwoaroof>
(unless you're doing really low-latency stuff that I try to avoid)
<moon-child>
there's a simple solution you're all missing
<moon-child>
global interpreter lock!
<nij>
fiddlerwoaroof: Say my program depends on xad..aslkjd-hello-2.10, it it's updated I don't really have to care.
<fiddlerwoaroof>
That's a big part of the reason why, when I left Python, I didn't settle on Ocaml, Ruby, Node, etc...
<fiddlerwoaroof>
moon-child: ^
<no-defun-allowed>
"When I said 'falliable shared state', the 'falliable' was in massive sarcasm quotes. I could take a bath in this stuff. Put it on cereal, rub it right into my eyes. Honestly, it's not deadly at all... to me."
<moon-child>
;)
<lukego>
fiddlerwoaroof: I have plenty of scars from production outages on "mostly safe" systems though. even BEAM we once spent a whole week chasing a production problem that turned out to be a C routine calling a non-reentrant libc function and this routine just happening to be exercised by more threads on this particular deployment. that was standard file I/O code in BEAM that had been written years before with the bug dormant
<lukego>
fiddlerwoaroof: but lparallel seems really awesome to me. I understand that it can coordinate a bunch of forked lisp images each producing partial results. that's that kind of stuff I like.
<Nilby>
I've hard crashed linux, bsds, macos using sbcl :o
retropikzel has quit [Ping timeout: 250 seconds]
CrashTestDummy2 has joined #lisp
<no-defun-allowed>
In my opinion, you can try to do a supervisor tree-type thing with shared state by treating anything which touched that state as faulty and restarting it. But it is just an opinion as I haven't worked on my supervisor tree-type thing implementation for ages.
<fiddlerwoaroof>
lukego: I think the thing is I've tended to design around immutable state anyways
<lukego>
Nilby: but everyone is different. I don't write multithreaded applications and I don't write string processing code in C. beyond that I am game for most things :)
<fiddlerwoaroof>
So, I just treat threads as cheap processes
<lukego>
I only like immutability if it's real. Not just a quasi-immutable layer as a leaky abstraction. That's also why I'm not really interested in clojure.
<fiddlerwoaroof>
See, I only care about immutability as a property of an API
<fiddlerwoaroof>
because it's always an abstraction over mutable memory locations :)
<lukego>
but sorry I am sure that if we scrolled back 15 years in the channel log I would have said all of these things before ad naseum so I will put a sock in it now :)
<no-defun-allowed>
Perhaps you can rationalise that by saying "well, a shared mutable object is just a cheap poorly synchronised faux-process, so the same rule applies for when a process you need crashes".
<MichaelRaskin>
lukego: I also like false branches of if really not being executed and definitely not leaking data, but well…
CrashTestDummy3 has quit [Ping timeout: 260 seconds]
<fiddlerwoaroof>
Yeah ever since Spectre, I've just assumed that computers are broken from bottom to top
<moon-child>
only since spectre?
<moon-child>
what about rowhammer?
<fiddlerwoaroof>
Good point
<Nilby>
fiddlerwoaroof: They really are, especially when you consider all the crap hiddnen in firmware, and microcode.
<engblom>
And even without spectre, I consider OS broken. As any bigger OS is written in C/C++, I can not trust them.
<MichaelRaskin>
Rowhammer is just too much cost cutting with clear remedy that costs not too much
<fiddlerwoaroof>
Yeah, Spectre is a bug in the spec for a CPU
<MichaelRaskin>
Speculative execution is something people discussed making safe for a decade (always failing to find a convincing solution), Intel saying that nah it's all safe, then Meltdown
<engblom>
I can not trust anything that is written in a language not taking care of memory management. In any bigger project there are 100% sure bugs because of bad memory management.
<no-defun-allowed>
I usually don't mess up with shared mutable state (which is mostly immutable except for concurrent hash tables, queues, etc, sure). And, while I am never going to test it, my coping mechanism suggests that I would mess up synchronisation about as much with CSP or actors or whatever else.
<moon-child>
MichaelRaskin: rowhammer and spectre are both the result of side channels--that is, details which were not correctly modeled
<MichaelRaskin>
moon-child: Row-hammer is a result of cost-optimising a known trade-off
<fiddlerwoaroof>
My impression, though, is that rowhammer isn't an issue in the design of memory, it's a result of memory manufacturers being cheap
<lukego>
splittist: I'm learning a lot of CLIM-fu from your examples! I had no idea about stuff like FORMATTING-TABLE as seen in https://snipboard.io/Z84UlJ.jpg. I must be reading the wrong parts of the manuals.
<MichaelRaskin>
Like, it is well known you need to refresh charges, it is well known if you do not do it enough you get noise…
<moon-child>
yes, but presumably they had sufficient refreshes to get sufficiently good reliability for non-pathalogical/malicious scenarious
<moon-child>
in many cases, to exploit rowhammer you needed to explicitly tell the cpu to flush a cache line to memory. Meaning that with normal cpu memory access patterns the flaw would not have been exploitable
<moon-child>
s/the flaw would not have been exploitable/bitflips would not have generally occurred/
<moon-child>
*pathological. It's late, I shouldn't be writing
White_Flame has joined #lisp
<nij>
Hello! Is there a de facto way to compute a fingerprint of a CLOS object? I want to get the hash of an asdf system.
<nij>
Hopefully this can be the first step to introduce the guix's way into CL. I'll see.
<no-defun-allowed>
Usually you just hash all the source code.
OlCe has joined #lisp
<beach>
nij: The term "CLOS object" is meaningless. Every Common Lisp datum is an object, and every object is an instance of some class, and all classes are part of CLOS.
<nij>
Hmmm I thought we went through this last time beach. I wasn't pretty convinced that the class named T as an object is an instance of some class in CLOS.
<nij>
no-defun-allowed I don't want a minor change in the source code to change the hash.. e.g. (1 2 3) and ( 1 2 3)
<no-defun-allowed>
Oh, for fuck's sake, did you even try to test that?
<moon-child>
nij: 'redundant' rather than 'meaningless', if you prefer
<nij>
system class n. a class that may be of type built-in-class in a conforming implementation and hence cannot be inherited by classes defined by conforming programs.
<no-defun-allowed>
It even says "System Class T".
<no-defun-allowed>
That doesn't leave it open! Seriously, stop trying to sound smart with this.
<no-defun-allowed>
No, it does say "may". Well, it still is an instance of _a_ class.
<nij>
no-defun-allowed I'm not trying to sound smart. I've spent some hours really wanting to get this right. If it's not right, I'm always happy to learn.
<no-defun-allowed>
A further hint is that there are no exceptional situations for CLASS-OF. i.e. any object that is described by the standard has a class.
hendursaga has quit [Remote host closed the connection]
<no-defun-allowed>
Yes, we don't necessarily know which class #.(find-class 't) is an instance of, but it is an instance of SOME class.
hendursaga has joined #lisp
<nij>
But that class (named system class) is not well defined in CLHS, right?
pve has joined #lisp
<no-defun-allowed>
That is what I said, yes.
<nij>
"all classes are a part of CLOS".. is this also right?
<no-defun-allowed>
As I understand it, anything you could call CLASS-OF with is necessarily an object. And CLASS-OF does not signal errors. Ergo, every object is an instance of some class.
<phoe>
no-defun-allowed: t
<phoe>
nij: what does "are a part of" mean in this context?
<nij>
phoe I'm quoting beach's latest comment.
<nij>
(beach I'm not de-valuing your comment. I'm just interested in this and want to get it right.. Thanks for your comment!)
<phoe>
hmmm
<jdz>
nij: Are you now convinced that the "class named T as an object is an instance of some class"?
<nij>
Yes, but not "of some CLOS class", or "of some class as a part of CLOS".
<jdz>
nij: Please name one non-CLOS class.
<phoe>
:D
<nij>
system-class
<jdz>
That's CLOS.
<nij>
Why @_@?
<jdz>
Because anything to do with classes is CLOS in common lisp.
<phoe>
AFAIK sb-pcl:system-class is a subclass of cl:built-in-class which is a part of CLOS
<Nilby>
as usual, it depends on what your definition of is is
<nij>
lol..
<phoe>
like, a standard-defined part of CLOS
<no-defun-allowed>
Well.
<no-defun-allowed>
If we keep calling CLASS-OF with the class of the last object, we will invariably get to STANDARD-CLASS. Is STANDARD-CLASS "a part of CLOS"?
<jdz>
nij: Also, you're a fan of glossary. What is this "CLOS" thing you keep talking about?
<lukego>
splittist: the new CLIME text stuff is all working great on my machine so far! awesome :-) actually it's at the point now where I think I'll write some real application code rather than just throw-away tests
<phoe>
oh wait, no, cl:built-in-class is a subtype of sb-pcl:system-class
<phoe>
I got it the other way
<lukego>
I don't feel ready to attack the Commands / Command Tables stuff yet. have only glanced at that API. need to read and digest a bit.
<nij>
no-defun-allowed: hmmmmm makes more sense to me now. It seems that I was in the pitfall of thinking that a class must be well-defined in CLHS in order to be a CLOS class.
<lukego>
Maybe write some code and come back to that when I have an actual use for it
<jdz>
nij: You said it again. "CLOS class".
<phoe>
nij: well-defined in CLHS, yes
<nij>
jdz: yeah I have no idea what CLOS really is.
<phoe>
every class is an object of class CLASS
<phoe>
which is well-defined in CLHS
nostoi has quit [Quit: Verlassend]
<jdz>
nij: So you've been told to not use the acronym. And you'll notice, that when you drop it, the intended meaning of your sentences does not chaneg.
<mfiano>
This circular conversation could have terminated with AMOP
<nij>
My problem really was on system-class..
<phoe>
a system class is a class like any other, nothing really different about it
<nij>
mfiano: in #clschool beach told me that AMOP might not be fully compatible with CLHS. So I'm afraid no..
<jdz>
nij: It's quite interesting to see you randomly pick which advice to follow.
<nij>
phoe: hmm what makes it special is that CLHS leaves system class as an implementation dependent thing? But it's still a class in CLHS.
<mfiano>
That's why we have c2mop
<phoe>
nij: what do you mean, still a class in CLHS
<nij>
jdz: I mean I'm just a curious noob that tries to learn. I will keep updating my knowledge if there's a chance.
<jdz>
nij: So you claim, but your behavior tells a different story.
<nij>
phoe by that I mean it is still an instance of the class named CLASS, according to CLHS.
<phoe>
nij: all classes are instances of the class named CLASS
<phoe>
there are absolutely no exceptions
<phoe>
a system class is a CLASS that is allowed to be a BUILT-IN-CLASS, that's all
ljavorsk has joined #lisp
<nij>
jdz: How so? Err.. I'm sorry if I act differently than my word. That would be off-topic, but I'm open to talk about it in another place! I'd be grateful if you could point it out.
undvrainbowvita8 has quit [Ping timeout: 240 seconds]
<jdz>
nij: If you were curious and wanted to learn, you'd just go and read AMOP, and then come back and ask more informed questions.
amk has quit [Read error: Connection reset by peer]
<nij>
phoe I see. Thanks :)
amk has joined #lisp
<nij>
jdz: Why is AMOP relevant here? I thought we were talking about CLHS..
<phoe>
nij: AMOP tells a story about how to implement CLOS
<jdz>
nij: No, the topic is "CLOS" and your insistence on using that acronym.
<phoe>
like, on a lisp that does *not* have CLOS
<phoe>
and since classes are an integral part of CLOS, it also teaches about how to make classes work
<nij>
phoe: I thought that's just a way to implement CLOS..?
<phoe>
nij: what is just a way to implement CLOS?
<nij>
AMOP
fitzsim has quit [Remote host closed the connection]
<phoe>
AMOP is a book that contains a description of how to implement CLOS and also has an example simple implementation of CLOS called Closette
<nij>
jdz: I see. I had the mis-impression that CLOS is the object system described by the common lisp standard.
<nij>
Thanks for your patience jdz phoe. My blindspot was that I falsely insisted on that a well-defined concept in CLHS must be implementation independent.
<phoe>
what exactly do you mean by a "well-defined concept"
<jdz>
Good. Hopefully we all learned something new today.
<phoe>
if CLHS defines that something must be true, then every implementation must follow this in order to conform to it
<zacts>
what is CLHS?
<phoe>
if CLHS defines that something *may* be true, then implementations are free to do whatever
<phoe>
zacts: the online rendition of the CL standard
<lukego>
splittist: How do you judge that :HUGE is the appropriate text size for a short string inside a 100x100 square? text sizing is a bit of a mystery to me
* lukego
realizes he has not read the relevant part of the CLIM docs and goes to do that
eta has joined #lisp
silasfox has quit [Client Quit]
<jackdaniel>
the mapping between keywords and sizes is quite arbitrary
v88m has quit [Ping timeout: 246 seconds]
<jackdaniel>
it is meant as some semantic sizing that adapts to the underlying port
<lukego>
Seems that you can also provide a point size but what does that mean in terms of pixels and/or normal CLIM geometry?
masp has quit [Quit: Konversation terminated!]
<jackdaniel>
that said it is possible to specify the size in a number
<lukego>
Just now for example I'd like to draw a string centered in a circle and I'd like for ~ 10 characters to fit before spilling out of the sides. is there a good way to specify that?
<jackdaniel>
currently it means em on 72dpi (so if you have 144 dpi screen, then it will be twice as large as it should be)
<lukego>
or in splittist's example - what you care about is the size of the lambda relative to the size of the rectangle
masp has joined #lisp
<jackdaniel>
say you have text style size 10. then you call text-size on your string with that text style, that gives you metrics for the string
<jackdaniel>
and then you may multiply the text style size to match that
<jackdaniel>
having a pixel-perfect match would require a fixed font
<jackdaniel>
otherwise you have things like kerning and different character widths/heights in a way
<lukego>
I'm not looking for exactness here though, I'd like to e.g. just say how wide an M should be in pixels or something. I'll draw a thousand circles, labelled with a string in the middle of each, and aesthetically I'd like them all to be the same size and "not too many" of them to spill out
<jackdaniel>
as I said, there is a function text-size to asses the size
<jackdaniel>
it returns couple of values, so it is possible to determine pixel-perfect bounding box of the particular text, or the size in font metrics (height = ascent+descent, width = left-bearing + text-width + right-bearing)
<lukego>
ok. I was kind of hoping for a (with-font-height (10 :units :pixels) ...) or something but it sounds like such a beast could be written based on these apis
<lukego>
s/pixels/current geometric units/
CL-ASHOK has quit [Ping timeout: 252 seconds]
<lukego>
I'm tempted to use CLIM's nice utility functions for drawing tabular data but since this is CAD data I need to be careful e.g. about one unit == one millimeter and can't really rely on automatic sizing of anything but decorations like labels
silasfox has joined #lisp
<jackdaniel>
also, regarding the text, you may also scale it it fit inside something
<jackdaniel>
text then is, well, scaled (i.e may have distorted dimensions)
<lukego>
narrator: He had already made up his mind to hard-code a magic number because it sounded too complicated.
<_death>
apparently presentation translators are not invoked when typing something for accept? mouse battery died..
<nij>
I'm about to push a repo to quicklisp. It requires me to test it on at least to implementation. How should I do that? Or if anyone can help? Thanks :)
<jackdaniel>
_death: I think that you are right, translators are checked for the pointer input
<phoe>
nij: do you have tests for your code?
<jackdaniel>
I'm not sure what the spec says about string input to accept
<phoe>
can they be run via asdf:test-system?
<jackdaniel>
nij: by "test" it means that you ensure that it runs at least on two implementations
<jackdaniel>
that is a proof of somewhat attainable portability
<jackdaniel>
so run it i.e on sbcl and on ccl, if it works on both then you should be good to go
<nij>
I've only worked with sbcl before. Not really sure how to test it on another implem.
<jackdaniel>
I believe that this is the intention of this requirement
<splittist>
nij: you can get a docker image with lots of implementations specifically for this purpose
<nij>
phoe, sure, tested on sbcl and it returns T
monolithic has joined #lisp
<phoe>
nij: I mean, it returns T by default, like, always
<phoe>
the question is - does it run your test suite?
<nij>
"Fourth, make sure it builds with ASDF.." What does it mean by "builds"? I've put my repo in local-projects, and loaded with (ql:quickload..) successfully. Does that count?
<Xach>
nij: it means asdf is the way the project's structure is defined and loaded.
<Xach>
nij: it has an .asd file, and doesn't require outside asdf to load the project
<Xach>
some projects require extra steps, like running ./configure or setting environment variables etc, and those are not compatible with quicklisp
<nij>
Yes, then I think that's fine. There's no ./configure or anything like that. Just a plain .asd file.
<nij>
I better learn the testing part carefully tomorrow. After that I'll try to raise an issue. :-)
CL-ASHOK has joined #lisp
rodriga has joined #lisp
srandon111 has joined #lisp
srandon111 has left #lisp [#lisp]
edvardo_ has joined #lisp
CL-ASHOK has quit [Ping timeout: 268 seconds]
yoonkn has joined #lisp
silasfox has quit [Quit: ERC (IRC client for Emacs 27.2)]
silasfox has joined #lisp
<edvardo_>
Why is the standard way to perform recursion in the lambda calculus the Y combinator instead of Lf.Lx.f f x?
<phoe>
edvardo_: I don't know if #lisp is a good forum for mathematics
<nij>
Maybe ##lisp is what you are looking for, edvardo_
<phoe>
lukego: nice!!!
<nij>
oh cool lukego
ljavorsk has quit [Ping timeout: 260 seconds]
<frgo>
lukego: That is so very cool and awesome. Keep going!
<lukego>
Here's where I'll need good zoom support though. In each of those little circles I want to be able to write a label like "MGTVCCAUX_RS" and that will take some extra pixels :-) but I'm hoping that since this is vector graphics (SVG) that scaling can just be done locally by Emacs at arbitrary magnification without bothering Lisp for a new version.
<lukego>
Gonna also need a convenient way to toggle viewing the latest CLIM presentation in a full screen window
<lukego>
Maybe actually zooming could be done in such a dedicated buffer/window with a specialized keymap
* lukego
checks what Emacs's existing SVG viewer mode has to offer
<Shinmera>
Is there a relatively supported vector graphics format that's not insane like svg?
<phoe>
nope, you need to make one
<luis>
phoe: does CCL have a default method for file-position like SBCL used to?
<phoe>
you could name it Shinmera's Vector Graphics, for short - svg
<jackdaniel>
I don't understand what's insane in embedding a programming language in the vector graphics format
<jackdaniel>
;)
<luis>
phoe: thanks
<phoe>
Shinmera: :D
<phoe>
luis: same for fundamental output streams
<White_Flame>
Shinmera: there's always PDF ;)
<lukego>
Shinmera: I don't think Gerber would qualify..
<jackdaniel>
coreldraw format has a nice extension: cdr :)
<White_Flame>
swf is somewhat supported, but I think that's more turning into "was"
<_death>
postscript maybe
<Shinmera>
Yeah PS probably comes the closest.
<White_Flame>
still a programming language, though ;)
<Shinmera>
Right
<White_Flame>
that just happens to have graphics side effects sometimes
<frgo>
Yep, PS. Also good for printing.
<Shinmera>
SWF iirc also has a JS precursor thingy so
<Shinmera>
anyway, good news is that the SF3V is not useless!
<Shinmera>
Bad news: I need to make it happen
<luis>
phoe: thanks
<White_Flame>
does Cairo have some file format for graphics, or is it all function call based?
mrchampion has joined #lisp
nij has left #lisp ["#lisp"]
nij has joined #lisp
gxt has quit [Remote host closed the connection]
gxt has joined #lisp
<jackdaniel>
White_Flame: it may be serialized to uchar* but there is no format specification
<jackdaniel>
and deserializing data requires specifying the format, width and height
xkapastel has joined #lisp
CL-ASHOK has joined #lisp
aartaka_d has quit [Ping timeout: 260 seconds]
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 260 seconds]
CL-ASHOK has quit [Ping timeout: 252 seconds]
Lord_of_Life_ is now known as Lord_of_Life
cer-0 has joined #lisp
pjb is now known as Guest15098
Guest15098 has quit [Ping timeout: 260 seconds]
cosimone has quit [Remote host closed the connection]
Sheilong has joined #lisp
cosimone has joined #lisp
pjb has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
<etimmons>
nij fiddlerwoaroof : Both CLPM and Qlot can do version pinning, including of git repos.
aeth has quit [Ping timeout: 252 seconds]
<etimmons>
I think the best solution to version pinning encouraging not updating is to make a regular CI job that updates and runs tests for you. That's trivial with CLPM, I assume it is with Qlot as well
Bike has joined #lisp
aeth has joined #lisp
<etimmons>
nij: I'm not entirely sure about what you want regarding <hash>-hello-2.10. But presumably if you really want such a scheme to be reproducible, you need some service to distribute those hashes as well, no?
orivej has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 26.3)]
<etimmons>
Does anyone have tools they use to help ensure license compliance when distributing Lisp executables?
<etimmons>
I've been accumulating ad-hoc procedures and scripts, but would very much like to use something else if it already exists
<jackdaniel>
I did something similar in one gig - traversed asdf dependency tree and printed system names and licenses to a csv file
<jackdaniel>
sjl had something in his scripts afair
<etimmons>
Did you deal with reproducing copyright statements? ("Redistributions in binary form must reproduce the above copyright notice [...]")
<etimmons>
That seems to be the tricky part, especially given the lack of such an explicit copyright statement in many CL projects
silasfox has quit [Ping timeout: 276 seconds]
<jackdaniel>
no, I was putting them in predefined license categories (using spdx identifiers) and acted on that. custom licenses were not accepted into dependencies
<jackdaniel>
(if a particular string was not recognized, then the debugger popped out so I could add it manually and use that from then on)
<etimmons>
That's a requirement from BSD license, though. MIT has something similar as well.
<jackdaniel>
by "no" I mean that this was not a purpose of the tool. this act was to ensure, that there are no undesired dependencies (direct or indirect), not to decide what should be redistributed
<jackdaniel>
that tool was not redistributed at all (only accessed from the outside)
frost-lab has quit [Quit: Connection closed]
pjb has quit [Read error: Connection reset by peer]
silasfox has joined #lisp
<etimmons>
ah, got ya
psilotorp has joined #lisp
psilotorp has quit [Ping timeout: 246 seconds]
psilotorp has joined #lisp
silasfox has quit [Ping timeout: 260 seconds]
hypercube has quit [Ping timeout: 240 seconds]
layerex has joined #lisp
silasfox has joined #lisp
Inline has joined #lisp
wsinatra has joined #lisp
Inline has quit [Client Quit]
aartaka has joined #lisp
Oddity has quit [Ping timeout: 252 seconds]
cer-0 has quit [Quit: leaving]
CrashTestDummy3 has joined #lisp
CrashTestDummy2 has quit [Ping timeout: 260 seconds]
CrashTestDummy2 has joined #lisp
CrashTestDummy3 has quit [Ping timeout: 252 seconds]
ebrasca has quit [Remote host closed the connection]
fitzsim has joined #lisp
bollet has left #lisp [#lisp]
waleee-cl has joined #lisp
jnewton has joined #lisp
<lukego>
splittist: nice :)
<lukego>
Maybe I need to switch from me 1080p laptop to 4K desktop for Emacs at this point..
<lukego>
or maybe both at once... I see there is `M-x make-frame-on-display'
yoonkn has quit [Remote host closed the connection]
<luis>
lukego: sadly Emacs is not DPI-aware on Windows (hopefully the situation is better on Mac/Linux)
Nilby has quit [Ping timeout: 276 seconds]
<jackdaniel>
I think that Mac requires so many workarounds to make software written for Linux run (and more with each release) that mentioning them together may be slightly misleading
edvardo_ has quit [Quit: Leaving]
fitzsim has quit [Quit: ERC (IRC client for Emacs 27.1.90)]
fitzsim has joined #lisp
<xristos>
Emacs (mitsuharu branch) looks great on macOS, incl hidpi support, double buffering and so on
CL-ASHOK has joined #lisp
pbaille has joined #lisp
cosimone has quit [Remote host closed the connection]
CL-ASHOK has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
<lukego>
I haven't exercised it too hard but I get quite beautiful basic results running Emacs on a 34" 4K display with xrandr dpi option to boost the size way up (uncorrelated with the /actual/ DPI because I am just using it as a magnification knob...)
johannes_ has quit [Ping timeout: 265 seconds]
amb007 has joined #lisp
<lukego>
I'm now imagining that I could edit on my laptop and have the whole 4K screen automatically showing an insanely zoomed-in copy of the most recently selected CLIME image. that could be something :)
<pbaille>
I'm wondering if a lisp can have only quasiquote and no regular quote. What would be the downsides ? (sorry if this message appears for the second time, I can't tell if it was posted or not)
<beach>
Do you mean "no reader macro '", or "no special operator QUOTE"?
<_death>
`(foo ',bar).. you don't need either of course, (list (quote foo) (list (quote quote) bar))
<beach>
I think the former is definitely possible. Not so much the latter.
<phoe>
pbaille: a quasiquote without any unquotes inside is equivalent to a regular quote
<jackdaniel>
mind that quasiquote may allocate new data (hence it is not equivalent, vide ^)
<lukego>
pbaille: Guessing that's fine provided that you use (QUOTE x) instead of 'x. But if you plan to use quasiquote instead of quote it will become confusing in certain kinds of code that uses nested quote/quasiquote e.g. `(foo ',(...)) because more quasiquotes means more levels of unquoting
<pbaille>
yes it is equivalent but why the regular quote is needed , if it is a subset of quasiquote ?
<jackdaniel>
quote is a special operator in common lisp
<jackdaniel>
quasiquote is a reader syntactic sugar (i.e not a special operator)
<phoe>
pbaille: because quasiquote is expressed in terms of quote in CL
<phoe>
if you wanted to avoid this, you'd need to have quasiquote as a special operator of sorts, likely along with unquote
<jackdaniel>
also I think that the proper name is backquote
<pbaille>
Yes I understand, but if someone was creating a new dialect of lisp that only has quasiquote it would be acceptable ?
<phoe>
pbaille: I guess so, yeah
<phoe>
jackdaniel: yes, thanks
<pbaille>
quasiquote is maybe the name in scheme literature
<beach>
pbaille: You still haven't answered my question, because the answer to yours depends on it.
<phoe>
yes, CLHS uses backquote whereas e.g. Racket docs call it quasiquote
<pbaille>
beach: I'm sorry I was a bit distracted, I was meaning no special operator QUOTE
amb007 has quit [Read error: Connection reset by peer]
<beach>
pbaille: Then the answer is that you can't do without it, as lukego pointed out.
<phoe>
pbaille: if you have nothing else that you can replace QUOTE with then you're toast
<pbaille>
(I'm not a CL person (I came from clojure) so I may not understand all CL sutleties)
<phoe>
basically, you need some means of preventing standard evaluation rules from kicking in
<phoe>
regardless of whether it's special operator QUOTE or special operator BACKQUOTE
<phoe>
where "special operator", in CL-speech, means "an operator that does not obey standard evaluation rules and also is not a macro"
<phoe>
basically, you need some primitive that will fulfill the role that CL:QUOTE fulfills in standard CL
amb007 has joined #lisp
<phoe>
if your backquote is such an operator, then bingo, you can implement QUOTE in terms of it
<phoe>
(though it would be kinda backwards)
niflce has joined #lisp
<jackdaniel>
if you implement a "new dialect of lisp" then you don't need quote because you are designing a new programming language
<jackdaniel>
with its own evaluation rules
<jackdaniel>
but you need a PR team that will argue on reddit that your new dialect of lisp is a lisp :-)
<jackdaniel>
(public relations, not pull request)
<pbaille>
jackdaniel: haha yes I see !
<pbaille>
phoe: thank you for the details
<lukego>
pbaille: I think that for some kinds of code you would miss having ' e.g. in macro-writing macros or html-writing macros and such. The simplest example I can think of it (let ((arg 'quote-me)) `(f ',arg)) => (F 'QUOTE-ME). here you want to preserve the quote inside the backquote while unquoting its argument. If you used two backquotes it would be... different.
<lukego>
pbaille: I'm taking your question in the spirit of, "Is quote just there for historical reasons and obsolete with respect to quasiquote?" and the answer to that in practice is no, you want to use both in real programs.
<pbaille>
lukego: Your interpretation of my question is correct
<lukego>
pbaille: I vaguely remember wondering the same thing and being surprised at how useful plain ol' quote turns out to be :)
<jackdaniel>
_death: thanks! looks like an interesting read
<_death>
there are many interesting posts in ll1-discuss
abhixec has joined #lisp
cranium_ has quit [Quit: Leaving]
CrashTestDummy has joined #lisp
imode has joined #lisp
CrashTestDummy2 has quit [Ping timeout: 240 seconds]
MichaelRaskin has quit [Read error: No route to host]
<pbaille>
thank you so much for all your observations on my 'question :) see you next time !
<lukego>
yeah ll1-discuss is where they _finally_ got the right people in the room to settle a bunch of questions that had been a source of flame wars for decades :)
attosaurus has quit [Quit: Connection closed for inactivity]
LispSporks has quit [Ping timeout: 250 seconds]
aartaka has joined #lisp
<_death>
I have it as a gnus-friendly archive, along with cl-su-ai and saildart
luckless has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
luckless has joined #lisp
MichaelRaskin has joined #lisp
luckless has quit [Remote host closed the connection]
luckless has joined #lisp
jnewton has quit [Ping timeout: 246 seconds]
<lukego>
splittist: oh btw I'm churning out little CLIME pictures that have 1500 presentations each and nothing anywhere is breaking a sweat. I can do ACCEPT and pick which of the 1517 little circles I'm interested in
igemnace has quit [Ping timeout: 260 seconds]
igemnace has joined #lisp
gzj has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
john2gb0 has joined #lisp
aartaka has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<splittist>
lukego: awesome. The best kind of software - immediately useful (:
amb007 has joined #lisp
Josh_2 has joined #lisp
gzj has quit [Remote host closed the connection]
gzj 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
rpg has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
SpaceIgor2075 has joined #lisp
SpaceIgor2075 has quit [Remote host closed the connection]
long4mud has joined #lisp
SpaceIgor2075 has joined #lisp
pjb has quit [Read error: Connection reset by peer]
vydd has quit [Ping timeout: 246 seconds]
ecraven has quit [Ping timeout: 252 seconds]
vydd has joined #lisp
SpaceIgor2075 has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
ecraven has joined #lisp
amb007 has joined #lisp
jnewton has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
jnewton has quit [Ping timeout: 252 seconds]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
OlCe has quit [Remote host closed the connection]
OlCe has joined #lisp
jibanes has quit [Quit: leaving]
jibanes has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
jibanes has quit [Client Quit]
amb007 has joined #lisp
jibanes has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
terpri has joined #lisp
dilated_dinosaur has quit [Quit: Leaving]
jnewton has joined #lisp
srhm has joined #lisp
<flip214>
scymtym: re clim.flamegraph branch advice-backend: ; The function CLIM:DRAW-ELLIPSE* is called with odd number of keyword arguments.
terpri has quit [Client Quit]
terpri has joined #lisp
terpri_ has joined #lisp
terpri_ has quit [Client Quit]
<flip214>
and if I choose threads, start/stop without there being any activity, start is MOST-POSITIVE-FIXNUM, end is MOST-NEGATIVE-FIXNUM, and the duration doesn't make any sense ;/
<scymtym>
flip214: let me try to reproduce
dilated_dinosaur has joined #lisp
<flip214>
I just cloned _your_ clim, to be on the safe side ... but ASDF stops because of DRAW-ELLIPSE
amb007 has quit [Read error: Connection reset by peer]
jibanes has quit [Quit: leaving]
<flip214>
*
amb007 has joined #lisp
jibanes has joined #lisp
pjb has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
cage_ has joined #lisp
CL-ASHOK has joined #lisp
amb007 has joined #lisp
<scymtym>
i was going to ask about the DRAW-ELLIPSE error. i cloned everything in a fresh environment and i cannot reproduce that. can you describe in more details what happens?
<flip214>
COMPILE-FILE-ERROR while compiling #<CL-SOURCE-FILE "clim.flamegraph.view" "timeline" "presentations">
<flip214>
; caught WARNING:
<flip214>
; The function CLIM:DRAW-ELLIPSE* is called with odd number of keyword arguments.
jnewton has quit [Ping timeout: 246 seconds]
<flip214>
and the warning seems to be fatal.
<flip214>
If I just comment out the DRAW-ELLIPSE* via #+(or), I can load the advice-backend branch.
OlCe has quit [Remote host closed the connection]
psilotorp has quit [Remote host closed the connection]
<flip214>
(clim:draw-ellipse* stream start end 10 dx 0 0 dy))))
lottaquestions has quit [Quit: Konversation terminated!]
amb007 has quit [Read error: Connection reset by peer]
OlCe has joined #lisp
amb007 has joined #lisp
CL-ASHOK has quit [Ping timeout: 252 seconds]
<flip214>
and trying to use (clim.flamegraph.examples.recording:with-recording () ...) freezes my SBCL so hard that I have to kill -9 it....
<scymtym>
flip214: i see the DRAW-ELLIPSE* problem. can you disable the sprof source in WITH-RECORDING? i was trying to keep up with the upstream sprof changes but i probably messed something up so that it doesn't work with your SBCL version. and you wanted deterministic profiling anyway, right?
<flip214>
yes please, with a side order of reliability
amb007 has quit [Read error: Connection reset by peer]
<flip214>
but WITH-RECORDING is only run _after_ loading, and loading fails because of D-E, so how should that help?
amb007 has joined #lisp
gzj has quit [Remote host closed the connection]
<scymtym>
to be fair, i said "if you feel adventurous …"
<jackdaniel>
Zork II: The Wizard of Frobozz
OlCe has quit [Ping timeout: 252 seconds]
<scymtym>
flip214: i pushed a fix for the DRAW-ELLIPSE* problem
<scymtym>
you could also try disabling the memory source. that one records gc events and memory statistics
Lord_Nightmare has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
orivej has joined #lisp
<flip214>
2.1.3.... will do
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<flip214>
still dead in the water
jnewton has joined #lisp
<scymtym>
i'm building that SBCL version to see what the problem could be
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
u0_a181 has joined #lisp
u0_a181 has quit [Client Quit]
CL-ASHOK has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<flip214>
well, if you use 2.1.4 and it works I'll just upgrade
amb007 has joined #lisp
CL-ASHOK has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
waleee-cl has quit [Quit: Connection closed for inactivity]
abhixec has quit [Read error: Connection reset by peer]
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
rpg 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
silasfox has quit [Ping timeout: 250 seconds]
niflce` has joined #lisp
niflce has quit [Ping timeout: 240 seconds]
jnewton has quit [Ping timeout: 260 seconds]
skapata has joined #lisp
<scymtym>
flip214: in a container, i built SBCL 2.1.3 from source, cloned all libraries from github and tried the example. i can't reproduce the freeze, sorry
notzmv has quit [Ping timeout: 240 seconds]
<flip214>
scymtym: thanks a lot!
<flip214>
well, I could try to use strace.... swank is dead, a new connection doesn't work.
<flip214>
would a gdb trace of all threads help perhaps? Guess that's too noisy...
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
notzmv has joined #lisp
<scymtym>
not sure if that would help. can you try without swank, though?
White_Flame has quit [Remote host closed the connection]
<fiddlerwoaroof>
etimmons: the goal of CLPM to be "A package manager for Common Lisp that strives to cleanly separate the package manager process itself from the client image that uses it." is the opposite of what I want
White_Flame has joined #lisp
<fiddlerwoaroof>
I want all the metadata about the history of an image to be within the image at all times
psilotorp has joined #lisp
<etimmons>
Interesting. What metadata do you want in the image? The main focus of multiple processes in CLPM is to offload things like HTTP(S), git, untaring, etc.
Sauvin has quit [Ping timeout: 240 seconds]
<etimmons>
The metadata that stays in the image is whatever ASDF needs to find the files on the filesystem. But more could possibly be added.
notzmv has quit [Ping timeout: 240 seconds]
rpg has quit [Ping timeout: 268 seconds]
<fiddlerwoaroof>
For one thing, I'd like the information about the origin of a system to be in the repository: git url, commit hash, etc.
<fiddlerwoaroof>
s/repository/image/
jnewton has joined #lisp
<fiddlerwoaroof>
But, also, I like how quicklisp and ASDF pull things that are usually external tools into the image
<fiddlerwoaroof>
Things that go the opposite direction generally seem to be solving problems I don't have
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 260 seconds]
lavaflow has quit [Ping timeout: 265 seconds]
rpg has joined #lisp
hiroaki has quit [Ping timeout: 260 seconds]
aeth_ has joined #lisp
aeth has quit [Ping timeout: 265 seconds]
aeth_ is now known as aeth
niflce` has quit [Quit: ERC (IRC client for Emacs 27.2)]
niflce has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<etimmons>
Yeah, I would love to have easy in-image access to system provenance as well.
<etimmons>
It'd be neat to have an interface defined for that, separate from any particular package manager. If that existed, I'd happily make CLPM expose info via that interface.
<etimmons>
Until then, I'll add exposing it from the clpm-client package to my TODO list.
jnewton has quit [Ping timeout: 252 seconds]
jnewton has joined #lisp
lavaflow has joined #lisp
pbaille has quit [Remote host closed the connection]
shka_ has quit [Ping timeout: 240 seconds]
nij has quit [Quit: #lisp]
cage_ has quit [Quit: rcirc on GNU Emacs 27.1]
masp has quit [Quit: Konversation terminated!]
CL-ASHOK has joined #lisp
jnewton has quit [Ping timeout: 240 seconds]
v88m has joined #lisp
silasfox has joined #lisp
mindCrime_ has joined #lisp
CL-ASHOK has quit [Ping timeout: 240 seconds]
silasfox has quit [Ping timeout: 250 seconds]
mindCrime_ has quit [Excess Flood]
mindCrime_ has joined #lisp
niflce has quit [Ping timeout: 240 seconds]
pbaille has joined #lisp
johnjay has quit [Ping timeout: 265 seconds]
johnjay has joined #lisp
jnewton has joined #lisp
gaqwas has joined #lisp
gaqwas has joined #lisp
gzj has joined #lisp
niflce has joined #lisp
CL-ASHOK has joined #lisp
heisig has quit [Quit: Leaving]
gzj has quit [Ping timeout: 260 seconds]
silasfox has joined #lisp
Krystof has quit [Ping timeout: 268 seconds]
Inline has quit [Ping timeout: 260 seconds]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
actuallybatman has joined #lisp
CL-ASHOK82 has joined #lisp
tmf has quit [Remote host closed the connection]
narimiran has quit [Ping timeout: 265 seconds]
aartaka_d has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
rpg has joined #lisp
silasfox has quit [Remote host closed the connection]
CL-ASHOK82 has quit [Quit: Ping timeout (120 seconds)]
notzmv has joined #lisp
aartaka has quit [Remote host closed the connection]
aartaka_d has joined #lisp
jnewton has quit [Ping timeout: 252 seconds]
Spawns_Carpeting has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
pbaille has quit [Remote host closed the connection]
pbaille has joined #lisp
terpri has quit [Ping timeout: 250 seconds]
<jmercouris>
etimmons: are you the developer of CLPM?
<jmercouris>
I would guess so based on your username
<jmercouris>
I think it would help if you had a little cookbook so people could get started with CLPM
<jmercouris>
I tried following your presentation, but the format was incredibly difficult to follow for me
waleee-cl has joined #lisp
Inline has joined #lisp
aartaka has joined #lisp
CL-ASHOK has quit [Ping timeout: 246 seconds]
CL-ASHOK has joined #lisp
jnewton has quit [Ping timeout: 246 seconds]
CL-ASHOK has quit [Ping timeout: 252 seconds]
terpri has joined #lisp
niflce has quit [Ping timeout: 246 seconds]
hiroaki has joined #lisp
cognemo has quit [Ping timeout: 268 seconds]
Spawns_Carpeting has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
Spawns_Carpeting has joined #lisp
wsinatra has quit [Quit: WeeChat 3.1]
renzhi has joined #lisp
anticrisis has joined #lisp
hjudt has quit [Ping timeout: 265 seconds]
hjudt has joined #lisp
surabax_ has quit [Quit: Leaving]
CL-ASHOK has joined #lisp
torbo has joined #lisp
<etimmons>
jmercouris: I am! And yeah, I really need to make some more accessible resources. I tend to be long winded on things like this. I think the last half of my ELS paper is a decent starting point for "I just want to use CLPM; what do I need to do?"
karlosz has joined #lisp
<MrtnDk[m]>
eric What's stopping you?
cer-0 has joined #lisp
<etimmons>
Time mostly
<MrtnDk[m]>
Ah yea, that darn time.
<etimmons>
'tis a precious commodity
hjudt has quit [Ping timeout: 240 seconds]
skapata has quit [Ping timeout: 260 seconds]
CL-ASHOK has quit [Ping timeout: 240 seconds]
skapata has joined #lisp
pve has quit [Quit: leaving]
ramHero has quit [Remote host closed the connection]
<xristos>
etimmons: some suggestions for clpm, i'd do away with the installation part and have a release be a self-contained single binary I can just drop in my PATH
<xristos>
it can spit out the client library code (if needed) in the same way it spits out configurations
mtd_ has joined #lisp
mtd_ has quit [Client Quit]
<xristos>
a decentralized mode would also be nice, imo centralized package indices are a cardinal sin
<xristos>
something like go get -u <url>
<xristos>
but also having the dependencies be specified as URLs by the package author in the package itself
<xristos>
to avoid the middleman
<etimmons>
It actually can do that! `clpm client cat` spits out the client as a single file.
gzj has joined #lisp
<etimmons>
The 0.4.0 release will be coming Real Soon Now (basically as soon as I get my hands on an M1 - probably ~2 weeks). I can pretty easily publish tarballs and bare executables when I post it
frgo has quit [Remote host closed the connection]
<etimmons>
I'm interested in what you mean by a decentralized mode. The problem with URLs specified by the package author is maybe they're using an old fork of a dep, or I want to use something slightly different.
frgo has joined #lisp
<etimmons>
does go get -u fully implement what you mean? If so, I'll take a look at it
<xristos>
well go package management is decentralized
<xristos>
(with optional centralization)
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
<xristos>
if i publish a library, i specify the packages it uses, their location, their versions and the cryptographic checksums
renzhi has quit [Ping timeout: 246 seconds]
<etimmons>
Hmmm, I've used go only a tiny bit and never really looked at its package management. I'll take a look and try to understand it
<xristos>
so the entire dependency tree is specified by the package author and not looked up at runtime
<etimmons>
But how does it reconcile another library using the same deps with different versions?
<etimmons>
Is go one of those languages where multiple versions of the same package can coexist at runtime?
<xristos>
yes
<etimmons>
ahhh, that explains it
<etimmons>
I'm not sure how to map that to CL. I know there was some discussion earlier about an ELS paper on strategic renaming of packages, but that doesn't seem ready for primetime
<etimmons>
I could forsee clpm easily supporting a mode where the person running clpm could provide sort of a local index that overrode the centralized remote indices, though
<xristos>
i'm not really talking about multiple library versions in the same process
bitmapper has joined #lisp
<xristos>
but for a library author to be able to specify his dependencies (with exact versions and cryptographic sums) as part of the package itself
<xristos>
therefore enabling reproducible builds
<MichaelRaskin>
To be fair, Quicklisp from a fixed distinfo version is no less reproducible
<xristos>
and transparent software provenance without middlemen (thus being able to make guarantees)
<etimmons>
OK, so are you thinking of using this mostly when building applications? And not when using it as a library? Otherwise we'd have to deal with the inevitable case of systems A and B using C, but publishing different metadata about C
<MichaelRaskin>
I would believe in long chains of trust (because that's what you describe) _less_ than a single middleman with enough investment
<xristos>
MichaelRaskin: I'm not sure what you mean by enough investment
<xristos>
Quicklisp has been vulnerable for years for example
<xristos>
I think it still fetches upstream sources from plain http sources
<xristos>
but that's the least of it, the entire model is broken in ways that package management in Go (for example) doesn't suffer from
<xristos>
and that's ok, different tradeoffs
<MichaelRaskin>
Well, I think there are upstreams that do not offer https at all…
<xristos>
i'm not advocating against centralized package indices, but an alternative would be nice and we don't have that for CL
<MichaelRaskin>
An alternative would require buy-in across
<etimmons>
Thanks for the pointer, I was unaware go was decentralized. I'll take a look at it
<xristos>
MichaelRaskin: not really, most folks already publish on github/gitlab and so on
<xristos>
it could be done in a similar way to Go
<MichaelRaskin>
And specify dependencies under assumption of Quicklisp
<xristos>
and people could start using it from day 1
<etimmons>
My personal end goal has been a package index where CL developers could publish their projects at their own pace
<MichaelRaskin>
Well, you can use Ultralisp if you want faster (and less compatibility-tested) updates
pbaille has quit [Remote host closed the connection]
<xristos>
MichaelRaskin: so no buy-in required, folks can keep doing what they're already doing, but now I have the option when writing a new library to specify dependencies in this manner
pbaille has joined #lisp
CL-ASHOK has joined #lisp
<MichaelRaskin>
Specify where?
<xristos>
in my own library
<MichaelRaskin>
As a separate extra metadata file?
<etimmons>
Ultralisp is a step in the right direction, but it still suffers from some Quicklisp flaws (like lack of provenance metadata, system version numbers, and historical releases are difficult to discover)
<xristos>
as a .lisp file that's part of the library itself (equiv to go.mod and go.sum files)
<xristos>
and then folks that want to use it would need a package manager that supports this scheme
<xristos>
which is fine, especially if that package manager came as a single standalone executable
<MichaelRaskin>
… or fork it to make it actually usable with Ultralisp, I guess
<MichaelRaskin>
One thing where we
<MichaelRaskin>
did not have worse than Javascript ecosystem was incompetent vendoring
hjudt has joined #lisp
pbaille has quit [Ping timeout: 265 seconds]
CL-ASHOK has quit [Ping timeout: 240 seconds]
<etimmons>
Fork what to work with Ultralisp?
<MichaelRaskin>
Whatever library specifies dependencies in a unique way and not just as usual ASDF dependencies
<etimmons>
I assumed xristos meant the proposed metadata file would be in addition to ASDF dependencies
<MichaelRaskin>
> and then folks that want to use it would need a package manager that supports this scheme
<etimmons>
I assumed that "use it" referred to the extra security. But I could be wrong
random-nick has quit [Ping timeout: 252 seconds]
hiroaki has quit [Ping timeout: 260 seconds]
<MichaelRaskin>
Sure, it would be nice if Quicklisp included the exact upstrean reference. In Nixpkgs I would probably switch to generating upstream fetches for Common Lisp packages.