kevingal has quit [Remote host closed the connection]
Lycurgus has joined #commonlisp
yitzi has joined #commonlisp
alandipert has joined #commonlisp
Lycurgus has quit [Quit: Exeunt]
waleee has quit [Quit: WeeChat 3.1]
Lycurgus has joined #commonlisp
Lycurgus has quit [Client Quit]
dieggsy has quit [Read error: Connection reset by peer]
dieggsy has joined #commonlisp
waleee has joined #commonlisp
waleee has quit [Client Quit]
waleee has joined #commonlisp
kagevf has joined #commonlisp
waleee has quit [Ping timeout: 252 seconds]
leeb has joined #commonlisp
rbtEngrDude has joined #commonlisp
Lycurgus has joined #commonlisp
pfdietz has quit [Ping timeout: 252 seconds]
Lycurgus has quit [Quit: Exeunt]
<beach>
Good morning everyone!
dieggsy has quit [Read error: Connection reset by peer]
dieggsy has joined #commonlisp
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 264 seconds]
Lord_of_Life_ is now known as Lord_of_Life
Oladon has joined #commonlisp
dieggsy has quit [Read error: Connection reset by peer]
dieggsy has joined #commonlisp
dieggsy has quit [Read error: Connection reset by peer]
dieggsy has joined #commonlisp
andai has quit [Quit: Leaving.]
dieggsy has quit [Read error: Connection reset by peer]
dieggsy has joined #commonlisp
housel has quit [Remote host closed the connection]
srhm has quit [Quit: Konversation terminated!]
cjb has quit [Quit: BRB]
raeda has joined #commonlisp
cjb has joined #commonlisp
bilegeek has quit [Quit: Leaving]
atgreen has quit [Ping timeout: 264 seconds]
loke has joined #commonlisp
<drmeister>
The readtable doesn't change automatically when you change default packages does it? I'm wondering how #H reader macro gets installed in cl21.
<drmeister>
I evaluate the sample code in the cl21 github README.md and #H() doesn't work - the *readtable* hasn't been altered by anything up to the #H().
<drmeister>
Either fukamachi left out swapping the readtable in the sample code - or I'm forgetting something about how the default package and default readtable work.
<drmeister>
Ho ho - he redefines in-package and a bunch of other stuff so that readtables are changes when you use in-package.
<beach>
drmeister: Is this the channel you want?
<drmeister>
It is.
<beach>
Just checking.
<drmeister>
This be #commonlisp - the new Libera.Chat channel for common lisp?
<drmeister>
Yep.
<drmeister>
I've added support for clasp to CL21 and there appears to be something not right with the readtables.
ad-absurdum has joined #commonlisp
lazr has joined #commonlisp
ad_absurdum has joined #commonlisp
ad-absurdum has quit [Ping timeout: 248 seconds]
pve has joined #commonlisp
mrcom has joined #commonlisp
Oladon has quit [Quit: Leaving.]
shka has joined #commonlisp
contrapunctus has joined #commonlisp
johan_ has joined #commonlisp
dieggsy has quit [Read error: Connection reset by peer]
dieggsy has joined #commonlisp
dieggsy has quit [Read error: Connection reset by peer]
dieggsy has joined #commonlisp
cjb has quit []
hendursaga has quit [Ping timeout: 252 seconds]
Th30n has joined #commonlisp
Cymew has joined #commonlisp
Nilby has joined #commonlisp
cranium has joined #commonlisp
adabsurdum has joined #commonlisp
<pjb>
IMO, it's not a good idea to link readtables and packages. readtables and files, perhaps, but not packages.
ad_absurdum has quit [Ping timeout: 248 seconds]
amk has quit [Remote host closed the connection]
amk has joined #commonlisp
<flip214>
pjb: OTOH, this is neat too: (cl21:in-package :postscript-emulation) (Hello World) 100 100 moveto show
<pjb>
(enable-postscript-readtable) is as nice.
<pjb>
and it can be used in different packages!
Krystof has joined #commonlisp
hendursaga has joined #commonlisp
<Jach>
Josh_2: You might also want to post in the common lisp subreddit, I've seen hiring posts show up there before.
prite has joined #commonlisp
pve has quit [Quit: leaving]
VincentVega has joined #commonlisp
hendursaga has quit [Ping timeout: 252 seconds]
hendursaga has joined #commonlisp
<luis>
pjb: the nice thing of linking them to packages is the repl, though perhaps some concept above packages would be nicer here
random-nick has joined #commonlisp
scymtym has joined #commonlisp
eta has quit [Quit: Gateway shutdown]
kevingal has joined #commonlisp
rudi has joined #commonlisp
eta has joined #commonlisp
pve has joined #commonlisp
rudi has quit [Quit: rudi]
rudi has joined #commonlisp
rudi has quit [Client Quit]
sm2n has quit [Read error: Connection reset by peer]
sm2n has joined #commonlisp
rudi has joined #commonlisp
VincentVega has quit [Ping timeout: 264 seconds]
Gnuxie has joined #commonlisp
srji has joined #commonlisp
<pjb>
luis: furthermore, load is specified in a way that let you interpret the loaded files as you wish, not only as the CL system predefines it: you can set a *readtable* and a *package* where to load a file (that wouldn't contain in-package and enable any different *readtable*), so that the same declarations can be processed differently.
<pjb>
luis: an example of that is a file such as com/informatimago/common-lisp/html-base/html401.lisp which contains defelement and defattribute forms, and which can be loaded either in a html parser or a html generator package with different definitions of those operators.
<pjb>
luis: different reader macros can similarly be useful to instrument (read) a loaded files in different ways.
VincentVega has joined #commonlisp
silasfox has joined #commonlisp
Th30n has quit [Ping timeout: 264 seconds]
yitzi has quit [Quit: Leaving]
<phoe>
drmeister: I assume that cl21 does the equivalent of standard CL:IN-PACKAGE + NR:IN-READTABLE
<phoe>
both of which are implemented as setting *PACKAGE* and *READTABLE* in EVAL-ALWAYS mode
<phoe>
s/as/as, respectively,/
adabsurdum has quit [Quit: Leaving]
Th30n has joined #commonlisp
rusua has quit [Quit: Connection closed for inactivity]
loke[m] has joined #commonlisp
<shka>
hi all
<shka>
is there a way to unload system?
<phoe>
AFAIK there's none
<phoe>
unless a system defines an unloading operation itself
<phoe>
what does it even mean to unload a system?
<phoe>
probably to reverse all the operations done during its loading
<phoe>
so you'd need to track all the DEFUN, DEFGENERIC, DEFVAR, DEFMETHOD, DEFFOO operations done during its loading, and then have a way to reverse them
<phoe>
and I don't know even of a single system that does all that!
<shka>
phoe: yeah, it shouldn't be possible
<shka>
instead, i can simply delete all packages defined by the system and run GC i think
<loke[m]>
phoe: You could conceive of a Lisp implementation that allows you to compartmentalise systems in the sense that any object belongs to a given domain.
<loke[m]>
That would be very similar to simply running multiple Lisp runtimes, but with some ability to share objects.
<loke[m]>
I'm not sure any such system exists though.
<loke[m]>
Erlang has it though, no?
<shka>
uh, this would be first class environments?
<shka>
which is what sicl is trying to do
<loke[m]>
shka: I guess so? But are they implemented anywhere fully?
<shka>
not in cl
<loke[m]>
Right. That's what I meant. I should have been more clear.
<shka>
racket comes to mind in the wider lisp family
<loke[m]>
You can kinda-sorta do it in the JVM as well.
<phoe>
loke[m]: yes, it could, but it's still theory
<phoe>
can't do that in any complete contemporary CL implementation that I know of
<phoe>
SICL is the closest, I guess
<scymtym>
environments work in terms of bindings, though. objects may have a name in one or more environments, but don't "belong" to a particular environment
<phoe>
oh
<phoe>
so you'd still need multiple separate ASDFs loaded
<phoe>
with separate state
<shka>
scymtym: sure, but that does not make all that much difference in practice
<scymtym>
shka: maybe. i guess it depends on the purpose. first class global environment do not imply independent heaps, for example, which i think erlang has
<phoe>
erlang has those because of very strict IPC limitations
Lycurgus has joined #commonlisp
<phoe>
one can't share a heap object in erlang, one must copy it
<phoe>
unless it's an object in the global heap which is then also immutable like everything in erlang
<loke[m]>
phoe: are you sure? Objects are immutable in Erlang, so why would you need to copy them?
<phoe>
loke[m]: because threads are individually GC'd.
<phoe>
you can't refer an object from another thread's heap because you don't know if it's still valid
<shka>
erlang threads are actually processes
<phoe>
yes, green threads
<phoe>
you cannot really have such kind of limitations in Lisp
<phoe>
loke[m]: TIL, I must read more about it then
<loke[m]>
There is a pool of threads, if I'm not mistaken and erlang processes are assigned to them.
<shka>
anyway, i don't really need independent heaps in my lisp
<shka>
well, perhaps thread nursery heap like the one in sicl so they can be GCed independently to an extent
<Nilby>
I've made system deletion methods for some of my systems, but you have to be careful to delete packages in the right order, and know or limit any other load/runtime effects.
<pl>
phoe: BEAM used to be single threaded for a long time, but it gained multithreaded operation sometime before 2014
chrnybo has joined #commonlisp
<Nilby>
It would be difficult, but you could make an effect watcher for other systems, and make a careful effect undo-er, but it seems like a lot of work.
waleee has joined #commonlisp
Th30n has quit [Ping timeout: 272 seconds]
<shka>
i wonder if there is even use case for something like this
<phoe>
basically reversible computing for lisp
<phoe>
a hard thing to do
<shka>
well, exception safety, perhaps?
<phoe>
among other things
<shka>
and some kind of transactional processing?
<Nilby>
There are really good use cases for it.
<shka>
but niche use cases
Lycurgus has quit [Quit: Exeunt]
waleee has quit [Ping timeout: 264 seconds]
<_death>
maybe you can "snapshot" by forking
waleee has joined #commonlisp
Th30n has joined #commonlisp
<Nilby>
system unloading can be useful where you have sub-applications, e.g. web browsers/servers, shells, editors, window managers/servers, etc.
chrnybo has quit [Ping timeout: 248 seconds]
leeb has quit [Ping timeout: 272 seconds]
dieggsy has quit [Read error: Connection reset by peer]
dieggsy has joined #commonlisp
dieggsy has quit [Read error: Connection reset by peer]
dieggsy has joined #commonlisp
waleee has quit [Ping timeout: 264 seconds]
<jackdaniel>
unloading is problematic when you reference objects from that system
rudi has quit [Quit: rudi]
<beach>
Even though SICL doesn't exist yet, it feels real to me. So it makes me jump to read that first-class global environments don't exist in any "cl". :) I guess we just need to continue the work and make it real as soon as we possibly can.
waleee has joined #commonlisp
<Nilby>
Software that's written is real, but perhaps not alive yet. Some is embryonic, some is archaeological.
yitzi has joined #commonlisp
waleee has quit [Ping timeout: 248 seconds]
cage has joined #commonlisp
johan_ has quit [Ping timeout: 265 seconds]
heisig has joined #commonlisp
selwyn has joined #commonlisp
Mandus has quit [Ping timeout: 264 seconds]
Mandus has joined #commonlisp
Krystof has quit [Ping timeout: 248 seconds]
johan_ has joined #commonlisp
Krystof has joined #commonlisp
<dieggsy>
i may have missed the answer to this earlier, but do we have some standard way to show the full class hierarchy for a particular class?
<beach>
The CLIM listener has a function for that as I recall.
<beach>
"show class subclasses" or something like that.
* beach
suspects that his answer was not satisfactory to dieggsy.
<eta>
I think DESCRIBE does this
<dieggsy>
eta: it doesn't seem to
<dieggsy>
beach: I'll check that out, is that on quicklisp?
<dieggsy>
i thought about doing it myself, thanks for the paste
<dieggsy>
what's the view-lisp command?
<beach>
Nilby: That doesn't seem to handle the "diamond" case.
Mandus has joined #commonlisp
<scymtym>
the McCLIM inspector (called Clouseau) can also be used to visualize subclasses, superclasses (and the CPL) as graphs: (clouseau:inspect (find-class CLASS-'NAME)) and then expand the list in question
<beach>
Ah, good point.
<beach>
And another argument in favor of McCLIM.
* scymtym
meant 'CLASS-NAME, not CLASS-'NAME
<beach>
Nice.
<dieggsy>
welp, I've reported my error on #clim
<beach>
I saw it. :)
<beach>
Anyway, I frequently say something like "people spend a lot of energy to avoid having to learn Common Lisp". I think the same thing holds if you substitute CLIM/McCLIM for Common Lisp.
Th30n has quit [Ping timeout: 264 seconds]
gigo has joined #commonlisp
<gigo>
hi
<beach>
Hello gigo.
<gigo>
hi beach! new to this place. got interested after seeing the freenode debacle and someone suggested I join this channel.
<Nilby>
beach: Sorry. I'll get right on it boss. Every patse I make is satisfaction guaranteed or triple your money back.
<gigo>
this channel has logs. nice! i can see the past chats
<beach>
gigo: That's good advice.
<beach>
Nilby: Too bad I put in 0 money. :)
<gigo>
beach: can you elaborate this, "people spend a lot of energy to avoid having to learn Common Lisp"? curious because I am a beginner to Common Lisp as well and I want to be sure I am not falling into a pattern where I am avoiding learning Common Lisp.
<gigo>
I mean what would be an example of putting a lot of energy to avoid having to learn Common Lisp?
<gigo>
one thing I do is use uiop often because I see that solving the problems that uiop has solved in a cross-platform manner would be a lifetime activity, so I just use uiop instead of reinventing that wheel. Would that be an example of avoiding learning CL?
<beach>
gigo: By that I mean that I see a lot of projects and programming languages that solve a small subset of the problems that would be solved by Common Lisp, but for some reason, people dismiss Common Lisp as being useless without having given it a try.
<dieggsy>
Nilby: what's ~vt ?
<gigo>
beach: thanks. that makes sense.
<Nilby>
tab over to a value, or insert 'v' spaces
<dieggsy>
not sure I fully get how that works
<dieggsy>
e.g. (format t "~vt~a" 10 "foo") ? not 10 spaces
<susam>
I can relate to what beach said. I began learning CL a long time back but it was more of a curiosity then. Didn't realize the true value of CL. And then one day I saw one of my colleagues implemeting a DSL in JSON format and then a small processing engine that interprets the JSON and does stuff. When I looked at it, I thought: Wait a minute! This looks like Lispy but implemented in an ad-hoc manner in a
<susam>
hurry and a maintenance overhead. Why not just use Lisp for these things? And from that day I got hooked to CL in a serious manner.
<beach>
susam: Excellent example!
<eta>
greenspun's 10th rule etc
<Nilby>
dieggsy: it's so it indents it to the recursion depth 'level'
<dieggsy>
right, i can see that working, but i don't entirely understand the ~v mechanism
<dieggsy>
plus, with a level of zero it seems to get indebted one space over
<Nilby>
v just means get the value from the arguments instead of ~10t where it's in the format string
<beach>
jdz: Not me. I just saw the description given by susam.
<susam>
jdz: Yes, very similar to jsonlogic.com which I guess came on HN front page a few days back. But I have seen this sort of thing at least twice in my career many years ago.
selwyn has quit [Read error: Connection reset by peer]
<dieggsy>
Nilby: oh, sly is doing something weird with that
<Nilby>
dieggsy: Sorry. I only tested in my repl in a terminal, so emacs might do something different
<dieggsy>
nah that's not on you lol
<dieggsy>
wonder if slime has the same problem
<dieggsy>
works fine in run-lisp
<Nilby>
dieggsy: Maybe it's the mop: pacakge, has to be sb-mop: in sbcl or something else in other lisps. I just tested in a clean sly with sbcl and it worked after that.
<dieggsy>
yeah clean sly works here too. could also be any of the bazillion things i have to load in my work repl
<dieggsy>
yeah, it's that. not gonna go hunting it down ATM lol
heisig has quit [Quit: Leaving]
joshy has quit [Quit: Connection closed]
Cymew has quit [Ping timeout: 264 seconds]
srhm has joined #commonlisp
<srji>
emacs: in *scratch* buffer when i type '(def' i get auto completions, how can i enable it with slime repl?
mrcom has quit [Remote host closed the connection]
osp has joined #commonlisp
contrapunctus has joined #commonlisp
<kagevf>
srji: try C-tab
engblom has quit [Remote host closed the connection]
<Josh_2>
srji: using icomplete
contrapunctus has left #commonlisp [#commonlisp]
contrapunctus has joined #commonlisp
Duuqnd has quit [Remote host closed the connection]
Duuqnd has joined #commonlisp
Gnuxie has quit [Quit: Leaving]
Colleen has quit [Read error: Connection reset by peer]
Colleen has joined #commonlisp
<drmeister>
phoe: Regarding named readtables - we had a bug in clasp that broke the named readtable wrt macros - we have a fix now.
kayprish has joined #commonlisp
kevingal has quit [Remote host closed the connection]
Gnuxie has joined #commonlisp
dsk has quit [Ping timeout: 272 seconds]
osp has quit [Quit: Leaving]
andai has joined #commonlisp
kayprish has quit [Quit: Leaving]
kayprish has joined #commonlisp
yitzi has quit [Quit: Leaving]
shka has quit [Quit: Konversation terminated!]
yitzi has joined #commonlisp
shka has joined #commonlisp
Lycurgus has joined #commonlisp
waleee has joined #commonlisp
dickbar__ has quit []
katco has joined #commonlisp
Lycurgus has quit [Quit: Exeunt]
bhaible has quit [Remote host closed the connection]
kayprish has quit [Read error: Connection reset by peer]
waleee has quit [Ping timeout: 248 seconds]
waleee has joined #commonlisp
<contrapunctus>
Is there a Common Lisp library which can make queries (in the style of SQL) on an s-expression, without reading the whole of it into memory?
notzmv has quit [Ping timeout: 252 seconds]
<moon-child>
an s-expression? That seems like the wrong representation for something that doesn't fit in memory
<lazr>
when your cdr points to an on-disk file
nature has joined #commonlisp
<contrapunctus>
🤔
<nature>
Hey everybody, I just started to pickup CLOS and I am trying to model a form entry, and it just felt that I was repeating myself like crazy and if I want to add or remove a field it's gonna be tedious work updating all methods/functions and places where I use those methods/functions.
<pjb>
contrapunctus: do you have only this one class, or do you plan to make other classes the same way?
<pjb>
s/contrapunctus/nature/
<pjb>
nature: ^
<saturn2>
nature: is there a reason you need to wrap make-instance and all accessors in your own functions?
<pjb>
nature: instead of (update-entry e :email foo) just write (setf (email e) foo)
<pjb>
nature: of course, s/:reader/:accessor/ in defclass for that.
<pjb>
If you don't let defclass generate the code for you, of course, you have to rewrite it yourself (badly).
<contrapunctus>
moon-child: so would you recommend against an s-expression document format, in the interests of low memory consumption and the subsequent problem of keeping memory synced with disk? What would you recommend instead?
<moon-child>
not sure. Probably straight-up sqlite
<pjb>
nature: now, there may be a valid reason to define a slots-for-<something> generic function, with methods on classes and subclasses, so that you may write a single method like to-list in a generic way.
<moon-child>
depends on data constraints ofc
<pjb>
nature: also depending on what you need to-list for, you could just use the MOP to get the list of slots in an instance.
<pjb>
nature: one problem of using slot-value (or indirectly with with-slots) is that now you cannot write decorator methods on the writers.
<nature>
thanks for taking the time pjb and saturn2, so I don't plan to have more classes, I am just trying to build a simple web app that has a form and will store this in a csv. (Among other things the user is able to connect and update its form, view other forms etc.. But I am more concerned with my understanding of CLOS)
<nature>
saturn2: The reason I made this wrapper is that it felt better to have a single method to update an entry, as most of the times I update multiple fields in one go, but it seems that having multiple setf is advised, right?
<nature>
also I am not totally sure on how to use MOP in order to get the said behaviour, if you have any pointers/reads on it I'll check it out.
<nature>
pjb: I see I see, (with-accessors ...) would be better in such a case? Even though here I don't plan to write decorators methods on the writers, it's good that you point out such limitations to me, thanks
<nature>
saturn2: As for the make-entry function, I just read that it's good practice to define your own constructors
<White_Flame>
if adding/removing fields is going to be a thing, then using a more dynamic data structure would make a lot more sense than declared object slots
<pjb>
nature: yes, with-accessors could be better.
<saturn2>
nature: in CL you can write an initialize-instance method if you need to do anything special when creating an instance, so it's not usually necessary to use a wrapper
<pjb>
nature: but then it depends why you're setting the slots. If it's because you're loading an object from a database, then you may want to set the slots directly.
<saturn2>
to get a list of an object's slots you can do (mapcar #'c2mop:slot-definition-name (c2mop:class-slots (class-of obj)))
<pjb>
But update-entry is not called deserialize object, so…
dieggsy has quit [Read error: Connection reset by peer]
dieggsy has joined #commonlisp
<pjb>
Again, why do you want to-list? is it to serialize the object and store it in the database?
<White_Flame>
and if so, would it be that bad to just use lists? maybe another list for the field names?
<pjb>
If so, your class should have a method on a generic function slots-for-serialization, because you don't want to store all the slots. Some are derived values, some are caches, some are technicalities. Sometimes, a single database value is computed from two slots, or vice versa, a single slot can store two database columns.
<pjb>
hence the need of accessors even in that case.
<nature>
Yes because then I pass my database object to cl-csv:write-csv and it requires a list of list
<pjb>
serialization and deserialization of objects is not simple (OODBMS).
<White_Flame>
judging by the initforms, they're all string slots anyway
<White_Flame>
so that definitely simplifies it
<nature>
White_Flame: The problem with list is that for now I have only 6 fields but then I will need 3 timestamp fields and starting to keep track of those among a list of 30 values felt annoying and error-prone
<White_Flame>
defstruct with (:type list) gives you accessors to list elements by name, and still allows you to do list iteration over the fields (because it is actually a list)
<White_Flame>
obviously it's slower access than class slots for large numbers of them, because it has to walk the list, but if much of what you do is list-oriented over the slots, then it might be worth it for the simplicity
<White_Flame>
I don't know what your processing steps are, but these 2 functions you showed seem to expose more of a list interface to me
<White_Flame>
oh, update-entry takes keys, not 2 objects
<White_Flame>
but yeah, the main thing that jumped out at me was you changing the slots of the class and having to update the rest of the code
<nature>
Exactly what I felt was not the best in my code
<nature>
But it seems indeed that destruct with (:type list) could be what I was looking for
<nature>
Also thank you everybody for your precious feedback!
<zephyr>
anyone know of a historical or contemporary embedded db / object store for CL that offered query result subscriptions? ie the ability to "install" a query and obtain a stream of results as data changed. follow-up question, has anyone ever used such a thing as the data model in a (Mc)CLIM app?
<pjb>
nature: reload it, I've added a serialize/deserialize example; note how the two values are different objects.
<pjb>
nature: a real ODBMS would note that we're loading again an existing object, and unify them (eg using an ID slot).
<pjb>
There's also defstruct (:type vector) if you have a lot of fields.
<moon-child>
zephyr: depending on the nature of your queries, that could be tantamount to re-running the query on every change
<moon-child>
(unless you have a _really_ clever optimizer)
<moon-child>
imagine a query like select all values from table x that are < the sum of table y * the alternating difference of table z
<zephyr>
there are a lot of ways to efficiently produce a running result set, see e.g. IVM and differential dataflow
<moon-child>
I will look those up
<zephyr>
you're right that it's equivalent to running the same query and diffing after any possible change, though
<nature>
Thanks pjb! It might actually prove useful if I want more complex fields than strings
<White_Flame>
I've used a lot of forward-chaining inference systems, but those have been in-RAM, not in databases
<White_Flame>
but those fire on the delta of result sets directly
andai has quit [Ping timeout: 248 seconds]
<zephyr>
oh, i'm thinking in-RAM. have wondered about forward-chaining, but i think i like having a data model instead of a rule model, to support e.g. "Save" or whatever
<zephyr>
(my usecases are UI oriented)
<White_Flame>
the "data" are the facts in the fact base, and the rules are the "queries" who rise & fall with the members of their respective result set
VincentVega has quit [Remote host closed the connection]
<White_Flame>
but I have built a GUI in CLISP once
<White_Flame>
erm, CLIPS
<zephyr>
were you pleased with the result?
<White_Flame>
yes, it was very easy to manage state. rule engines are great for this
<White_Flame>
it's a crying shame that they have been relegated to "business rules" systems, instead of as common software development tools
<White_Flame>
we embrace the latter, but tools are proprietary for now
<White_Flame>
Lisa is the main lisp fc rule engine I've found, but I haven't actually used it for real
<zephyr>
do you recall if you used rules to trigger modification of stateful UI objects? or where you working with more primitive graphics
<zephyr>
i'd be curious to know also if you represented graphical objects themselves in the fact base, or if they were managed externally
karlosz has joined #commonlisp
pve has quit [Quit: leaving]
<White_Flame>
zephyr: yeah, for instance when some rule holds true, set a UI element to active, and when ot goes false set it to inactive
<White_Flame>
it would be harder to do bidirectional binding in this model I think, but reflection from data onto screen is easy, and from GUI input to trigger fact is easy
<White_Flame>
and yes, we've done full server-based rule driven GUIs for webpages, including layout and schema being defined in facts & rules
<White_Flame>
which where if you changes those facts, the screen would reflect new form layouts etc in realtime without needing refreshing
<White_Flame>
*change
<Nilby>
Fancy UI layout things (html5,qt) are like rule engines
<White_Flame>
or many constraint engines
<White_Flame>
*maybe
<Nilby>
I agree lot of normal apps could probably benefit from a decent rule engine.
prite has quit [Ping timeout: 248 seconds]
<White_Flame>
the one thing they're quite clunky with is serial processing & serial dependencies, but they can obviously represent them
<White_Flame>
but for command & control, monitoring, error detection, etc, it's WAY easier than imperative style
<White_Flame>
and of course data reflection
<White_Flame>
but, to most people in industry, you tend to get "that's not how you do it!" to "that's not possible", even when you show them :-P
johan_ has quit [Ping timeout: 248 seconds]
silasfox has quit [Ping timeout: 248 seconds]
notzmv has joined #commonlisp
<zephyr>
well, thanks for sharing your experiences, consider me emboldened :-)
johan_ has joined #commonlisp
<zephyr>
i have a system of "databases" (tuple sets) that compose under a query function to yield a new tuple set. and one can subscribe to tuples added/removed in the most recent transaction, and the connected tuple set states are consistent. the query language is datalog-like
<White_Flame>
of course, in the database world, some people do build stuff like that out of triggers, too. I've not tried it
<White_Flame>
(database as in RDBMS)
<zephyr>
right, yeah, a key aspect of my contraption is the dependency ordering to prevent glitches
<Nilby>
I added a rule engine without asking, and I got: "How'd you get your data so clean?"
silasfox has joined #commonlisp
<White_Flame>
Nilby: a database trigger based one?
<Nilby>
It was outside the db, but it was part of an external change propagator thing.
cage has quit [Remote host closed the connection]
nature has quit [Quit: Lost terminal]
Gnuxie has quit [Quit: node-irc says goodbye]
katco has quit [Quit: node-irc says goodbye]
loke[m] has quit [Quit: node-irc says goodbye]
katco has joined #commonlisp
Gnuxie has joined #commonlisp
loke[m] has joined #commonlisp
Colleen has quit [Ping timeout: 264 seconds]
Colleen has joined #commonlisp
<jmercouris>
interesting how many fewer nicks there are
<jmercouris>
I wonder how many were just idling for years upon years in #lisp
Duuqnd has quit [Remote host closed the connection]