freenode/#lisp - IRC Chatlog
Search
20:00:17
random-nick
I might be missing something, but it seems the groveller doesn't have anything for creating function bindings
20:37:51
phoe
you can later distribute the binding specs to everyone along with your library; no need for them to have clang
20:54:09
void_pointer
The one downside is that you have to run it for each processor architecture and sometimes OS you want to target (because the width of an int can change radically between architectures and even OSes on the same architecture)
20:58:09
aeth
cl-autowrap has problems that borodust fixed with claw. https://github.com/borodust/claw
20:58:35
aeth
In particular, borodust seems to have removed most of the things that introduce performance penalties.
20:58:42
void_pointer
Also, if you are interfacing POSIX libraries, you have to be prepared for the sizes of things changing from Linux, Mac OSX, the various BSDs, etc.
21:00:50
void_pointer
c2ffi can be better in some cases here, like extra fields in standard structs (e.g. Mac OSX has an extra field in sockaddr that isn't on Linux)
21:03:50
void_pointer
Basically, depending on how many systems one is targeting, the build matrix for the spec files can get rather large
21:05:18
equwal
void_pointer: That sounds unpleasant. We do have lots of VM technology available and CI, so it should be possible to only manually do the process once.
21:09:00
void_pointer
That certainly does help. With Linux and most BSDs on most platforms, it should be pretty easy with VMs with or without CI. Windows' high backwards compatibility makes it fairly easy since you only need to do it for one version. Mac OSX is maybe the wild card. Oh, and of course, if one is doing smart phones, well, good luck.
21:10:35
fe[nl]ix
cffi-grovel and manually creating bindings have one advantage: you only define what you use
21:11:06
equwal
Yeah, I mentioned CI since it helps by automatically doing it when a pull request is made. What would a travis.yaml, GUIX config, or docker file look like to generate these automatically? Do we have an example to start with?
21:11:11
fe[nl]ix
you can even have a struct with 20 fields, but if you only need one you can just define that and the groveler will figure out the struct size and field offset
21:24:27
aeth
random-nick: Try its fork claw instead, then. Worst case scenario, neither work, but borodust (the fork author) is in this channel. https://github.com/borodust/claw
21:28:33
aeth
random-nick: and then there's the option of manually using cffi-grovel that fe[nl]ix said
21:49:54
void_pointer
though that is brittle, but this is the nature of many projects in their early states
21:51:21
void_pointer
unless one is of the literate programming persuasion, design first and code second, or really into making documentation as one goes; that is how it is (and sadly, some projects never get their documentation)
21:56:46
aeth
void_pointer: I have a literate programming library but it's entirely undocumented at the moment ;-)
21:57:36
aeth
void_pointer: It's a joke. If it's undocumented and documentation comes first, then it's empty, i.e. not there.
21:58:41
void_pointer
aeth: with literate programming, one does have to start somewhere to bootstrap, though that is where external documentation and comment documentation come in
0:29:58
White_Flame
z147: btw, in the vocabulary I'm around, "rule-based" systems tend to talk about production rules, not prolog (although that can be part of it)
0:56:17
z147
White_Flame, i'm going through the archive at CMU Artificial Intelligence Repository, lots to contemplate
0:58:54
White_Flame
yeah, but really it sounds like you need to define the general workflow of the software you'd like to have first, then look at tools that might deliver that. THere's an infinite rabbit hole of tech variations otherwise
1:12:21
z147
White_Flame, i usually prefer to get a fast idea with as many quick prototypes as possible
1:13:16
z147
the systems i've been exposed to were closed, vendor-specific java, with what I saw under the hood, very simple rule matching
1:22:26
White_Flame
are you looking for raw rule tech, or something that's fleshed out with a bunch of dialogs and such to interact with the humans? all the open source stuff is the former, except for maybe jboss rules
1:25:17
z147
White_Flame, i prefer to do exploratory use as part of my specification development. So i'm not limiting anything at this time.
1:25:44
z147
from the market point, i'm looking at existing systems outside of CL and what their limitations are
1:26:49
White_Flame
but if what you want is GUI-driven human interaction, that's more software written on top of those layers than rule engines themselves
1:27:43
White_Flame
the rule engines used to be called "expert system shells", in that you use them to create expert systems, so they're not immediately able to do "expert" stuff in the common case. So that's the sort of thing I'm wondering about your search
1:30:50
White_Flame
often times, there'd be a domain expert, but they wouldn't do anything with the system; the "knowledge engineer" would encode what they deal with the expert into the rule forms
1:31:15
White_Flame
some advanced systems sought to allow the domain expert to directly enter stuff, and that's a whole other system
1:31:28
z147
what happened to expert system shells, the term fell off the radar, the approach remains in other forms?
1:31:58
White_Flame
the tech went mostly into BRMS (business rules management systems), where they became less interactive
1:32:22
White_Flame
most of the stuff that I saw had you select which ruleset to use, and which data to seed it with, then it ran to completion and gave you an answer
1:32:33
White_Flame
so it ends up being a fancy function call instead of a dynamic interacting system
1:33:08
White_Flame
so you have a big Java enterprise application, that makes calls out to the BRMS to make configurable decisions
1:33:55
z147
I suppose it's called expert systems and rules management as far as current publications
1:34:00
White_Flame
which is completely different than the older style where the system would dialogue with the user, asking questions abotu stuff it didn't know
1:34:39
White_Flame
that dialoguing system is something built on top of the rule engines; it's not an implicit feature of them
1:35:13
White_Flame
or at least, not of the standard model of especially open source ones. That dialoguing was commercial special sauce
1:36:04
White_Flame
but again, the modern stuff eschews interactivity and simply crunches a result from input facts in batch
6:10:41
ecraven
just out of interest, does CLOS offer support for setting the *print-base* of slots? so when printing or inspecting an object, some slots would automatically be shown in a different base?
6:27:12
beach
... at least to some extent. The inspector of SBCL does not use DESCRIBE, so an :AROUND method on DESCRIBE-OBJECT will not work in that case.
6:28:53
beach
ecraven: I recommend you use Clouseau instead. It is much more flexible in terms of configuration and customization.