Spawns_Carpeting has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
Spawns_Carpetin- has joined #lisp
drl has quit [Quit: Leaving]
TK__ has quit [Ping timeout: 245 seconds]
jnewton has joined #lisp
bitmapper has quit [Quit: Connection closed for inactivity]
yoonkn has joined #lisp
notzmv has joined #lisp
<nij>
pjb: cool tricks! Thanks :-)
pbaille has joined #lisp
Inline has quit [Ping timeout: 260 seconds]
pbaille has quit [Ping timeout: 240 seconds]
Sheilong has quit [Quit: Connection closed for inactivity]
jnewton has quit [Ping timeout: 240 seconds]
akoana has left #lisp [#lisp]
random-nick has quit [Ping timeout: 260 seconds]
jnewton has joined #lisp
Bike has joined #lisp
lotuseat` has joined #lisp
lotuseater has quit [Ping timeout: 250 seconds]
harovali` has joined #lisp
harovali has quit [Ping timeout: 246 seconds]
freshmaker666 has quit [Quit: ZNC 1.8.2 - https://znc.in]
mntee has quit [Quit: bye]
mntee has joined #lisp
mntee has left #lisp [#lisp]
freshmaker666 has joined #lisp
freshmaker666 has joined #lisp
freshmaker666 has quit [Changing host]
<harovali`>
pjb: hi Pascal. I tried twice to build and load cl-charms in two different linux machines. In both I had problems. But the second one is my attempt to have a clean start.
<harovali`>
In my (second) attempt, I'm right now am having this problem loading cl-charms
dbohdan has quit [Read error: Connection reset by peer]
dbohdan has joined #lisp
<pjb>
harovali`: the error seems to be muffled by quickload, Try (asdf:oos 'asdf:load-op :cl-charms)
mindCrime_ has joined #lisp
jnewton has quit [Ping timeout: 265 seconds]
<Bike>
harovali`: grovel errors usually mean you're missing a dependency in my experience, like the curses library. running the command independently might give you a more informative error message
pbaille has joined #lisp
pbaille has quit [Ping timeout: 268 seconds]
<dieggsy>
if i'm live coding a web app with hunchentoot, what's the easiest way (is there a way?) to reload the page in browser from lisp?
<dieggsy>
the workflow of make a change, switch to browser, manually reload, switch back to emacs is a bit jarring
<dieggsy>
er, disruptive idk
long4mud has joined #lisp
<waleee-cl>
dieggsy: if you're ok with an pre-release experience, nyxt can be controlled from emacs
<pjb>
(uiop:run-program (format nil "firefox -remote 'openURL(~A)'" url)) ; in about:config set "browser.link.open_newwindow.override.external" to 1
<pjb>
dieggsy: ^
<pjb>
dieggsy: or (uiop:run-program (format nil "open -a Safari ~A" url)) on macOS.
<pjb>
s/~A/~S/
<dieggsy>
pjb: hmm, e.g. firefox -remote 'openURL(google.com)' seems to do nothing for me
<pjb>
It's really a shame uiop:run-program doesn't take a separate :arguments list. ccl and clisp gave good hints about that!
<pjb>
google.com is not an URL.
Bike has quit [Quit: Connection closed]
<pjb>
the scheme is mandatory: URI = scheme:[//authority]path[?query][#fragment]
<dieggsy>
pjb: hah, i appreciate pedantry as much as the next guy, but at least in the gui firefox doesn't require the scheme, but sure, let's rephrase e.g. firefox -remote 'openURL(http://google.com)' does nothing for me
<pjb>
It has always worked for me when I used linux…
<dieggsy>
when was this? do you know what firefox version it was?
<fiddlerwoaroof>
If the permissions are not part of the pointers to objects, you can have an issue where the pointer's permissions are interepreted differently by different parts of the system
<beach>
OK, I can't understand how this example applies. I think I need a lot more time to digest the information.
xkapastel has quit [Quit: Connection closed for inactivity]
drl has quit [Quit: Leaving]
notzmv has quit [Remote host closed the connection]
<fiddlerwoaroof>
This means (assuming a system with privileged and unprivileged parts) that every time an unprivileged part A communicates with a privileged part B and then receives a response, B has to have logic to determine whether A has permission to receive the response.
<beach>
You see, I don't even know what it means for a "system" to have privileges.
<beach>
I haven't thought things through for CLOSOS, but in Multics, systems don't have privileges; people do.
<beach>
... contrary to Unix.
notzmv has joined #lisp
<fiddlerwoaroof>
I think you can put this in terms of environments, no? A system has a "privilege" to access any object referenced in its global environment, and all the other objects that can be produced by calling some accessible function on htose objects
<beach>
That is not how I have ever thought about privileges, which is why I am totally confused.
jnewton has quit [Ping timeout: 252 seconds]
overy4nder has quit [Remote host closed the connection]
psilotorp has joined #lisp
psilotorp has quit [Ping timeout: 250 seconds]
karlosz has joined #lisp
f1hre has joined #lisp
notzmv has quit [Ping timeout: 240 seconds]
<pjb>
beach: how does the multics system know what person give it a command? What if it's a secretary tha gives a command dictated by the boss?
<pjb>
(both in the case of multics and unix, there's a computer system object that represents the user to manage its priviledges; unfortunately, computers are not smart enough to validate or check that a real alive human being and who he is, is giving it the commands).
<Nilby>
Multics is very cool in many ways, with rings, gates and all, but it's security model might be a bit dated, even if it's certainly better than unix. I'm pretty sure multics had a system call between you opening a file, that told the "operator" to take a tape off the rack on put it on a tape drive. And the open internet was decades away.
<contrapunctus>
beach: good morning. Please have a look ^^ http://ix.io/3mUw
f1hre has quit [Remote host closed the connection]
<beach>
Give me a few minutes...
<beach>
contrapunctus: Thanks. It is going to take me a long time, because I don't have a tools that can diff the markdown and the html. So I think I need to read it word by word and compare.
karlosz has quit [Quit: karlosz]
<beach>
pjb: Programs in Multics refer to objects in the object store (i.e., segments in the segment hierarchy on Multics) symbolically. When a reference to such an object is hit, the dynamic linker is invoked to "snap the link". What the linker does it so check the ACLs in the "object store" and compare them to the user and group executing the code. This comparison results in a capability that has restricted access according to the ACL.
<beach>
The operation is then re-tried on the capability.
nullman has quit [Ping timeout: 240 seconds]
<beach>
So all the objects that a program can refer to are capabilities that have been created by the dynamic linker, so the access privilege is based on the user and the group executing the operation. Not on some concept of a system having the privilege.
<beach>
pjb: Does that make sense.
nullman has joined #lisp
<fiddlerwoaroof>
can programs refer to objects they can't access? and pass those references to other programs?
<beach>
I believe so, yes. But the programs that those objects are passed on to, also execute as the same user and group as the caller.
<fiddlerwoaroof>
So, there's no way to pass an object to a program running as a different user or group?
<beach>
I think that's true.
<beach>
Multics still had a very limited address space.
<fiddlerwoaroof>
I guess that wouldn't have the problem I'm thinking of
<beach>
So pointers were per-process just as with Unix.
<fiddlerwoaroof>
The issue I'm thinking of occurs when two programs communicate and they're executing as different users or groups
<beach>
I am thinking that this is a fundamental difference between Multics and Unix. In Multics, users+groups have privileges. In Unix, programs do too.
<beach>
Yes, I understand.
<fiddlerwoaroof>
program A constructs a reference it can't access (/home/otheruser/secret) and asks B to do something with it. B does something with the path and passes information back to A
<beach>
Well, in Unix, the capability is the file descriptor and it is not valid across processes.
<fiddlerwoaroof>
That's only sort of true: using unix sockets, one program can push a file descriptor to another
<beach>
Oh wow! And the kernel translates it so that it refers to the same object in the new process?
<fiddlerwoaroof>
Yeah
<beach>
That sounds dangerous.
<fiddlerwoaroof>
It's actually safer
<beach>
It is certainly a very different model from what I have been thinking about so far.
<fiddlerwoaroof>
If I push a file descriptor, my permissions are attached to the file descriptor already
<fiddlerwoaroof>
So, if the other program tries to use that file descriptor to read information I don't have access to, it'll get an error
<beach>
I see.
<beach>
Well, that would be similar in CLOSOS, I *think*, because a capability would be a pointer with some access bits, and pointers would be valid everywhere.
dbohdan has joined #lisp
dbohdan has quit [Changing host]
<beach>
So one program would "snap the link" and get a capability that it can then hand over to some other program. The caller's privilege on the object will be reflected in the capability.
<pjb>
beach: it make sense. But it's similar to unix. the access rights of unix objects are some crude a simple capabilities associated to the user ID and group ID (and others).
<beach>
pjb: Yes, I know. Unix was meant to be an "implementable subset of Multics".
<fiddlerwoaroof>
beach: yeah, my thought is that you don't need ACLs at all
<fiddlerwoaroof>
At least, not in the way I usually think of them
<beach>
fiddlerwoaroof: That's the part I don't understand. If I want to put an object in the object store, and I don't have ACLs, what kind of capability do I give it?
<beach>
It seems to me that I would then be forced to give the same access rights to everybody on the system.
<fiddlerwoaroof>
Couldn't you give it a "directory" object and the capability to add directory entries?
<fiddlerwoaroof>
Or whatever makes sense for the store layout in question?
<fiddlerwoaroof>
I guess the capability in sense would just be a pointer to some root object
<beach>
I don't know what a "directory" is, nor a "store layout".
<fiddlerwoaroof>
+ permissions to associate new objects to that root
<beach>
Nor a "root".
pbaille has joined #lisp
<pjb>
You can also play the directory game in unix. Instead of letting everybody access /{bin,usr/bin,…} you can setup /home/$USER/bin/… and prevent users to access anying outside of their /home/$USER.
<fiddlerwoaroof>
The idea is just that the first program that runs has full access to the object store. When it runs another program, it lets that program access the object store by passing an object to it and the capability of executing certain functions that associate other objects to it in the object store
waleee-cl has quit [Quit: Connection closed for inactivity]
<fiddlerwoaroof>
Any object not associated with that object is transient and GCed when the program exits
<pjb>
fiddlerwoaroof: capability based systems work too, indeed. It's only that this may require more work to build those directories. But I guess once it's done automatically, it can be as easy to use as unix.
<beach>
fiddlerwoaroof: So if I create an object, how do I tell this "first program" that I want bill and joe to be able to read and write it, but everyone else just read?
<pjb>
It's clear that this would avoid the PATH=.:… problems.
<beach>
I guess I need to go study how capability-only systems work in more detail.
mbomba has joined #lisp
<fiddlerwoaroof>
beach: that's why I said "not in the way I usually think of them"
<moon-child>
findUser sure looks a lot like an 'open' call
<fiddlerwoaroof>
There needs to be a similar concept when a program is first executed, but the whole idea is to prevent programs from creating pointers the user cannot access.
<beach>
pjb: So every object in the system would be stored in some place associated with each user in the system? That sounds pretty bad.
<pjb>
it's a capability that you must have on the system.
<fiddlerwoaroof>
that is, pointers to objects that the user cannot acess
<pjb>
beach: capability management is finer grained than unix access right, that's for sure.
<moon-child>
pjb: and how do 'you' get that capability? You still need to bootstrap access to something, somehow
<beach>
pjb: And what if I want to give access to every user in the ADMIN group, even though not all users in that group have been created yet?
<pjb>
beach: finer, and more explicit. But that's the point, and this is what help security.
<pjb>
moon-child: somebody needs to give it to you.
<beach>
Do I have to go through every object I ever created whenever a new user is created?
<loli>
don't capability style systems just boil down to lattice structures?
<pjb>
moon-child: there's a system generation phase (kind of compilation-time for the system) where those root capabilities are assigned to some root object that can then distribute them.
<pjb>
beach: basically yes. But there are objects whose job is to automatize that.
<fiddlerwoaroof>
You only have to go through the roots of trust
<beach>
I think I won't be able to understand the ideas here until I read up on capability-only systems.
mbomba has quit [Quit: WeeChat 3.1]
<pjb>
perhaps it would be worth running a capability based system to see how that works.
<Nilby>
I like capability systems. My ideal capability system is: "Can anyone run a program on my computer? No, They can't."
<fiddlerwoaroof>
If a program has access to a particular set of objects and a particular set of functions, it can also access any objects producible by calling some sequence of functions with some combination of the objects
<fiddlerwoaroof>
It's a bit like GC roots and the reachable set
<pjb>
beach: but if you remember multics, on unix when you compile a program, with default UMASK 022, it gets access rights 755 so it's executable by any user that has access to a path to the new program. On multics, cics and other systems of that time, once you had a program compiled, you didn't have anything. You would have to write JCL or use command installation commands to make this program accessible to users as a command.
<pjb>
beach: capability based system require the same administration steps.
<pjb>
Or I guess we could write a (virtual) capability system in lisp, to explore those questions and the user interfaces that are required.
<beach>
I will definitely take the time to read up on capability-only systems. If the security model is simpler or safer, I should understand it better.
<Nilby>
Capability systems seem simpler to understand for users, and simpler to administer, but you still have the problem you have now on phones, where programs can be coercive and demand "give me all these capabilities or I won't even run".
<beach>
Nilby: You seem to be using the word "capability" in a way I don't recognize.
<beach>
I only know the use as "a reference to some object that includes an indication of the kind of access to it that is permitted".
<beach>
So in "give me *this* capability", I don't know what nature *this* would be.
<beach>
It seems it would already have to be a capability.
<fiddlerwoaroof>
Fuchsia too
<fiddlerwoaroof>
(The Fuchsia OS is another new OS based on object capability principles)
<lukego>
splittist, fiddlerwoaroof: I optimized ACCEPT quite a lot in CLIME. It was getting really slow when I had 50K acceptable presentations in Emacs at the same time. Turned out to just be a dumb data structure i.e. the set of acceptable presentations needed to be converted from a list to a hashtable. Emacs profiler is good!
<fiddlerwoaroof>
lukego: cool
<Nilby>
I think of it more like the name of thing that can be done with an object, e.g. "take a picture on the camer"", so in language terms, more like a method combination.
<Nilby>
*camera
jnewton has joined #lisp
<fiddlerwoaroof>
Nilby: I think there's just two different meanings for the word going on here
<beach>
Nilby: But that's not how it is used in the literature.
<fiddlerwoaroof>
capability-based security uses a very specific definition of the term
<splittist>
lukego: yay! Next up - creating an emacs-pane
<lukego>
what's an emacs-pane exactly?
<fiddlerwoaroof>
I'm waiting for Climacs to be embedded in emacs
<fiddlerwoaroof>
:)
<Nilby>
Sorry. Just ignore me.
Nilby has left #lisp ["lossage_handler() returned"]
<lukego>
splittist: btw I think that I gave you commit bits but just do whatever you like e.g. PRs etc. I just don't have my github notifications working very well atm so often miss things for a couple of days before polling
<splittist>
lukego: I haven't done anything recently. I need my other projects to catch up to where I'm really using clime, to see what needs adding. Panes are the substrate for gadgets, I think.
<lukego>
I think maybe next up for me will be trying to do really nice client-side zooming. for CAD stuff I think that I need to be able to easily make presentations scale to fit the available space & be able to zoom in up to about 20x mag
<lukego>
one other random feature I'd like is a (with-output-to-emacs (s :pane :foo :if-exists :overwrite) ...) so that Lisp could assign names to the images and have the option to update them in place
<lukego>
splittist: yeah same here
<lukego>
though the zooming is a pain point now because I'm constantly tweaking (with-scaling ...) to try and see what I need. I think that Emacs image support will make it easy e.g. already supports a fit-width/fit-height/fit-window kind of scaling option and we could hack the "viewBox=..." attribute to crop the region of interest
anticrisis has joined #lisp
<lukego>
but it helps a lot to be able to copy&paste presentations now e.g. because I can do a really big one, put it into a buffer on the side, and not worry about it scrolling off screen in the repl
<splittist>
If you had the raw svg in the emacs-side object, you could just add a scaling transform and re-render.
<splittist>
(Or have a 'Open in Inkscape' option ... )
epony has quit [Quit: upgrade]
karlosz has joined #lisp
epony has joined #lisp
<lukego>
Good ideas :)
<lukego>
Have to think about that Inkscape one in particular. Then I guess I'd want to embed metadata into the SVG about the presentations
hypercube has quit [Ping timeout: 250 seconds]
<lukego>
and that's probably easy to do actually straight on the lisp side
<lukego>
I need to understand if the Emacs image scaling attributes are usable - or maybe better to just always hack the SVG and rerender. Experimentation suggests that Emacs "zoom in" commands on images are raster based i.e. they render the SVG into a bitmap and then scale that into a pixelated blarg
<beach>
fiddlerwoaroof: In a capability-based system, how does a user refer to an object in order to obtain a capability? Do objects have names? If so, who determines tha name? Does every user refer to some object using the same name?
<lukego>
splittist: I'm not ready to think about this yet but besides Inkscape another interesting option could be to open the SVG in a browser and accept callbacks from Javascript. Maybe this could even be driven by Emacs with the browser doing the job of (insert-image (create-image ...)) only.
<beach>
fiddlerwoaroof: Actually, forget about it. I think I will just go think about how it might be done. I suspect the literature excludes the mechanics of of assigning privileges to people and groups of people.
<phoe>
hello
<beach>
Hey phoe.
jnewton has quit [Ping timeout: 268 seconds]
orivej has joined #lisp
notzmv has joined #lisp
<phoe>
beach: AFAIK a capability is just an object that contains 1) an indirection to some other object, 2) some state - simplest state is "on/off", a boolean
<phoe>
and the trick is that you are not allowed to operateon the object directly, you must use the capability object instead
<beach>
That's the third definition of capability today.
<phoe>
and the capability object must be in its "on" state in order for the action to be performable and performed
<beach>
And the second one that does not correspond to the use in the literature.
<contrapunctus>
beach: ^ generated HTML with indentation and whitespace resembling yours, hopefully easier to diff.
<beach>
Plus, that's not what I am asking. I am asking about the mechanics of assigning privileges.
<beach>
contrapunctus: Thanks!
<phoe>
if something in the system turned the object "off", then the action that the capability was created for doesn't happen
<beach>
*sigh*
<phoe>
okay, I'll shut up
<fiddlerwoaroof>
beach: wouldn't one way just be to have a "user" object?
<beach>
What I am asking is this: Suppose I created an object, and I want every system administrator to be able to modify it, but everyone else can just read it. What do I do for that to happen, and what do I write in the email to everyone? "Hi, I just wanted to let you know that you can now do ... to a access my new object."
<beach>
What is "...", and what did I do in order for "..." to be the way to access the object?
pbaille has quit [Ping timeout: 245 seconds]
<fiddlerwoaroof>
One way would be to have an object representing the "admin" group with write-enabled pointers to the resources
<beach>
OK, and how do I "name" it?
<fiddlerwoaroof>
And then you just iterate across the objects representing administrators and associate them with the admin group
<beach>
Hold on...
<beach>
There might be administrators that aren't in the system yet.
<beach>
So there must be a representation for the group as such.
<fiddlerwoaroof>
Yeah, #<user object> -> #<admin group object> -> #<resource>
<beach>
And I still don't know what "..." is. Maybe "Object number 234 in your list of objects you can access"?
<fiddlerwoaroof>
Then #<new user object> -> #<admin group object>
<beach>
Or "object named <some-name>"? How do I prevent myself from removing an existing object with <some-name>"
<fiddlerwoaroof>
Whoever can create new user objects can create the link between the new user and the existing group objects
<beach>
That part is fine.
<beach>
But I don't know what "..." is.
<beach>
What instructions do I write in my email for users to access my object?
<beach>
And how did I make those instructions work?
<fiddlerwoaroof>
Oh, I see, that would depend on the protocols for the object in question, right?
<beach>
The object has to be named in some way. Either, "Bill, it's your object number 234. Joe, yours is object number 34534534...."
<beach>
Or it must have some name that is the same for everyone.
<fiddlerwoaroof>
Why?
<beach>
Should I just put the capability in my email?
<fiddlerwoaroof>
I see, let me think about it :)
jnewton has joined #lisp
<beach>
Or, "Hey everyone. I just created an object that you can use if you like, but this system doesn't allow me to give you instructions how to find it, so you just have to scan the entire object database".
<fiddlerwoaroof>
It seems to me that the protocol for accessing a new resource depends on the type of resource, though
<beach>
Sure. "And you can access the new object using a protocol consisting of functions that are somewhere in the system, but since I can't name them, you need to scan the entire object database"
<fiddlerwoaroof>
The functions would be named by updating a user's environment somehow
<beach>
So me, as the author of an object, would modify the environments of all users who are allowed to access my object?
<beach>
"Hey bill, I put a pointer to my new email program in your environment, and I called it 'hello'. Sorry if you already had an object by that name."
<fiddlerwoaroof>
It seems to me that that problem could be solved by some sort of hierarchy among environments
<fiddlerwoaroof>
Or by coming up with a way to embed the pointer itself in the email
<fiddlerwoaroof>
And letting the recipient name it
<beach>
I specifically do not want hierarchies. The main idea of the object store is that it can be searched by giving a bunch of attributes, like object type, modification date, creator etc.
<fiddlerwoaroof>
As a general principle, the idea of capabilities is to grant access by passing objects around rather than names
<beach>
Yes, that part I understand.
<beach>
What I don't understand is what my choices are for storing objects in a "database" that can be searched.
rgherdt has joined #lisp
cosimone has joined #lisp
<fiddlerwoaroof>
Every user would have some sort of object graph that's reachable from some "root set"
<fiddlerwoaroof>
And that object graph would be the database
<beach>
And it would be per-user?
<fiddlerwoaroof>
The edges might be
<beach>
OK, thanks.
<beach>
I'll give it some more thought.
<fiddlerwoaroof>
I think you'd probably also want to have at least one object in the root set that represents the user
<beach>
Sure. What I absolutely wanted to get away from is the concept of a "path", because it imposes an order that is usually not relevant.
<fiddlerwoaroof>
The email question has the issue of figuring out distributed identity
<beach>
Like in /home/beach/Lisp/Papers/gc.pdf and /home/beach/Papers/Lisp/gc.pdf.
<fiddlerwoaroof>
Yeah
<fiddlerwoaroof>
The hierarchy I was thinking about above was more like the way that lexical scopes nest
<beach>
Hmm.
<fiddlerwoaroof>
The user's environment might have a "parent" that could be modified by an arbitrary number of other users
<fiddlerwoaroof>
But, if the user has any names in ther user's own environment, they take precedence
<beach>
I think I see.
<fiddlerwoaroof>
we already do something like this on Unix with the PATH enviroment variable
<beach>
So to get away from paths and unique names, I imagined that every object in the object database would have a set of intrinsic attributes like the type of the object (video, PDF) and a bunch of assigned attributes like "programing-language=Lisp", etc.
<fiddlerwoaroof>
That makes sense
karlosz has quit [Quit: karlosz]
<fiddlerwoaroof>
I would think you'd want to have some notion of an edge between objects, though
<moon-child>
you can create trees on-demand if you like, based on the tags and tag categories
<moon-child>
I don't think there's a compelling reason to have them be an intrinsic part of the system
<fiddlerwoaroof>
And, at that point, I'm not sure if programming-language=Lisp is better modeled as an attribute or as an edge between a Lisp node and another object
<fiddlerwoaroof>
I'm not talking about trees
<fiddlerwoaroof>
Objects naturally form a graph, I think
<moon-child>
why is the graph representation better than the flat attribute-based one? 'naturally' isn't really an argument
<fiddlerwoaroof>
What I mean is that an object almost always contains pointers to other objects
<fiddlerwoaroof>
So, if you have objects, you have a graph
<moon-child>
ok, yes. But we're not talking about objects in general, but about an object store, which is a specific type of object with a specific structure. So why is this the most suitable representation for that particular structure?
sxmx1 has quit [Quit: WeeChat 3.1]
<moon-child>
to give an example, relational databases are a very successful paradigm for a data store, and they are flat
<fiddlerwoaroof>
That's not really true
<fiddlerwoaroof>
The on-disk format their is an implementation detail
<fiddlerwoaroof>
The conceptual model involves things like foreign keys
<fiddlerwoaroof>
Although, I realize now I may have been misunderstanding beach's use of "object store"
<fiddlerwoaroof>
I was assuming he was talking about something like orthogonal persistence
<moon-child>
I think there is a meaningful extent to which databases are flatter than, say, file systems; or an object graph in a lisp program. But I see your point
<moon-child>
my understanding of 'object store' is that it is the name of the solution to 'you can now do ... to a access my new object', and that persistence was orthogonal
<fiddlerwoaroof>
Yeah, I was assuming an enviroment more like a Smalltalk image
<beach>
Yes, I think moon-child has the right idea of how I imagined the object store.
<beach>
It certainly has nothing to do with persistence.
pbaille has joined #lisp
<beach>
"Give me a list of all the PDF files in the system that are at least 100kbytes large". Stuff like that.
<beach>
"Give my all the Lisp files in the system that are part of library A or library B.
<fiddlerwoaroof>
But, what is returned? a bag of bytes? or #<pdf-object "foo" #x11112222>
<beach>
A list of pointers (capabilities) to objects.
<beach>
I said PDF "files". I mean PDF "objects".
<beach>
I will then create my own temporary "directory" from those objects if that is the best way to work on them later.
<fiddlerwoaroof>
Why have the distinction there between pointers and objects?
<beach>
There is no such distinction. I imagine "reference semantics" like Lisp.
<beach>
So the latter.
<fiddlerwoaroof>
ok, then I don't see how the store isn't a graph
<beach>
It is a flat list.
<beach>
So a special case of a graph, of course.
<fiddlerwoaroof>
Can you have, for example, a documentation object in the store that maintains a reference to the function it documents?
<beach>
That would certainly be a possibility, if the object was created that way.
<beach>
But the function would not be searched in the query.
<beach>
... unless it was independently added to the object store.
<fiddlerwoaroof>
I was thinking that, conceptually, the way you'd collect search results is by walking the graph
<beach>
Objects are not automatically present in the object store. When I type 34234 or (cons 3 4) those objects are not in the object store.
<beach>
That is not how I see it.
<fiddlerwoaroof>
But, if I add a documentation object that references a function object, I have to persist the function when I add the documentation object to the store, right?
<beach>
I see an object being explicitly added to the object store, possibly with some assigned attributes.
<fiddlerwoaroof>
Otherwise, when the documentation object is retrieved later, you'd have a dangling reference
<beach>
"persist"?
<beach>
There is universal persistence.
<beach>
The object store has nothing to do with persistence. Every accessible object is automatically persistent.
<jackdaniel>
in (correct) capability systems capabilities are separate from objects too
<fiddlerwoaroof>
Hmm, I guess I'm confused why you'd have an object store
<jackdaniel>
otherwise you could conceal a capability in an object available to the "less" capable operator
<beach>
The object store is just a list of objects, each one with some associated attributes. The purpose is for search. Nothing else.
<fiddlerwoaroof>
That clears up a lot of confusions I had :)
<beach>
Ah, OK.
<fiddlerwoaroof>
I was thinking things like "who calls this function" would be answered by the object store
<beach>
I don't think so. The object store would answer questions like "Give me a list of all LaTeX files that are part of the Trucler library"
<beach>
I said "files" again. Sorry.
<fiddlerwoaroof>
I see that now, although I wonder if it'd be better to treat the object store as an optimization
<beach>
I don't think so. The object store would answer questions like "Give me a list of all LaTeX document objects that are part of the Trucler library"
<beach>
What would it optimize?
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
<fiddlerwoaroof>
If you already have a "trucler" project object with references to latex objects, lisp code objects, package objects, etc. the object store starts to seem superfluous, except as a sort of index.
<fiddlerwoaroof>
Because you could answer the same questions by walking the graph
<fiddlerwoaroof>
Starting at some designated sets of root objects
<beach>
Yes, but I would then have to have a lot of those "directory objects". There would be one such object that has all the PDF documents in the system that were created last month. Another that contains all the PDF documents that were created last week, etc.
<beach>
I want the ability to create those directory objects dynamically according to the way I want to work at the moment.
psilotorp has joined #lisp
<beach>
If I want to be able to search in all possible ways, the "graph" becomes meaningless and artificial.
<fiddlerwoaroof>
I think we might be talking about different things here
<beach>
That's entirely possible.
<fiddlerwoaroof>
If I take one tag like project=Trucler, I can either store that bit of information as a tag on every object in the object store, or I can create a "project" tag objects with links
<moon-child>
beach: out of curiosity, do you envision a query language that can perform optimizations based on indices and such? (filter (lambda (x) (eq (slot-value x 'programming-language) 'lisp)) *all-objects*) doesn't scale very well
<fiddlerwoaroof>
then I do the same thing for "PDF"
<fiddlerwoaroof>
(a) this saves space because each unique tag value is stored once
<fiddlerwoaroof>
(b) you're already going to be doing something like this if you have universal persistence
psilotorp has quit [Ping timeout: 250 seconds]
<moon-child>
'already going to be doing something like this' why?
<fiddlerwoaroof>
Well, in the case of lisp code, you'll have the package system with references to symbols
<fiddlerwoaroof>
As well as the various environments used to resolve those symbols
<moon-child>
having a given tag is orthogonal with being in a given environment
<fiddlerwoaroof>
And all the code will be present both inside the function objects and in the objects in the object store
<moon-child>
if it were not, then you would effectively be forcing a hierarchical architecture
<moon-child>
which means assuming some hierarchy to be canonical; this is not what we want
<fiddlerwoaroof>
You can't avoid that with a function object
<fiddlerwoaroof>
The free variables in the function object all have to resolve to something
<moon-child>
sure. So the function objects allow us one way to organize objects, and the object store enables another way of organizing objects, which wouldn't otherwise be possible. What's wrong with that?
<phoe>
is there any part of the specification that explicitly states that for any (setf (foo ...) newval), the value of (foo ...) retrieved right afterwards must be EQL to NEWVAL?
<fiddlerwoaroof>
I think the section "Storing form" here says that?
<fiddlerwoaroof>
> a form which can reference both the temporary and the store variables, and which changes the value of the place and guarantees to return as its values the values of the store variables, which are the correct values for setf to return.
<phoe>
hmmm
<phoe>
"changes the value of the place" is weaker than EQL
<fiddlerwoaroof>
Also "the ultimate result of evaluating setf is the value or values being stored"
<beach>
moon-child: I haven't given any thought to optimizing, but my hunch is that the space on a system is mainly taken up by binary stuff like sound, pictures, videos, etc. The object store will easily fit in main memory, so it should not take to long to scan it all. But sure, optimizations are good.
<phoe>
my question is whether the value that is stored must be EQL to the value that was passed into setf, and the bits of the spec you mentioned do not seem to guarantee that
<beach>
fiddlerwoaroof: Sure, tags may not be strings.
<phoe>
which means that e.g. (setf (foo) #1="bar") can e.g. make a copy of #1# that will be EQUAL but not EQL
<fiddlerwoaroof>
I don't think that's possible in general
<fiddlerwoaroof>
(setf foo (make-instance 'bar)) can't know how to clone an arbitrary instance
_paul0 has joined #lisp
<phoe>
in general, yes
<fiddlerwoaroof>
So, the only possible conforming implementation is to return the value passed in
<phoe>
hey wait
<phoe>
I meant (setf (foo) ...)
<phoe>
where SETF FOO can have an arbitrary expander
<phoe>
my question is whether (let ((thing ...)) (setf (foo) thing) (eql (foo) thing)) needs to return T in all cases
aartaka_d has quit [Ping timeout: 245 seconds]
<phoe>
or whether it's allowed not to do that
<beach>
phoe: I don't think it can be since the user can write "incorrect" SETF functions.
<fiddlerwoaroof>
Are those function conforming, though?
<phoe>
beach: what do you mean by "incorrect"?
<beach>
phoe: Not making the object available to subsequent reads.
loskutak has joined #lisp
<phoe>
beach: this is exactly my question, must "the object" be EQL to the value that was written?
<phoe>
or can it be different?
paul0 has quit [Ping timeout: 268 seconds]
<beach>
Yes, I understand.
<beach>
Anyway, I'm out of here for a while. I really need to get some work done today.
<phoe>
like, imagine that SETF FOO sends a network message that is meant to set some variable in another Lisp image
<phoe>
and calling (foo) sends another message that retrieves the value of that variable
<phoe>
a string, for simplicity
<phoe>
this is likely going to be EQUAL but not EQL
<phoe>
do the semantics of SETF allow for such a thing?
<fiddlerwoaroof>
My inclination is to say that SETF doesn't restore "the value or values being stored" unless the return value(s) are EQ to the stored value(s)
<phoe>
what do you mean by "restore"?
<fiddlerwoaroof>
sorry, typo for "return"
jnewton has quit [Ping timeout: 252 seconds]
<fiddlerwoaroof>
Although, I guess "value" might be ambiguous here
jeosol has quit [Quit: Connection closed]
hendursa1 has joined #lisp
rusua has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
v88m has quit [Ping timeout: 268 seconds]
Inline has joined #lisp
anticrisis has quit [Read error: Connection reset by peer]
jnewton has joined #lisp
<saturn2>
another thread can modify a variable between setfing and reading it
<phoe>
let's assume no threading for simplicity
<saturn2>
i'm just saying if that violates the spec, it seems to have gone unnoticed for quite a while
<moon-child>
phoe said 'right afterwards'. So let's assume that a small enough interval of time has passed that another thread couldn't have modified the variable
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
<Inline>
what kinda variable ?
Krystof has joined #lisp
imode has quit [Ping timeout: 246 seconds]
cage_ has joined #lisp
CodeOrangutan has joined #lisp
jnewton has quit [Ping timeout: 240 seconds]
CodeOrangutan has quit [Quit: Leaving]
frost-lab has joined #lisp
davros has joined #lisp
nij has quit [Ping timeout: 246 seconds]
CodeOrangutan_ has joined #lisp
CodeOrangutan_ is now known as CodeOrangutan
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
CodeOrangutan has quit [Client Quit]
CodeOrangutan has joined #lisp
cosimone has quit [Remote host closed the connection]
masp has joined #lisp
loskutak has quit [Ping timeout: 252 seconds]
pbaille has quit [Remote host closed the connection]
muyinliu_ has joined #lisp
muyinliu_ has quit [Client Quit]
muyinliu has joined #lisp
<splittist>
beach: one source of inspiration might be things like Microsoft Graph, which is about sharing things with different access controls. Of course, being MS, the documentation is written in such as way as to be both too high-level and too low-level at the same time.
<nature>
Learning Common Lisp and really liking it so far, I am a heavy vim user who can't edit text without vi-binding so I am currently using doom emacs for evil mode, but something weird is starting to happen... I am under the impression that vi-style binding are suboptimal when editing lisp, especially when working interactively with SLIME/SLY. Any take on this?
<nature>
Also maybe does anybody has some video recommendation of people making full use of the interactive workflow of lisp?
amk has quit [Read error: Connection reset by peer]
amk has joined #lisp
<beach>
nature: Weekends can be pretty slow here. And I am thinking most users here use plain Emacs+SLIME/SLY, so you may have to wait until tomorrow for more people who have a take on it.
<nature>
I am in no rush thanks for letting me know tho :)
<beach>
Sure.
zaquest has quit [Quit: Leaving]
skapata has quit [Remote host closed the connection]
<beach>
nature: For workflow, I usually have one Emacs window with the REPL, up to three windows with Common Lisp buffers, and one window with magit. When I make small changes, I use C-c C-c on a top-level form in a Common Lisp buffer, and immediately test the change in the REPL. For more extensive modifications, I re-load the ASDF system I am working on.
<scymtym>
nature: the "Common Lisp Tutorials" and "Little Bits of Lisp" playlists in https://www.youtube.com/user/CBaggers/playlists probably have a few things that could be helpful for you
saravia has joined #lisp
<scymtym>
those videos use Emacs and SLIME
saravia has left #lisp ["WeeChat 1.7.1"]
v88m has joined #lisp
<beach>
The one named "Little bits of lisp - Function lambda list" shows the basic workflow.
<nature>
beach: Do you make use of the mouse as well to inspect expression, symbols etc..?
<nature>
scymtym: Thanks, I'll check them out
klltkr has joined #lisp
<beach>
nature: I do yes, because I use the Clouseau inspector which pretty much requires it.
monolithic has joined #lisp
pbaille has joined #lisp
pbaille has quit [Remote host closed the connection]
pbaille has joined #lisp
kevingal has joined #lisp
<beach>
nature: Did you check out the movie I suggested? Does that look like the way you work too?
<nature>
beach: Checking it right now, what's the key to jump from the repl to the lisp buffer? I know C-c C-z goes to the repl, but I never figured out the other way around
<beach>
C-x o changes to the next window. So it works both directions.
<nature>
Thx and yeah that's the kind of worflow that looks good to me, copying a top-level sexp and pasting it, then modifying one of the inner sexps looks exactly what I am feeling I am struggling with
<nature>
with vi-binding I am mostly using visual mode with '%' to jump from one parenthesis to it's open/close counterpart
<nature>
But that feels pretty clunky honestly :/
<beach>
I'll spare you the lecture on the usual Emacs commands for stuff like that. :)
<nature>
What are the main commands to work with sexps in emacs? I honestly don't mind emacs binding when they are beter suited
Lord_of_Life_ has joined #lisp
<beach>
My fingers know them, but "I" don't. :)
<nature>
Or where can I find those commands at least? I don't necessarily look to be spoon-fed
<nature>
hahaha
<beach>
C-x C-f, C-x C-b for navigation, C-x C-a, C-x C-e for moving by function C-x C-t for swapping (I think).
<beach>
Maybe C-M-t.
heisig has quit [Quit: Leaving]
Lord_of_Life has quit [Ping timeout: 240 seconds]
<beach>
Maybe they are all C-M in fact, because I use C-[ instead of M-
rusua has quit [Quit: Connection closed for inactivity]
<beach>
I shouldn't have tried. :(
Lord_of_Life_ is now known as Lord_of_Life
heisig has joined #lisp
jnewton has quit [Ping timeout: 245 seconds]
actuallybatman has quit [Ping timeout: 252 seconds]
<muyinliu>
nature: Try Emacs plugin smartparens for manipulating sexps.
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
loskutak has quit [Ping timeout: 240 seconds]
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #lisp
Bike has joined #lisp
pve has joined #lisp
jnewton has joined #lisp
boooooooo has joined #lisp
boooooooo has quit [Excess Flood]
harovali` has quit [Ping timeout: 265 seconds]
mister_m has quit [Ping timeout: 240 seconds]
pbaille has quit [Remote host closed the connection]
pbaille has joined #lisp
pbaille has quit [Ping timeout: 246 seconds]
heisig has quit [Ping timeout: 240 seconds]
hiroaki has quit [Ping timeout: 260 seconds]
Inline has quit [Remote host closed the connection]
Inline has joined #lisp
Inline has quit [Remote host closed the connection]
Lycurgus has joined #lisp
Inline has joined #lisp
attila_lendvai has quit [Ping timeout: 240 seconds]
zaquest has joined #lisp
pbaille has joined #lisp
Inline has quit [Remote host closed the connection]
Inline has joined #lisp
aartaka_d has joined #lisp
pbaille has quit [Ping timeout: 245 seconds]
Sheilong has joined #lisp
aartaka has quit [Ping timeout: 260 seconds]
gareppa has joined #lisp
gareppa has quit [Remote host closed the connection]
frost-lab has quit [Quit: Connection closed]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
creat has quit [Ping timeout: 250 seconds]
Lycurgus has quit [Quit: Exeunt]
spacebat2 has quit [Ping timeout: 252 seconds]
gaqwas has quit [Remote host closed the connection]
spacebat2 has joined #lisp
notzmv has quit [Ping timeout: 245 seconds]
Bourne has joined #lisp
mister_m has joined #lisp
homonyms has joined #lisp
homonyms has quit [Read error: Connection reset by peer]
creat has joined #lisp
jnewton has quit [Ping timeout: 252 seconds]
heisig has joined #lisp
shka_ has joined #lisp
cosimone has joined #lisp
pbaille has joined #lisp
jnewton has joined #lisp
Inline has quit [Ping timeout: 260 seconds]
<loli>
^
<loli>
they are really nice, most others seem to use paredit, I use lispy myself, and some use parinfer
niflce has quit [Ping timeout: 252 seconds]
Lycurgus has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
xkapastel has joined #lisp
Lycurgus has quit [Quit: Exeunt]
cosimone has quit [Remote host closed the connection]
yoonkn has quit [Read error: Connection reset by peer]
notzmv has joined #lisp
supercoven has joined #lisp
atw has joined #lisp
gaqwas has quit [Remote host closed the connection]
davisr has quit [Remote host closed the connection]
narimiran has joined #lisp
X-Scale` has joined #lisp
amb007 has quit [Ping timeout: 265 seconds]
X-Scale has quit [Ping timeout: 265 seconds]
X-Scale` is now known as X-Scale
amb007 has joined #lisp
aartaka has joined #lisp
loskutak has joined #lisp
aartaka_d has quit [Ping timeout: 240 seconds]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
narimiran has quit [Quit: leaving]
psilotorp has joined #lisp
undvrainbowvita8 has quit [Quit: EXIT]
maxwilli- has joined #lisp
maxwilliamson has quit [Ping timeout: 240 seconds]
Inline has joined #lisp
irc_user has joined #lisp
<atw>
I've got a question about http://metamodular.com/lispos.pdf, re the single memory abstraction. Does this mean that every time a program creates a cons cell or object, that thing is written in the slow, permanent secondary memory?
psilotorp has quit [Ping timeout: 250 seconds]
Krystof has joined #lisp
actuallybatman has joined #lisp
<phoe>
not immediately I assume
<atw>
hello phoe! I bought your book recently :)
<phoe>
it gets written into RAM for sure, and I don't know what is the exact process of synchronizing data between RAM and non-volatile memory or what beach plans for this
<phoe>
atw: thanks, hope it serves you well
hypercube has joined #lisp
undvrainbowvita8 has joined #lisp
<atw>
I'm making a toy lisp system and I wanted something like (persist o) which causes o to be written to disk and evaluates to o. I was curious if CLOSOS took an explicit approach like this or if there's something more implicit that makes sense to do
amb007 has quit [Remote host closed the connection]
psilotorp has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
amb007 has joined #lisp
skapata has joined #lisp
Josh_2 has joined #lisp
waleee-cl has joined #lisp
Spawns_Carpetin- has quit [Ping timeout: 268 seconds]
<Bike>
atw: don't quote me on this, but my impression was permanent storage is only done when a snapshot is taken, which may happen automatically but not at every moment
<pjb>
atw: in addition to snapshots, there may be logs written (of changed pages). but this would be performed in an efficient background task that wouldn't impact much the system performance.
<pjb>
atw: it worked like this on EROS and I found it was a nice feature. Unfortunately for some reasons, this feature wasn't kept for CoyotOS.
v88m has quit [Ping timeout: 245 seconds]
<pjb>
atw: for a lispOS system you may also choose to have hardware to ensure persistence of the core memory. Either with a different core memory technology, or by using eg. batteries to keep the DRAM alive.
<pjb>
atw: notice how systems such as macOS try very hard to give the user the impression of persistent core memory: when you crash and reboot, it can reopen all the open application and restore the state they were in (if the application implements the feature).e
<pjb>
atw: this means that this is a good feature for the users, so there's no reason why it could't be implemented in hardware (with battery backed DRAM).
<pjb>
atw: but of course, for that you need a system that wouldn't crash and destroy the DRAM contents…
<pjb>
beach: ok. Then I didn't understand the aspect you didn't understand yet.
imode has joined #lisp
jnewton has quit [Ping timeout: 240 seconds]
cage_ has quit [Ping timeout: 268 seconds]
psilotorp has quit [Remote host closed the connection]
<mister_m>
Is ``format'' the preferred way to join a list of items with a given separator?
<mister_m>
without a package like ``cl-str''
<phoe>
mister_m: I guess so
<phoe>
(format nil "~{~A~^ ~}" things) is how I do it
<phoe>
with space being the separator, that is
notzmv has joined #lisp
<mister_m>
is using a library such as cl-str more typical for stuff like this?
<phoe>
I guess it depends on the programmer in question
masp has quit [Quit: Konversation terminated!]
<phoe>
I never used cl-str in my life, but mostly because I never needed it
notzmv has quit [Remote host closed the connection]
<phoe>
if you do more string processing then I guess it can be useful
<mister_m>
fair enough
<mister_m>
thanks
notzmv has joined #lisp
<Josh_2>
mister_m: I find cl-str very useful
notzmv has quit [Remote host closed the connection]
<Josh_2>
I use str:split all the time
jnewton has joined #lisp
notzmv has joined #lisp
notzmv is now known as Guest4205
Guest4205 has quit [Remote host closed the connection]
notzmv- has joined #lisp
<mister_m>
It is nice not having to re-implement various things like that certainly. split-sequence seems pretty common as well for that usage too or cl-ppcre's split
ebrasca has joined #lisp
zulu-inuoe has joined #lisp
notzmv- has quit [Ping timeout: 265 seconds]
aartaka_d has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
aeth has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
<Jachy>
I similarly like uiop:split-string because it's just there, but then some fraction of the time I also want to join and at that point might as well pull in cl-str...
cer-0 has joined #lisp
TK__ has joined #lisp
seok has joined #lisp
theothornhill has joined #lisp
<remexre>
any reason why the reader wouldn't be able to find a package (sb-introspect) but find-symbol can find symbols from it at compiletime or runtime?
<Xach>
remexre: case issues maybe. i can't think of anything else offhand but it would help to see the error or code or both.
<remexre>
code is just (format t "~s~%" (sb-introspect:function-lambda-list #'foo)) vs (format t "~s~%" (funcall (find-symbol "FUNCTION-LAMBDA-LIST" "SB-INTROSPECT") #'foo))
<Xach>
oh, sb-introspect isn't loaded yet, then.
<remexre>
the former of which results in READ error during COMPILE-FILE: Package SB-INTROSPECT does not exist.
<Xach>
easy enough
<remexre>
oh, it's not loaded by default? I'd've assumed all the compiler builtin libs were
jnewton has quit [Ping timeout: 246 seconds]
<Xach>
no.
<remexre>
ok, I should just be able to import-from it, right?
cer-0 has quit [Quit: leaving]
<Xach>
after it's loaded, yes
<Xach>
slime distorts the sense of what's loaded by default
<Xach>
sb-posix isn't even loaded by default
<remexre>
okay, looks like import-from works w/ package-inferred-system; thanks for the help!
psilotorp has joined #lisp
attila_lendvai has joined #lisp
cage_ has joined #lisp
<atw>
thanks pjb, Bike :)
CodeOrangutan has quit [Remote host closed the connection]
ebrasca has quit [Remote host closed the connection]
aamukastemato has joined #lisp
aamukastemato has quit [Quit: Leaving]
cage_ has quit [Quit: rcirc on GNU Emacs 27.1]
psilotorp has quit [Remote host closed the connection]
aeth has quit [Ping timeout: 240 seconds]
mindCrime has joined #lisp
orivej has quit [Ping timeout: 265 seconds]
irc_user has quit [Quit: Connection closed for inactivity]
Krystof has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
silasfox has quit [Ping timeout: 245 seconds]
jnewton has joined #lisp
silasfox has joined #lisp
absurdum has quit [Quit: Leaving]
jnewton has quit [Ping timeout: 260 seconds]
mindCrime has quit [Ping timeout: 260 seconds]
Inline has quit [Ping timeout: 260 seconds]
silasfox has quit [Ping timeout: 245 seconds]
TK__ has quit [Remote host closed the connection]
shka_ has quit [Ping timeout: 268 seconds]
silasfox has joined #lisp
supercoven has quit [Ping timeout: 245 seconds]
theothornhill has quit [Ping timeout: 265 seconds]
wxie has quit [Ping timeout: 252 seconds]
Sheilong has quit []
brandflake11 has joined #lisp
Krystof has joined #lisp
rgherdt has quit [Ping timeout: 260 seconds]
anticrisis has joined #lisp
notzmv has joined #lisp
notzmv is now known as Guest82031
nij has joined #lisp
aeth has quit [Ping timeout: 260 seconds]
pbaille has quit [Remote host closed the connection]
aeth has joined #lisp
hjudt has quit [Ping timeout: 260 seconds]
hjudt has joined #lisp
attila_lendvai has quit [Remote host closed the connection]
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
pbaille has joined #lisp
Guest82031 has quit [Ping timeout: 240 seconds]
pbaille has quit [Remote host closed the connection]
pve_ has quit [Quit: leaving]
attila_lendvai has quit [Ping timeout: 245 seconds]
patlv has joined #lisp
hjudt_ has joined #lisp
keja has joined #lisp
pbaille has joined #lisp
heisig has quit [Quit: Leaving]
pbaille has quit [Ping timeout: 265 seconds]
hjudt_ has quit [Quit: leaving]
hjudt has quit [Quit: leaving]
hjudt has joined #lisp
davros has quit [Remote host closed the connection]
notzmv- has joined #lisp
npfaro has joined #lisp
CrashTestDummy2 has joined #lisp
nature has quit [Quit: Lost terminal]
<npfaro>
hi lispers
<npfaro>
what is the current status on windows builds of SBCL? it looks like it has been sitting at 2.0.0 for a while
<npfaro>
is it possible to build from src on windows?
<npfaro>
(the latest that is)
karlosz has joined #lisp
patlv has quit [Ping timeout: 245 seconds]
CrashTestDummy3 has quit [Ping timeout: 245 seconds]