<akater[m]>
mfiano: “Setting *print-pretty* to true [just] causes the functions contained
<akater[m]>
in the current pprint dispatch table to have priority over normal print-object method” — CLHS on `*PRINT-PPRINT-DISPATCH*`. But I don't know how to make it work.
<akater[m]>
phoe: Possibly a good topic for Common Lisp Recipes 2nd Edition — debugging pretty-printer. However it might be covered in the current edition; I can't check now.
waleee has quit [Ping timeout: 245 seconds]
notzmv has joined #commonlisp
igemnace has quit [Quit: WeeChat 3.2]
gaqwas has quit [Ping timeout: 248 seconds]
gaqwas has joined #commonlisp
hendursaga has quit [Ping timeout: 244 seconds]
hendursaga has joined #commonlisp
hendursaga has quit [Client Quit]
hendursaga has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
kulernil has left #commonlisp [Leaving]
prxq_ has joined #commonlisp
prxq has quit [Ping timeout: 248 seconds]
<beach>
Good morning everyone!
gaqwas has quit [Ping timeout: 248 seconds]
gaqwas has joined #commonlisp
<Josh_2>
Mornin' beach
dsk has quit [Ping timeout: 258 seconds]
esb has quit [Remote host closed the connection]
zos has quit [Quit: WeeChat 2.8]
taiju has quit [Ping timeout: 256 seconds]
taiju has joined #commonlisp
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
rain3 has quit [Remote host closed the connection]
rain3 has joined #commonlisp
taiju has quit [Ping timeout: 258 seconds]
selwyn has joined #commonlisp
Bike has quit [Quit: Lost terminal]
taiju has joined #commonlisp
taiju has quit [Ping timeout: 248 seconds]
lisp123 has joined #commonlisp
lisp123_ has joined #commonlisp
lisp123 has quit [Read error: Connection reset by peer]
fizbin has joined #commonlisp
selwyn has quit [Read error: Connection reset by peer]
fizbin has quit [Client Quit]
lisp123_ has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
akoana has quit [Quit: leaving]
lad has quit [Ping timeout: 248 seconds]
sander has joined #commonlisp
taiju has joined #commonlisp
jans1 has joined #commonlisp
jans has quit [Ping timeout: 248 seconds]
jans1 is now known as jans
dsk has joined #commonlisp
lotuseater has quit [Quit: ERC (IRC client for Emacs 27.2)]
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 258 seconds]
Lord_of_Life_ is now known as Lord_of_Life
makomo has joined #commonlisp
pve has joined #commonlisp
d4ryus has quit [Quit: WeeChat 3.2]
d4ryus has joined #commonlisp
amb007 has quit [Ping timeout: 245 seconds]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
dsk has quit [Ping timeout: 245 seconds]
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
amb007 has joined #commonlisp
sm2n has quit [Ping timeout: 248 seconds]
lisp123 has quit [Ping timeout: 268 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
lisp123 has joined #commonlisp
hendursa1 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
hendursaga has quit [Ping timeout: 244 seconds]
<pjb>
mfiano: debugging without the debugger usually involves printing. So debugging print-object without the debugger will be quite delicate…
<pjb>
mfiano: add forms to test and validate each object before you print it.
<pjb>
use slot-boundp etc.
selwyn has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
sander has quit [Ping timeout: 248 seconds]
sander has joined #commonlisp
lisp123 has quit [Ping timeout: 268 seconds]
lisp123 has joined #commonlisp
<lisp123>
beach: Thanks, I am on that page. Is there a 1:1 correspondence between :compile-toplevel & compile, :load-toplevel & load and :execute & eval?
<kakuhen>
Is there a point to sharp-quoting lambda expressions? From what I've read online, it seems like LAMBDA already macroexpands to what sharp-quote would've done for us, i.e. give us (function (lambda ...))
<beach>
There is no point.
<mfiano>
sharp quote is a reader macro that expands to (function ...), so it can only hurt
<mfiano>
Hurt in that it is more to type, and there are certain parts of the standard that require a lambda expression, not a function
<beach>
And sometimes you are not allowed to use #' on lambda expressions.
<mfiano>
The report of a condition for example cannot be a function, only a lambda expression.
<beach>
And other times doing so is not what you mean.
<beach>
I am thinking 1. ((lambda (x y) (+ x y)) 1 2)
<rain3>
pjb: or using stealth-mixin and defining describe-object :around for our avoid-circular-printing-mixin
<beach>
and 2. (compile nil '(lambda ...))
<kakuhen>
I see. Thanks for the explanations, beach and mfiano
<mfiano>
report-name::= string | symbol | lambda expression
<mfiano>
Nowhere is a function accepted for a condition
<beach>
That's interesting.
<beach>
Never thought about that.
nij- has joined #commonlisp
hafat has quit [Ping timeout: 272 seconds]
<nij->
hayley: :)
<hayley>
I seem to have invented a new code organisation problem. A few days ago, I started writing a model and proof that some fine-grained locking code would not race, as part of some internal design documents for what I considered to be a module with "subtle" properties.
<nij->
morning.
<nij->
hayley: good to know you're here. I was wondering which persistent memory method you'd recommend.
<hayley>
So, in the directory for that model, I made another directory Design/ which contains those documents. Now I wrote another model, but don't have any more documents (yet). Where should I put that model file?
<hayley>
nij-: Page 35 of the CLOSOS book <http://metamodular.com/closos.pdf> describes a logging mechanism. Loosely speaking, after enough memory is changed, the changes are saved to disk, and it is possible to "work backwards" and find the most recent copy of some memory.
<scymtym>
mfiano: you can open the object for which the error to print occurs in the (SLIME) inspector and press "p". that should invoke a debugger with the error you are interested in
amb007 has quit [Ping timeout: 268 seconds]
amb007 has joined #commonlisp
<nij->
hayley: theoretical but not implemented yet!?
<hayley>
Another problem is whether to make a Design/ directory for each module, or another tree which has parallel structure to the code, or another directory without nesting (assuming there are fewer files, so nesting is unnecessary).
<hayley>
nij-: Yes.
<nij->
Lemme think how this is possible to persist functions and closures.
<kakuhen>
What is the difference between c2cl and c2mop when I make use of the metaobject protocol?
<hayley>
nij-: Again, the mechanism literally copies the contents of memory to disk and back.
<hayley>
It would be like saving a Lisp image, except that you are constantly incrementally writing the image. And the working set of the Lisp system can be larger than primary memory, so really you are incrementally reading and caching the image from disk.
<hayley>
Well, I suppose my problem is not unlike figuring where to put tests. And I put them in a /Tests/ directory without any nesting as there are few enough files for it to work.
sander has quit [Quit: So long! :)]
sander has joined #commonlisp
Qwnavery has quit [Quit: WeeChat 3.2]
random-nick has joined #commonlisp
kakuhen has quit [Read error: Connection reset by peer]
waleee has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
MetaYan_ has quit [Ping timeout: 248 seconds]
<nij->
Can CLOSOS be implemented over UNIX?
<nij->
Starting it over is better of course, but it seems a whole lot of work.
amb007 has quit [Read error: Connection reset by peer]
<hayley>
Yes, but I would argue you don't get all the benefits.
amb007 has joined #commonlisp
frgo has quit [Remote host closed the connection]
frgo has joined #commonlisp
sander has quit [Ping timeout: 268 seconds]
MetaYan has joined #commonlisp
sander has joined #commonlisp
<nij->
But at least we can "write to core incrementally"?
<hayley>
Sure.
Qwnavery has joined #commonlisp
CrashTestDummy2 has quit [Quit: Leaving]
Alfr has quit [Remote host closed the connection]
Alfr has joined #commonlisp
Alfr has quit [Remote host closed the connection]
CrashTestDummy has joined #commonlisp
<nij->
Sounds very nice..
<hayley>
Indeed. Would save a lot of hair-pulling.
dsk has joined #commonlisp
<beach>
nij-: Unix could not be turned into CLOSOS by any incremental process. But what would perhaps be possible would be to reuse Unix device drivers.
<hayley>
1.4 of The Book suggests a reasonable process. Even the single-user system would allow for a persistent memory abstraction.
<beach>
Yes, but I don't think that's what nij- had in mind.
<hayley>
Of course, one is still subject to, say, attacks of the killer microseconds, for example. But (more recently) I can appreciate what is gained from the intermediate steps.
<hayley>
Right, the last question "Can CLOSOS be implemented over UNIX?" is best answered with "no". But the initial supposed question, something like "Can we have persistent memory on Unix?" can be answered with "yes".
<beach>
Right, I think I read something about that.
CrashTestDummy2 has joined #commonlisp
CrashTestDummy has quit [Ping timeout: 248 seconds]
Qwnavery has quit [Quit: WeeChat 3.2]
dsk has quit [Ping timeout: 245 seconds]
<lisp123>
Does anybody have the source code for CONCORDIA and/or Symbolic Graphics Editor?
<rain3>
hayley: "Another problem is whether to make a Design/ directory for each module, or another tree which has parallel structure to the code" the 2nd one is not good, in my experience
<hayley>
I wouldn't be surprised if the only legal avenue was to buy a Genera license.
<lisp123>
Would that be likely to have the source code?
<beach>
lisp123: I believe that code is proprietary.
<hayley>
Yes.
<lisp123>
beach: Thanks
<lisp123>
I guess its not currently possible to buy a genera license (please don't get my hopes up)?
<hayley>
It is possible, but it would cost a lot of money.
<lisp123>
hayley: Thanks. Looks like $5,000 based on google
<rain3>
haylay: if that guy is right then tests for a module should be attached to that module, they should not be somewhere far away in a parallel directory
<hayley>
I thought this guy was just trying to sell me a graph database.
<beach>
lisp123: What would you do with it?
<lisp123>
beach: Nothing except to read the source code for CONCORDIA. But $5,000 is too much for just that, a couple of hundred might have been okay
<beach>
Yes, I see.
<lisp123>
I am curious if it did anything particularly different vs. other editors
<hayley>
Maybe I am too dense to get it, but there isn't anything about testing modules in that article.
<hayley>
But the issue is that I cannot create arbitrary links with a filesystem, so I have to pick what comes "closer" in the directory hierarchy.
lisp123 has quit [Ping timeout: 248 seconds]
<hayley>
The tests are also another module, for example, so it looks weird to have two modules sharing the same directory hierarchy.
<phantomics>
beach: I recall there was a proposal once for a CL-based init system as part of the discussions that led to systemd. That wouldn't be a CL-based Unix but it could catalyze the replacement of significant GNU/Linux system facilities with CL-based software; something like that could ease adoption of a CL-based OS, with portions of the init system ported over. Would be much better than systemd at any rate.
<hayley>
It'd still be a Unix.
<hayley>
An analogy would be that I don't think the existence of Ltk makes it easier to adopt CLIM.
<Gnuxie>
i'm not exactly sure what it is or what to make of it yet, but i am relaying this because we should probably know about this as a community considering newbies are going to be put through this program
hisacro has joined #commonlisp
<Gnuxie>
ok it's not as bad as i thought, it's some non profit with community contributions, they've only had 2000 people click the button to start the program
<hayley>
The example DISTANCE function already violates the LUV rules.
<akater[m]>
phantomics: I often think that init system is a very suitable target for a CL project. And systemd made the idea of a rich init more acceptable or even mainstream. If I knew how to turn it into a startup, it would be a very interesting one.
<hayley>
I guess all the code is that of the students, and I couldn't tell how good the mentors are. The exercises seem...underdescribed from what I can see without signing up or anything. The solutions produced are decent enough, so the course should be okay at least.
<beach>
phantomics: I don't know much about init systems, but any Unix code written in an unsafe language without automatic memory management would be a good candidate for a Common Lisp replacement. Whether that will facilitate adoption of a Lisp OS I don't know.
<beach>
phantomics: Some widely used applications would be good candidates as well, like `evince', for instance.
<hayley>
The main issue I remember from flicking though the solutions was the use of WHEN to return NIL or some value. Otherwise, nothing bad.
<hayley>
Oh, the description of Common Lisp mentions CLOS and macros but there are no exercises utilising either. And don't tell beach that they use the wrong binary search algorithm.
lotuseater has joined #commonlisp
selwyn has quit [Read error: Connection reset by peer]
<lisp123>
hayley: do you have a copy of the 'right' binary search algorithm?
<lisp123>
seems useful to have on file
cosimone has joined #commonlisp
<hayley>
The right search algorithm only checks equality when the range has been narrowed down to one element, from memory.
<beach>
Correct.
<phantomics>
akater[m] and beach: there is the Guile Scheme-based GNU Shepherd for Guix, so Lisp-based init systems already have some history
<beach>
The wrong one makes two tests per iteration, so it takes twice the time.
<akater[m]>
phantomics: I'm aware of Guix. I don't know how dynamic Guile is; I see the value in an interactive and likely image-based init, Common Lisp style.
<phantomics>
Certainly, and with CL you could do something much more modular than systemd
<phantomics>
The old init systems had their problems, but replacing them with an opaque monolith was not the way to go
<nij->
I was on Guix for a week, and couldn't figure out how to compile a package. Thus ducked out.
<beach>
I should watch that YouTube video that keeps popping up, entitled "The Tragedy of systemd".
<nij->
IIRC that's not really bashing systemd @@
<nij->
despite its name
<beach>
Oh!
<akater[m]>
Meanwhile, I find myself using the Info version of ANSI Common Lisp draft instead of CLHS quite often. Faster full-text search does make a difference, and for helm users, there's auto-generated `helm-info-ansicl` and while it does have its drawbacks compared to `hyperspec-` family, it's not bad and likely could be improved. And ansicl draft sources are public domain.
<random-nick>
guile is reasonably dynamic afaik, they even have a clos-like system called goops and I think shepherd uses it
<random-nick>
but I think they made class redefinition disabled by default in guile 3
cosimone` has joined #commonlisp
cosimone has quit [Ping timeout: 272 seconds]
cosimone` has quit [Ping timeout: 248 seconds]
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 268 seconds]
elf_fortrez has quit [Ping timeout: 246 seconds]
lisp123 has joined #commonlisp
cross has quit [Ping timeout: 240 seconds]
cross has joined #commonlisp
attila_lendvai has joined #commonlisp
gethuen has joined #commonlisp
Oddity has quit [Remote host closed the connection]
<pjb>
rain3: yes, I suppose using print-unreadable-object without a body is safe. That should work.
<pjb>
mfiano: You could define a funcallable object that mixins with a condition ;-)
<mfiano>
As mentioned, the problem was about reading out of bounds in unsafe code. At that point, all bets are off.
amb007 has quit [Ping timeout: 268 seconds]
<pjb>
hayley: I think I tend to adopt a flatter directory structure. I have subdirectories for specifications, analysis, design and documentation in addition to sources in the toplevel directory of the project, but rarely subdirectories in there. I assume that the structure of the software can change without notice (refactoring, etc). A design for a module would just be a chapter in the design document, so perhaps an included file if it's a
<pjb>
big document, but more probably just a org-mode section…
<pjb>
hayley: if you adopt a more "modular" directory structure, then keep doing it systematically (even if empty subdirectories are optional).
<rain3>
pjb: "You could define a funcallable object that mixins with a condition" I don't know this technique, how does it work ?
<pjb>
hayley: module_x/{specifications/,design/,sources/,submodules/submodule_y/{specifications/,design/,sources/}} etc.
<pjb>
rain3: I've never done it, ask beach. I just know there's a funcallable-standard-object class in MOP, and you can subclass it like any other class, and its instances can be called like normal functions.
<pjb>
You probably have to implement a special method to implement the "function" call.
<rain3>
yeah, and what about the 'mixing in with a condition ' part
<pjb>
this is just multiple-inheritance: (defclass my-function-condition (c2mop:funcallable-standard-object condition) ()) (handler-case (signal 'my-function-condition) (my-function-condition (funcond) (funcall funcond) (signal funcond)))
jfrent has joined #commonlisp
<rain3>
and how to use it for debugging objects with unbound slots <<error printing object>>
psycomic has joined #commonlisp
<pjb>
I don't know. I just responded to: <11:41:15><mfiano> Nowhere is a function accepted for a condition
amb007 has joined #commonlisp
<mfiano>
Oh that.
<rain3>
oh
<rain3>
Okay
Krystof has joined #commonlisp
<mfiano>
pjb: How would you mixin with a condition if conditions are not specified to be CLOS objects?
<mfiano>
I didn't know you could do that, given condition is a direct subtype of T
<mfiano>
and not, say, standard-object
<mfiano>
and then there's also the conformance rules: "define-condition, not defclass, must be used to define new condition types." and "make-condition, not make-instance, must be used to create condition objects explicitly."
<pjb>
mfiano: I don't think it's a problem.
<mfiano>
I don't agree given those rules.
<pjb>
but you're right, you'd have to give a meta-class that's compatible with both.
<mfiano>
You cannot create a condition with standard class machinery.
<mfiano>
To be conforming you MUST use define-condition
<pjb>
Yes, it's not possible conformingly (already, funcallable objects is a MOP extension anyways).
char has joined #commonlisp
selwyn has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 268 seconds]
heretical_crypte has joined #commonlisp
<char>
is there a portable way to rename bordeaux threads?
robin has joined #commonlisp
<random-nick>
bordeaux-threads has the nickname bt
<fe[nl]ix>
char: why do you ask ?
<char>
random-nick: I mean rename a bordaux thread
<char>
fe[nl]ix: when a thread is started by the usocket server it names it "usocket client". I would like to name it something else.
<fe[nl]ix>
you need to fix usocket
<random-nick>
char: doesn't seem like bordeaux-threads has support for renaming
bothillinois has joined #commonlisp
<char>
fe[nl]ix: what do you mean by that?
<random-nick>
and to implement renaming you'd have to implement it on all the supported implementations, since the implementations usually give that name to the OS
jeosol has quit [Ping timeout: 248 seconds]
<fe[nl]ix>
there's no concept of thread name on Unix, maybe on Windows
<lotuseater>
pjb: aren't there also smart pointer in C++?
<pjb>
Yes :-)
<lotuseater>
smart ^^
<lotuseater>
so objects in a non weak hash table aren't touch by the garbage collector?
amb007 has quit [Ping timeout: 258 seconds]
amb007 has joined #commonlisp
<char>
lotuseater: I think it is the opposite
<lotuseater>
hmm
<lotuseater>
ah wait, so if a weak hash table gets garbage collected all elements it references will too
<Bike>
a "weak" reference is basically one the garbage collector doesn't follow. So if an object is not referenced by anything except a weak reference it can be collected.
<Bike>
The hash table itself works under normal collection rules. It won't be collected unless nothing refers to it, and its keys and values won't be collected when it is unless there are no other references to them.
<Bike>
In a normal, non-weak hash table, the garbage collector will follow the references in the hash table, so the keys and values can't be collected unless the hash table is. At that point, they can be collected if the hash table was the only thing referencing them, and otherwise can't be.
<random-nick>
there's also the added requirement where objects which are collected will disappear from weak hashtables and weak-pointers pointing to them will become empty
<random-nick>
that prevents the existence of invalid weak references
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Ping timeout: 268 seconds]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<moon-child>
am I allowed to mutate &rest parameters?
<Bike>
no. implementations are allowed to skip copying them when a function is applied
<Bike>
"Because a function can neither detect whether it was called via apply nor whether (if so) the last argument to apply was a constant, conforming programs must neither rely on the list structure of a rest list to be freshly consed, nor modify that list structure."
<Bike>
i mean, you can mutate the variable itself
<Bike>
(lambda (&rest r) (setf r ...)) is fine
<moon-child>
hmm so
<moon-child>
if I only ever call the function directly, or apply to a _non-constant_ argument list, it's ok to mutate?
<mfiano>
(lambda (&rest r) (nreverse r)) is not
<mfiano>
moon-child: no
<mfiano>
conforming programs means all programs, regardless of these functions' access patterns
<White_Flame>
mutating the values in a &rest list should be fine, though, right?
<Bike>
moon-child: an implementation could rewrite "direct" calls into some other form
palter has quit [Ping timeout: 256 seconds]
<Bike>
if you really want to mutate, just copy-list first and you're fine
<moon-child>
ah, so ((lambda (&rest x) ...) 1 2) could be rewritten into ((lambda (x) ...) '(1 2))?
jcowan has joined #commonlisp
<moon-child>
Bike: I was just curious; don't have a practical application for this
<mariari>
I've had some weird beahviors from mapcan due to the mutation aspect of it
<Bike>
that is something that could happen, yes.
travv0 has quit [Read error: Connection reset by peer]
alanz has quit [Ping timeout: 240 seconds]
conjunctive has joined #commonlisp
drmeister has quit [Ping timeout: 258 seconds]
ullbeking has quit [Ping timeout: 258 seconds]
jhi has joined #commonlisp
travv0 has joined #commonlisp
palter has joined #commonlisp
ullbeking has joined #commonlisp
jsatk has joined #commonlisp
drmeister has joined #commonlisp
alanz has joined #commonlisp
<Bike>
implementations can do pretty exotic optimizations. for example on sbcl, if you don't use a rest list as conses (e.g. you only iterate over it and/or use it for more apply calls) it won't allocate a list at all
stylewarning has joined #commonlisp
<White_Flame>
moon-child: in sbcl, the &rest list itself might not be a cons-based list at all, but just directly accessing/iterating over stack slots. The devs finding that optimization opportunity does preclude any cons cell-based mutation
<White_Flame>
(missed it by *that* much)
Guest54 has joined #commonlisp
hendursa1 has quit [Remote host closed the connection]
hendursa1 has joined #commonlisp
<pl>
SBCL will happily let you mutate things that shouldn't be mutated if you do safety 0 speed 3
iisi has joined #commonlisp
IUSR has joined #commonlisp
d_run has joined #commonlisp
jmercouris has joined #commonlisp
Guest54 has quit [Client Quit]
gendl has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
frgo has quit [Quit: Leaving...]
lisp123_ has joined #commonlisp
rain3 has quit [Ping timeout: 258 seconds]
lisp123 has quit [Ping timeout: 258 seconds]
lisp123 has joined #commonlisp
lisp123__ has joined #commonlisp
lisp123_ has quit [Ping timeout: 252 seconds]
cage has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
lisp123 has quit [Ping timeout: 252 seconds]
amb007 has joined #commonlisp
tyson2 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
peterhil_ has quit [Quit: Must not waste too much time here...]
peterhil has joined #commonlisp
bothillinois has quit [Changing host]
bothillinois has joined #commonlisp
lisp123__ has quit [Remote host closed the connection]
CrashTestDummy3 has joined #commonlisp
kakuhen has joined #commonlisp
lisp123 has joined #commonlisp
CrashTestDummy2 has quit [Ping timeout: 258 seconds]
bothillinois has quit [Quit: leaving]
derelict has quit [Quit: WeeChat 3.2]
lisp123_ has joined #commonlisp
seanw has quit [Quit: leaving]
asarch has joined #commonlisp
lisp123 has quit [Ping timeout: 252 seconds]
lisp123_ has quit [Ping timeout: 252 seconds]
<nij->
Anyone had experience with loading maxima into the lisp repl?
<lotuseater>
you mean calling maxima from CL
<nij->
Yeah.. uhm I guess it's the same cuz it's implemented in cl.
dsk has joined #commonlisp
derelict has joined #commonlisp
<pl>
nij-: it might be... an experience
<pl>
Maxima is, iirc, a weird amalgam of MACLISP, Franz and Common Lisp
<pl>
and I think it doesn't use any of the modern build options
<nij->
But following its instruction leads to an error ---- Just performed compiling #<QUADPACK-FORTRAN-FILE "em-quadpack" "fortran" "dqawfe"> but failed to mark it done
<nij->
pl! Thanks lemme try that method.
<pl>
nij-: Common Lisp evolved, among other things, from MACLISP (and Franz was essentially MACLISP ported to Unix), and thus Maxima was updated to be compatible - but huge amounts of code are veery old style
<pl>
also consider that it doesn't take much to make most ancient Lisp code compilable on CL
<pl>
(this was a design goal, in a way)
<nij->
compiling.. I'm very excited.
<nij->
Wanted to do this months ago, but I was toooooo newb to even formulate what I wanted.
<nij->
(ha)
lisp123 has joined #commonlisp
<nij->
pl do you know why all CAS don't use sexprs as their syntax of lang?
<kakuhen>
I found an outdated documentation in CLiki. Not sure if relevant to this channel
<kakuhen>
I have copies of SBCL and CCL from MacPorts. They are virtually identical to copies you can contain upstream. That is to say, SB-ALIEN definitely exists in SBCL, and CCL comes with it's own FFI and the Objective-C bridge, too.
<pl>
nij-: most CAS are geared towards standard algebraic input (even Maxima does that, in a way)
<pl>
internal representation is rarely exposed
<kakuhen>
s/contain/obtain
<nij->
pl but that makes it harder for people to add new mathematical structures..
<akater[m]>
kakuhen: Feel free to edit CLiki if you're certain. (Know what Fink is?)
psycomic has quit [Remote host closed the connection]
psycomic has joined #commonlisp
<moon-child>
mathematica's 'canonical' format is m-expressions, it allows the use of traditional mathematical notation as shorthand
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
lisp123 has quit [Ping timeout: 268 seconds]
<akater[m]>
moon-child: It's not Mexprs that allow that but rather the FrontEnd interface.
<kakuhen>
akater[m]: I don't personally use Fink, but CLISP is no longer in Fink, and so the statement is vacuously true I guess?
<kakuhen>
Anyway I didn't know I was able to edit CLiki myself, so I'll do that soon
<kakuhen>
A quick search in fink's main repo shows no results for Fink, so I'm not sure how useful including the first half of that sentence is :P
<kakuhen>
no results for CLISP*
<akater[m]>
…You could have the same with sexprs, and I heard loke's interface does that.
<lotuseater>
mathematica is very consistent and mnemonic in naming
<akater[m]>
kakuhen: I have no idea what Fink is so you know better.
<akater[m]>
Yes, Mathematica is great. It brought me to Lisp.
<nij->
akater[m]: loke?
<lotuseater>
akater[m]: oh cool
<akater[m]>
I guess maxima-client is written by loke and used to be called CLIMaxima.
<lotuseater>
it could be interesting to work at Wolfram, but their code case must be huge with much legacy stuff in older C++
<nij->
lotuseater: I never know how to get started with mathematica. Any thought? Is there a cl binder?
<lotuseater>
hm no you do Wolfram Language
CrashTestDummy2 has joined #commonlisp
<akater[m]>
Yep, maxima-client is by @loke@functional.cafe (ActivityPub account)
<akater[m]>
lotuseater: I was under the impression they only used C but I might be wrong.
<lotuseater>
i think SMP the ancestor was mostly in C and Fortran
<lotuseater>
then it evolved, started using C++ and Java or so
CrashTestDummy3 has quit [Ping timeout: 268 seconds]
asarch has quit [Quit: Leaving]
<akater[m]>
lotuseater: I'm sorry, are you aware a PM chat was initiated (by you)? I'm using Matrix bridge, there might be surprising behaviour on both sides.
psycomic has quit [Ping timeout: 272 seconds]
<lotuseater>
*magic*
<Josh_2>
Hi
lisp123 has joined #commonlisp
taiju has quit [Ping timeout: 245 seconds]
pve has quit [Quit: leaving]
minion has quit [Remote host closed the connection]
specbot has quit [Remote host closed the connection]
karlosz has joined #commonlisp
lisp123 has quit [Ping timeout: 268 seconds]
seanw has joined #commonlisp
specbot has joined #commonlisp
minion has joined #commonlisp
kulernil has joined #commonlisp
kuler has quit [Ping timeout: 244 seconds]
selwyn_ has quit [Read error: Connection reset by peer]
hendursa1 has quit [Ping timeout: 244 seconds]
attila_lendvai has quit [Ping timeout: 272 seconds]
taiju has joined #commonlisp
hendursa1 has joined #commonlisp
<lotuseater>
hey Josh_2 :)
<Josh_2>
'ello
karlosz has quit [Quit: karlosz]
akoana has joined #commonlisp
gaqwas has quit [Ping timeout: 256 seconds]
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #commonlisp
kulernil has quit [Remote host closed the connection]
kulernil has joined #commonlisp
blihp has joined #commonlisp
lisp123 has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
kulernil has quit [Ping timeout: 244 seconds]
blihp has quit [Quit: Leaving]
lisp123 has quit [Read error: Connection reset by peer]
blihp has joined #commonlisp
blihp has quit [Client Quit]
blihp has joined #commonlisp
blihp has quit [Client Quit]
blihp has joined #commonlisp
Qwnavery has joined #commonlisp
dsk has quit [Ping timeout: 272 seconds]
lisp123 has joined #commonlisp
lisp123 has quit [Read error: Connection reset by peer]
lisp123 has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
lisp123 has quit [Read error: Connection reset by peer]