jackdaniel changed the topic of #lisp to: Common Lisp, the #1=(programmable . #1#) programming language<http://cliki.net/> logs:<https://irclog.whitequark.org/lisp,http://ccl.clozure.com/irc-logs/lisp/> | SBCL 1.4.5, CMUCL 21b, ECL 16.1.3, CCL 1.11.5, ABCL 1.5.0
Essadon has quit [Quit: Qutting]
hel-io has joined #lisp
slyrus1 has joined #lisp
benjamin-l has joined #lisp
hel-io_ has joined #lisp
robotoad has quit [Quit: robotoad]
hel-io__ has joined #lisp
hel-io has quit [Ping timeout: 264 seconds]
myrkraverk has joined #lisp
hel-io has joined #lisp
hel-io_ has quit [Ping timeout: 264 seconds]
hel-io__ has quit [Ping timeout: 252 seconds]
<stylewarning> }-{ello
pillton has joined #lisp
hel-io has quit [Ping timeout: 252 seconds]
smokeink has joined #lisp
nanozz has joined #lisp
ryan_vw has quit [Ping timeout: 252 seconds]
<stylewarning> Has anyone in here significantly worked with a language that has ADTs?
fsmunoz has quit [Ping timeout: 246 seconds]
nanozz has quit [Ping timeout: 272 seconds]
<LdBeth> Forth?
<stylewarning> ADT => algebraic data types, which Forth certainly doesn't have
<fiddlerwoaroof> I've done a bit of Haskell and work with people who write production Haskell apps
<stylewarning> I ask because I'm wondering what folks would find convenient as an interoperable representation in Lisp.
<stylewarning> I'm thinking just symbols and simple-vectors
<fiddlerwoaroof> Interoperable in what sense?
<stylewarning> in the sense that if you were to define an ADT in, say, Haskell, and you wanted to work with a representation of that in Lisp
<fiddlerwoaroof> Memory representation or a "wire" protocol?
<stylewarning> i see 3 options: symbols+vectors, a tree of structs, a tree of classes
<stylewarning> fiddlerwoaroof: an object representation in Lisp
robotoad has joined #lisp
<LdBeth> stylewarning (IRC): a tree of cons
<fiddlerwoaroof> I personally prefer subclassing to model the things that Haskell/etc. uses ADTs for
<fiddlerwoaroof> Because Haskell is built around a "closed world" assumption: its type system assumes that all the relevant types are known at compile-time
<stylewarning> yes
<fiddlerwoaroof> But that's not a good assumption in lisp
<Bike> i'd like a tree of structs, matches other langauges
<stylewarning> Bike: that's what I do in CL-ADT, but it has been inconvenient for re-definition, and inconvenient for creating constants
<Bike> why inconvenient for constants?
<White_Flame> instead of symbols and simple-vectors, if you used symbol and cons type specifiers, along with OR or MEMBER types, wouldn't that cover most the bases?
<LdBeth> ^ argee
<stylewarning> Bike: Well it's not so bad, but I haven't been able to guarantee EQ-constness with structs
<Bike> ah. yeah.
<White_Flame> the most glaring (and recurring) problem with simple-vectors is that their element type is locked to T
<stylewarning> (e.g., It Would Be Nice (TM) if (eq x None) for all x equal to None)
<Bike> right, yes.
<fiddlerwoaroof> Could your constructors do some interning?
<fiddlerwoaroof> e.g. make None a singleton and return the single value whenever a None is constructed?
<stylewarning> anyway the reason I ask is because i finally decided to cut all the nonsense out and take the plunge of implementing a strictly typed DSL in lisp with a focus on interoperability/incremental development
<stylewarning> fiddlerwoaroof: I do something sort of like that with CL-ADT
<fiddlerwoaroof> Cool, are you talking about something like Hackett?
<stylewarning> but I guess I don't know well enough all the nuance about compile-time load-time etc etc
<stylewarning> fiddlerwoaroof: yeah something like that, or PLAIT, or typed-racket
<fiddlerwoaroof> Well, hackett is fundamentally different from typed-racket.
<stylewarning> fiddlerwoaroof: my motivation isn't really to implement a whole new language; it's more to allow one to write statically typed and statically inferred pieces of Lisp code, in a way that isn't completely hermetically sealed off from the rest of your lisp program
<stylewarning> (e.g., to allow one to write safety-critical portions of their lisp programs in this DSL)
<fiddlerwoaroof> Yeah, I've been wanting that too. But the main benefit of types, for me at least, is _not_ the correctness guarantees
<stylewarning> Then what?
<LdBeth> dynamic dispatch
<fiddlerwoaroof> It's that, in a language with bidirectional type inference, you can use the types as a way to do some kinds of metaprogramming that is impossible with macros
<fiddlerwoaroof> e.g. you can pick the implementation to be used based on its return type
<stylewarning> Yeah, stuff like that sounds nice, having better compiler-macros and the like
<stylewarning> for me, where a lot of my job is writing compilers, the safety is what i care about a lot, because compilers are big and complicated and bugs are hard to find
<stylewarning> anyway, I have code here. It's not really functional. Maybe another weekend or two it will be a good enough MVP. Type inference works, type definitions almost work, compilation almost works, etc. https://github.com/tarballs-are-good/coalton
<LdBeth> or overloading, or polymorphism
<stylewarning> you can see some pedestrian examples of what does work now here: https://www.irccloud.com/pastebin/2CzwH3Iw/
kjeldahl has quit [Ping timeout: 276 seconds]
<fiddlerwoaroof> Cool
<fiddlerwoaroof> One day I'll get around to learning about type inference ;)
<stylewarning> it's a rabbit hole of interestingness
<fiddlerwoaroof> But, I've been keeping a list of bookmarks to follow up on here.
space_otter has quit [Remote host closed the connection]
<fiddlerwoaroof> The Type Systems as Macros paper that hackett is based on is the most interesting one to me because it seems to lead to an interesting part of the design space
<LdBeth> fiddlerwoaroof (IRC): Then the book Partial Evaluation and Automatic Program Generation is a good start
<fiddlerwoaroof> Where, since macroexpansion and type checking are interleaved, you can do interesting code-generation things
<stylewarning> idk, maybe. I think there's a lot of pay dirt in thinking about things with a very Common Lispy philosophy of building something useful and practical even if a bit muddy, instead of some new-fangled philosophy of program construction.
<fiddlerwoaroof> sure
<stylewarning> (with that said, I love that people are researching/looking into these things)
<fiddlerwoaroof> But, if you think of a typechecker as a program that reads your code and transforms it (at least by erasing your types), it makes sense to implement it as part of the macroexpansion phase of your program
<fiddlerwoaroof> The other thread is things like Shen and ACL2
<stylewarning> yes, provided you've buckled down the actual language you're typing
kjeldahl has joined #lisp
<LdBeth> ACL2 is about untyped logic
<fiddlerwoaroof> Yeah, the relevant thing there is that it's all about proving that certain rewrites of a program don't change the semantics
<fiddlerwoaroof> And ACL2 itself does type inference
<stylewarning> too bad lisp doesn't have global lexicals
<LdBeth> first class type -> untyped lambda, non first class type -> typed lambda
<LdBeth> And seems first class type has something to do with MOP
dorketch has joined #lisp
benjamin-l has quit [Remote host closed the connection]
benjamin-l has joined #lisp
<LdBeth> but the relation is still, vague
<fiddlerwoaroof> Anyways, there's way to many interesting things in Computer Science for the amount of free time I have
<fiddlerwoaroof> I should find a way to make some of these things part of my job :)
[X-Scale] has joined #lisp
equwal has joined #lisp
equwal has quit [Remote host closed the connection]
equwal has joined #lisp
X-Scale has quit [Ping timeout: 264 seconds]
[X-Scale] is now known as X-Scale
equwal has quit [Remote host closed the connection]
equwal has joined #lisp
equwal has quit [Remote host closed the connection]
equwal has joined #lisp
equwal has quit [Remote host closed the connection]
equwal has joined #lisp
jasmith has quit [Quit: Leaving]
anniepoo_ has quit [Ping timeout: 268 seconds]
equwal has quit [Remote host closed the connection]
equwal has joined #lisp
anniepoo has joined #lisp
equwal has quit [Ping timeout: 240 seconds]
slyrus1 has quit [Quit: slyrus1]
asarch has joined #lisp
<asarch> What's wrong with this compilation of SBCL in OpenBSD 6.4 for AMD64 (you have to enable the 'thread' flag in order to use McCLIM):
<asarch> Ups, sorry. I mean:
<asarch> The flags "threads native_bootstrap were used for this compilation
<asarch> I think this error was because the process used clisp to compile SBCL, right?
groovy2shoes has quit [Excess Flood]
groovy2shoes has joined #lisp
<fiddlerwoaroof> What command line are you using?
<asarch> cd /usr/ports/lang/sbcl && env FLAG="threads native_bootstrap" make install
<asarch> It used to work fine in the 6.3 release :-(
<fiddlerwoaroof> Hmm, I generally don't use system-provided versions of sbc
<fiddlerwoaroof> *sbcl
<fiddlerwoaroof> One strategy that might work is download a binary of sbcl from http://www.sbcl.org/platform-table.html and then use that to build the version you want
* asarch takes notes...
<fiddlerwoaroof> I generally install my preferred version of sbcl in ~/sbcl
<fiddlerwoaroof> I clone the git repo, checkout the tag for the release I want and then do ./make.sh --fancy --prefix=$HOME/sbcl
<asarch> Wow! Like most NodeJS users do
<asarch> Ok
<fiddlerwoaroof> If you're using the binary distro, I think you need to also specify the --xc-host option, so that would look something like ./make.sh --fancy --prefix=$HOME/sbcl --xc-host=/path/to/binary/edition/run-sbcl.sh
<fiddlerwoaroof> and then, once that finishes, do ./install.sh
<asarch> Ok
<asarch> Thank you fiddlerwoaroof
<asarch> Thank you very much :-)
<fiddlerwoaroof> But, also, OpenBSD is probably a less-used platform so you're likely to find bugs
<fiddlerwoaroof> I'd ask in #sbcl if you can't get a clean build
<asarch> Ok
esrse has joined #lisp
<asarch> I'm planning to port those games from the YouTube video to Common Lisp using McCLIM (I hope at least I could one of them)
igemnace has joined #lisp
<asarch> Bleh! It failed! :-(
<no-defun-allowed> ):
hel-io has joined #lisp
pierpal has quit [Ping timeout: 245 seconds]
Kundry_Wag has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
hel-io has quit [Ping timeout: 252 seconds]
<stylewarning> stuff that's working in Coalton https://github.com/tarballs-are-good/coalton#examples
<stylewarning> hopefully one can see the vision of it
pierpal has joined #lisp
<stylewarning> lots of work and polish left to do still though.
dorketch has quit [Quit: WeeChat 2.3]
Kundry_Wag has quit [Remote host closed the connection]
dorketch has joined #lisp
dale has quit [Quit: dale]
<fiddlerwoaroof> hmm will this support things like haskell's mempty?
<fiddlerwoaroof> where mempty :: List _ = [] but mempty :: Maybe _ = None ?
<fiddlerwoaroof> (I believe this is called "Phantom Types", iirc)
<dorketch> [1]> (I believe this is called "Phantom Types", iirc)
<dorketch> *** - READ: comma is illegal outside of backquote
<dorketch> The following restarts are available:
<dorketch> ABORT :R1 Abort main loop
<Bike> um?
<dorketch> I tried to repl the list in parentheses and that's what clisp threw back
<adlai> dorketch: even in #clnoobs they're not gonna take kindly to multiline pastes of not understanding how the reader works.
<Bike> no shit
<adlai> clhs 2
<adlai> dorketch: your princess awaits in that castle right there. good luck.
<dorketch> you people don't take jokes. I'll leave now
<dorketch> sorry
dorketch has left #lisp ["WeeChat 2.3"]
<adlai> dunno, i think that the sin tax is actually quite funny.
orivej has joined #lisp
pierpal has quit [Ping timeout: 252 seconds]
arescorpio has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
Roy_Fokker has quit [Read error: Connection reset by peer]
<pillton> stylewarning: I thought Mark Tarver did something like what you are proposing.
<stylewarning> pillton: i don't see people embedding Shen into their CL code
<stylewarning> Shen seems to have preference to be it's own language
<stylewarning> fiddlerwoaroof: I'm not sure. Maybe in the future.
<pillton> stylewarning: I thought he wrote a CL in CL which was type safe. I remember something about a type safe Tcl/Tk binding.
<stylewarning> pillton: Hm, I'm not familiar then.
slyrus1 has joined #lisp
<pillton> stylewarning: Well, I have exceeded my time to try and find out. My memory might be failing.
Oladon has quit [Quit: Leaving.]
loke` has joined #lisp
slyrus2 has joined #lisp
quazimodo has joined #lisp
dale has joined #lisp
ikki has quit [Ping timeout: 245 seconds]
pjb has quit [Ping timeout: 252 seconds]
<fiddlerwoaroof> I believe Qi is something like that
nanoz has joined #lisp
quazimodo has quit [Ping timeout: 268 seconds]
<stylewarning> fiddlerwoaroof: Qi and Shen are similar in this regard
quazimodo has joined #lisp
<fiddlerwoaroof> Yeah, I think there's this cultural thing that makes it so that most people are uninterested in static/dynamic interop
<stylewarning> fiddlerwoaroof: I don't think that's true. The thing with Shen/Qi is that they're presented as a "all or nothing" solutions.
<fiddlerwoaroof> I dunno, there are things like typed racket and core.typed in Clojure
<stylewarning> fiddlerwoaroof: yes, and do you think such things aren't used much?
<fiddlerwoaroof> I don't know the racket ecosystem
<fiddlerwoaroof> But, I've never seen much uptake of core.typed
<fiddlerwoaroof> Anyways, I've heard that Shen has pretty good interop with its host implementation
<fiddlerwoaroof> But, I've always been put off by Tarver's attitude towards open source
<stylewarning> fiddlerwoaroof: Shen compiles to Lisp (or whatever host), but it doesn't appear to be *designed* to interoperate.
<stylewarning> In the sense that the expectation is that you use Shen and the host in a mixed fashion. But I might be wrong.
<stylewarning> And yeah, the whole Shen/Qi open source thing was annoying.
<on_ion> =(
arescorpio has quit [Quit: Leaving.]
<LdBeth> There’s criticize on racket’s ecosystem as just good enough for making demonstration
Oladon has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
<beach> Good morning everyone!
<fiddlerwoaroof> morning beach
ryan_vw has joined #lisp
mathrick_ has quit [Ping timeout: 264 seconds]
<LdBeth> Morning
<anniepoo> I keep running into 'widetag'. Can somebody define what a widetag is?
<anniepoo> (SBCL)
<anniepoo> Thanks beach
<beach> Sure. It looks somewhat complicated if I may say so.
<anniepoo> 8cD I have foolishly agreed to do some 'routine cleanup' on stylewarning's code.
<anniepoo> 8cO
<beach> Unless you are working on SBCL internals, you should not have to think about tags at all.
<beach> It's an implementation detail.
<anniepoo> I'm writing (cleaning up) a tool to strip out a bunch of info after compilation, to deliver a minimal size runtime object file
<beach> I see.
<anniepoo> 8cD <-- idiot Prolog programmer, hasn't written any CL since the 90's.
mathrick_ has joined #lisp
<beach> A great opportunity to get back into the game. Things have changed a lot since then. Not the language, but things around it.
<beach> Even the programming style conventions change slowly over time, just like natural languages do.
quazimodo has quit [Ping timeout: 240 seconds]
<beach> And we have (somewhat) better tools for free implementations. Genera, of course, was a lot better than what we have now.
<beach> ... but not quite as good as what we can (and will, dammit) accomplish! :)
<aeth> stylewarning, fiddlerwoaroof: Personally, I would just use type declarations (and related type things) to mix "static" with CL. It works very well with SBCL (with safety above 0) except for :type in slots in defclass, which are only checked with (debug 2) (I think it's when the defclass is *defined* within a (debug 2)). There are some issues here or there with other implementations, but I will document them some day and hopefully those can
robotoad has quit [Quit: robotoad]
quazimodo has joined #lisp
<loke`> beach: I think it's more precise to say that is was better in some respects. Not everything has gone backwards :-)
nanoz has quit [Ping timeout: 240 seconds]
<stylewarning> aeth: I highly disagree. That requires monomorphising all data structures, and even Common Lisp is happy to have polymorphism everywhere.
<beach> loke`: Too early for precision here. I haven't finished my morning coffee yet.
<aeth> Looks like it got cut off. "and hopefully those can be fixed"
<stylewarning> aeth: But even so, ignoring that (major) aspect, it also requires heavy declare/check-type discipline, which is fine, but it gets difficult to precisely express the types you want to express without descending into a bunch of SATISFIES types. How do you express a list of symbols, in Lisp?
<anniepoo> I know most of the fp basics- I wrote Lisp for Apple years ago. I know clojure and I'm a Prolog maven. But yeah, everything seems to have changed.
<anniepoo> and yes, awesome opportunity
<anniepoo> 8co <-- intimidated
<aeth> stylewarning: You can use https://github.com/Bike/introspect-environment directly or use something that uses introspect-environment, but unfortunately those only have access to *declarations* and not what the implementation's type inference system infers.
<beach> anniepoo: So one thing that has changed is that more Common Lisp programs are object-oriented these days. Using CLOS, of course.
<stylewarning> aeth: How do you express that a variable should be bound to a value which is a list of symbols?
<beach> stylewarning: You can use regular type expressions developed by Jim Newton and Didier Verna.
<anniepoo> also, more syntax
<aeth> stylewarning: The weakness is data structures, but there are ways around it. There actually is a type syntax for cons cells, but afaik it probably is O(n). What I did was define a struct that has foo as a foo-car and itself or nil as the foo-cdr (an alternative could permit trees at the cost of not being able to O(1) check that it's a proper list)
<beach> anniepoo: How so?
<loke`> aeth: Seems like you want ACL2.
<aeth> loke`: ACL2?
anewuser has quit [Quit: anewuser]
<stylewarning> aeth: The weakness is not data structures, at all.
<stylewarning> Lisp can express a huge variety of data structures, like lists of symbols, for example.
<anniepoo> IIRC the first time I ran into keywords :foo was when I started clojure. I don't remember them from whatever ancient version of lisp I was using at apple
<anniepoo> (or from the GCOS/Multics Lisp I first learned on)
<beach> anniepoo: Oh, but that wasn't even Common Lisp.
<aeth> stylewarning: :type in struct slots tends to be respected, and works very well in SBCL. But now you're mostly stuck with structs and functions/lambdas/lets. And you don't really have a good way to deal with ftypes, even in SBCL.
<anniepoo> yeah, that was pre- CL
<loke`> aeth: In ACL2, ‘satisifes’ type specifications do what you hope it does :-)
<anniepoo> and honestly, I no longer remember what lisp I was using at Apple.
<loke`> anniepoo: MCL, I guess?
<LdBeth> anniepoo (IRC): or Corman
<anniepoo> quite possibly MCL
<LdBeth> Corman is Windows version of Coral
<stylewarning> aeth: I think you're still overestimating the compile-time safety afforded by type annotations with SBCL for a project like building a compiler. :)
<anniepoo> it was an internal tool for Apple - maintaining fonts was painful, I wrote a font compiler-decompiler that turned them back and forth into s-expressions
<stylewarning> It does a remarkable job for a dynamic language, but it isn't reliable.
<aeth> stylewarning: SBCL will statically type check within a compilation unit or file, and if you turn on sb-ext:*derive-function-types* (off by default because it violates the standard) it will assume that ftypes will not change even if the function is redefined and will do even more static type checking. You might have seen the former before if you redefine a function with C-c C-c and SBCL gives a type error.
<aeth> Usually happens with sequences.
<fiddlerwoaroof> anniepoo: (don't answer if you don't want to connect identities) but, were you the run offering the prolog course on twitter?
<stylewarning> aeth: I bind *D-F-T* in some of my ASD's.
<anniepoo> I was indeed
<anniepoo> 8cD
<LdBeth> Just wants to ask where's a good point to start Prolog and Smalltalk
<anniepoo> Smalltalk I wouldn't know
<fiddlerwoaroof> cool, I wanted to participate, but I was too busy moving/etc. to actually do anything
<LdBeth> I've read the Smalltalk Blue book but did not get me interested
<anniepoo> send an email to anne@swi-prolog.org saying you want to be informed next time it's offered
<aeth> stylewarning: Anyway, I don't think what's there for types is satisfactory, but it's something that hopefully will be extended in the future, particularly with non-T data structures (when I write in this style I'm basically stuck with structs and my custom metaclass), generics, and ftypes.
<anniepoo> 3 mins, decarpal
<loke`> LdBeth: I downloaded Pharo and then found soem online tutorials. That's how I started looking at ST
<LdBeth> anniepoo (IRC): thank you
<aeth> stylewarning: Well, arrays work, too, but only for certain numeric types.
<fiddlerwoaroof> aeth: that's good for performance critical code but it's effectively turning Common Lisp into Pascal or Java 1.1
<aeth> fiddlerwoaroof: or Fortran
<fiddlerwoaroof> The things that make Common Lisp pleasant are things like generic functions, clos and various other higher-order techniques
<fiddlerwoaroof> (at least, CLOS and generic functions and the condition/restart system are the main reasons why it's my favorite language)
<aeth> I disagree.
<aeth> I use CL for the REPL and macros.
<LdBeth> I use CL for interactive devloping
<stylewarning> If the claim is that adding strong type decls turns parts of your program into Pascal-y code, then I agree.
<fiddlerwoaroof> Well, it's a big language, so there's lots of room for different styles :)
<fiddlerwoaroof> stylewarning: in particular, monomorphic types
<stylewarning> Yes
<fiddlerwoaroof> If we had a good polymorphic-type DSL, I'd never consider using anything else
<aeth> stylewarning: Pascal-y code, but not Pascal code, because you can have length (*) not just length (0), (1), (2), ... :-)
<aeth> (I'm sure Pascal has fixed that in the past 30 years)
<LdBeth> loke` (IRC): maybe Squeak is good enough? i don't know
<fiddlerwoaroof> Or, even better, dependent types
<stylewarning> (typep #(1 2 3) '(vector symbol)) always makes me sad.
<aeth> fiddlerwoaroof: This is the sort of problem that would have to be solved at the implementation-level. And several implementations since CLers hate unportable code.
<fiddlerwoaroof> Not really, you can write a typechecker as a macro that implements a DSL
<fiddlerwoaroof> You can't really get the sort of type system I want without implementing a new language anyways.
<fiddlerwoaroof> The important thing is that it be designed, like Clojure, as a hosted language with nice interop with the host language.
termlen0 has left #lisp ["ERC (IRC client for Emacs 26.1)"]
Bike has quit [Quit: Lost terminal]
<anniepoo> nrrgh... keep expecting to have nondeterminism
<stylewarning> fiddlerwoaroof: that’s the goal with Coalton! (:
robotoad has joined #lisp
<stylewarning> ;)
<anniepoo> assume you don't want me to insert that here... 8cD
danielxvu has quit [Remote host closed the connection]
danielxvu has joined #lisp
capadoodle has joined #lisp
robotoad has quit [Quit: robotoad]
quazimodo has quit [Ping timeout: 272 seconds]
jasmith has joined #lisp
<LdBeth> This great slides makes me question about do dynamic/static type really differentiate
wanz has joined #lisp
<fiddlerwoaroof> alternatively you could use this: https://github.com/TeamSPoon/wam_common_lisp/ anniepoo
<fiddlerwoaroof> :)
<anniepoo> LOL
* anniepoo runs away screaming, pigtails flying in the wind
<anniepoo> >8cO
rozenglass has quit [Remote host closed the connection]
ryan_vw has quit [Ping timeout: 250 seconds]
ryan_vw has joined #lisp
quazimodo has joined #lisp
quazimodo has quit [Client Quit]
quazimodo has joined #lisp
robotoad has joined #lisp
danielxvu has quit [Remote host closed the connection]
dale has quit [Quit: dale]
<stylewarning> LdBeth: Axiom serves a very distinct purpose :)
<fiddlerwoaroof> That's the computer algebra system, right?
<LdBeth> A CAS with possible capabilities on logic
* loke` has mostly been working with Maxima, which is a really nice CAS for Lisp.
<loke`> I did have a look at Axiom, but its code is inpregneable.
<no-defun-allowed> i wouldn't look into the code for maxima :P
danielxvu has joined #lisp
<loke`> no-defun-allowed: Maxima is weird in a different way. It's what you get for being a 40 year old code pase, origianlly written in maclisp
<LdBeth> well, PAIP will teach you how to write a CAS like maxima
<loke`> But it's been easy enough to integrate in my own code.
<stylewarning> PAIP only hints
marusich has quit [Ping timeout: 240 seconds]
<no-defun-allowed> that's true, it's got a lot of PROG and old lisp stuff
<stylewarning> loke`: I’d love to see material where Maxima is integrated with code
Kaisyu has joined #lisp
<loke`> That's my CLIM UI that uses Maxima to perform computation, and uses CLIM to render the maths
<stylewarning> loke`: Any screenshots?
<beach> Screenshots please!!!
<stylewarning> loke`: this sounds awesome!
<beach> I have seen them, but others should see them too.
<beach> stylewarning: I confirm that his work on Climaxima is indeed awesome.
<beach> Don't you have videos as well?
<stylewarning> loke`: this outclasses my paltry FORMULADOR project :$
<LdBeth> amazing
<beach> It is truly amazing. And it shows what we can do with McCLIM.
<loke`> stylewarning: What is formuladfor?
<stylewarning> A kooky little library I work on from time to time
ku has quit [Read error: Connection reset by peer]
angavrilov has joined #lisp
<loke`> stylewarning: Oh neat!
ku has joined #lisp
<loke`> stylewarning: Is it in any way related tot he 2D text maths renderer that Maxima has?
<stylewarning> No. It’s supposed to be better than Maxima
DGASAU has joined #lisp
<stylewarning> in terms of terminal typesetting
<loke`> stylewarning: I see you're using your own syntax. Can it accept Maxima's form?
<stylewarning> No, I’d love for it to. My own “syntax” is barely syntax. It’s just typesetting object construction.
<loke`> stylewarning: My renderer uses Maxima's syntax internally. You could probably easily write a converter that makes it supprot it.
<stylewarning> My bigger priority re Maxima is to get my perm group algebra library included and supported
<loke`> stylewarning: what is that?
<stylewarning> The Maxima devs are an eclectic bunch :)
<loke`> stylewarning: Indeed :-)
<loke`> They sure are traditionalists... CLOS classes? No way, GCL doesn't support them.
<stylewarning> It’s a little tool I use to do research in computational group theory
marusich has joined #lisp
<loke`> stylewarning: Are you integrating that into Maxima?
chipolux has quit [Quit: chipolux]
<loke`> Time for some lunch
chipolux has joined #lisp
<stylewarning> I haven’t. I’d like it to be. But I haven’t had the patience. (:
LeoLiang has joined #lisp
kajo has quit [Ping timeout: 252 seconds]
Oladon has quit [Quit: Leaving.]
<LeoLiang> Hi, anyone knows the history of lisp quote?
<LdBeth> gg, it's right in the initial design of lisp
<no-defun-allowed> yeah quote was one of the primitives in jmc's paper
<LeoLiang> @no-defun-allowed I familiar with javascript. Compared to lisp, javascript's eval is too simple. It change lisp's quote to string value. like Function.toString. Am I right?
<pillton> How can an eval be "too simple"?
<beach> Heh!
<LeoLiang> I mean it's usage.
<LeoLiang> javascript's eval.
<pillton> I imagine CL's eval is as simple to use as Javascripts.
<beach> LeoLiang: This channel is about Common Lisp, so you may not get good answers about JavaScript.
* pillton wonders if javascript has a null lexical environment.
<beach> LeoLiang: In a homoiconic language, you need to distinguish between code and data, hence the quote. Plus, in Lisp, if you know the beginning of an expression, you also know the end, so you only need a single marker for a quotation.
<beach> I am guessing JavaScript is not homoiconic.
<LdBeth> so lisp maintains a relation table for mapping symbol's literate string to pointer, and add a new entry when encounterd a new symbol
<beach> LdBeth: Why are you telling us this?
<LdBeth> I guess LeoLiang is intersted in difference in lisp's symbol and js' string
jack_rabbit has quit [Ping timeout: 250 seconds]
igemnace has quit [Quit: WeeChat 2.3]
vlatkoB has joined #lisp
igemnace has joined #lisp
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
<beach> Hmm. OK.
smokeink has quit [Remote host closed the connection]
smokeink has joined #lisp
mange has quit [Remote host closed the connection]
astalla has joined #lisp
<on_ion> i am digging the words on homoiconism
<beach> "homoiconicity", rather, no?
<on_ion> i am not sure. but i always see the upper and lower quote as 'switch flipping', and knowing the end of sexp makes the sense of it. pardon my englishes
<loke`> homON_IONism?
<loke`> I figured it out. The secret is revealed.
<on_ion> originally,
on_ion is now known as oni-on-ion
Inline has quit [Quit: Leaving]
<pillton> onion?
<oni-on-ion> <-
<oni-on-ion> not origin, previous version
<oni-on-ion> *previous usage of a newer version. ah. originally humasect, whomasect.
<LdBeth> What?
<oni-on-ion> nothing, mindless info
marusich has quit [Quit: Leaving]
jeosol has quit [Ping timeout: 256 seconds]
ryan_vw has quit [Ping timeout: 252 seconds]
slyrus1 has quit [Remote host closed the connection]
scymtym has quit [Ping timeout: 272 seconds]
LeoLiang has quit [Ping timeout: 252 seconds]
varjag has joined #lisp
capadoodle has quit [Ping timeout: 256 seconds]
<anniepoo> hey ionic onion
<oni-on-ion> hi anniepoo =) how are you?
<anniepoo> doing OK
robotoad has quit [Quit: robotoad]
<oni-on-ion> okay =)
emaczen has quit [Ping timeout: 252 seconds]
<anniepoo> prepping a new set of eyestalks for Pomatia
<oni-on-ion> hehe eyestalks!
<oni-on-ion> doing some scheme. i knew i forgot to add another channel in the list
<anniepoo> tomorrow I go pick up the tubing for the eye drive supports
<oni-on-ion> two?
asarch has quit [Quit: Leaving]
<anniepoo> yes, two eyes
frgo has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 244 seconds]
frgo has joined #lisp
fikka has joined #lisp
nirved has joined #lisp
frgo has quit [Ping timeout: 268 seconds]
<no-defun-allowed> i found a very silly way to half-break slime's autodoc in the minibuffer
<no-defun-allowed> (defun foo (===> <===) (declare (ignore ===> <===)) 2)
<no-defun-allowed> it still shows up, but both arrows are emboldened, presumably cause it scans for ===> from the left and <=== from the right and the lambda list isn't escaped in any way
kajo has joined #lisp
madrik has joined #lisp
<beach> Another reason to work on a more reliable solution for all that stuff.
frgo has joined #lisp
<no-defun-allowed> it seems to me like passing the sexp instead of a string representation would be less painful
<no-defun-allowed> emacs doesn't care about colons in symbols, so it should be harmless
shrdlu68 has joined #lisp
frgo_ has joined #lisp
frgo has quit [Remote host closed the connection]
scymtym has joined #lisp
frgo_ has quit [Remote host closed the connection]
kajo has quit [Ping timeout: 252 seconds]
madrik has quit [Ping timeout: 268 seconds]
<dim> beach: can we do https://docs.racket-lang.org/quick/ in Second Climacs yet? ;-)
<beach> Sorry! No! :(
<dim> it seems to me like a nice goal to achieve, and I wish I could help
<beach> dim: But you can in the CLIM listener.
<dim> I though a listener was included in climacs somehow?
<beach> No, it's the other way around.
<shka_> hello
<beach> dim: The input-editor of McCLIM is Drei, which is an extraction of the basic editing features of (first) Climacs.
<beach> Hello shka_.
<shka_> where and when are initializede :class allocated slots?
<shka_> is it during initialization of the class?
<shka_> if so, how can i alter this?
<dim> beach: oh make sense, so in the vision, Climacs is the editor “widget” that McCLIM uses?
<beach> dim: Pretty much, yes.
<beach> shka_: I think it is when shared-initialize is executed on the instance, but you can check that by printing something in the initform.
<shka_> beach: but it is not standardized, right?
<beach> dim: Emacs did it the other way around, but that's just because nothing like CLIM existed at the time.
<shka_> even not in the form of de facto standard
<beach> shka_: I don't know. Sorry. It might be in the MOP.
<dim> makes sense beach, thanks
<shka_> no problem, i will take a look
kajo has joined #lisp
<jackdaniel> I have plans to replace Drei though with something less overengineered. Drei served a good purpose for Emacs clone, but it is not very good as a default editor substrate
<jackdaniel> but this is just in plans phase so far
<beach> Would your replacement be used by the listener?
<beach> ... or just for the regular input editor?
<beach> The listener is a bit special because it accepts Common Lisp forms, which is not typical for other applications.
<jackdaniel> it will be possible to coerce listener to use it I suppose, but I didn't pay much thought to that
<jackdaniel> right now listener uses clim (without drei extensions), so it doesn't matter what is baking editor substrate for it
<beach> Hmm.
kajo has quit [Ping timeout: 252 seconds]
hhdave has joined #lisp
<beach> Are you saying we have more than one place where keyboard gestures such as C-M-f C-M-a, etc are defined?
frgo has joined #lisp
kajo has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
heisig has joined #lisp
<jackdaniel> (to be clear, I'm not proposing drei removal, I'm proposing removing dependency between mcclim and drei in the former's core module)
<beach> I see. I am still puzzled though that the listener is not using Drei, because that would mean that we have several places where pretty specialized gestures like that are defined.
HDurer has joined #lisp
<jackdaniel> it is possible for drei to add some gestures to pure clim (and if they are defined solely in drei then they could be moved to core), so with a simple replacement you'd lose these gestures. that doesn't mean that listener depends on drei in any way, it just means that drei has side-effects which influence mcclim behavior.
<jackdaniel> I don't know if they are defined elsewhere, I'm sure it is fairly easy to scope the codebase to check this out though
frgo has quit [Ping timeout: 272 seconds]
kajo has quit [Ping timeout: 252 seconds]
jochens has joined #lisp
kajo has joined #lisp
<beach> I am also interested in knowing in which ways you think Drei is over-engineered, and how you would do it differently. It is a serious question. I wrote (first) Climacs, but Athas extracted the part of it that is now Drei, and I am not sure exactly what he did.
hhdave has quit [Ping timeout: 268 seconds]
<jackdaniel> one infuriating part is the notion of having buffer-pane mixup (for some reason drei doesn't keep notion of a pane separate from a buffer, so you can't freely operate on drei panes using clim primitives. Keep in mind, I don't remember drei code details, I'm fixing parts of it sporadically, but I remember finding quite a few assumptions like that in drei
<beach> I see. Thanks.
<jackdaniel> another thing (but this is not drei's issue per se, I'm just mentioning it since we are at gestures) is that not everyone is fond with mcclim key combinations, it would be nice to be able to switch input pane to use other gestures
<jackdaniel> also there is modual-class metaclass which doesn't really benefit text-field in any way I can imagine (but it makes perfect sense for Emacs-like editor)
<jackdaniel> s/fond with mcclim key combinations/fond with Emacs key combinations/
hypnon has joined #lisp
<dim> I like the self-insert-command idea in Emacs, do we find it in drei/Climacs too?
<dim> what I mean is that given that “trick” it should be easy enough to maintain more than one keymap in the editor, right?
<jackdaniel> what is a self-insert?
<beach> The command to which most letters are bound.
<jackdaniel> havign different keymaps is not overly hard, it just needs to be implemented
<jackdaniel> having*
<jackdaniel> keymap is a bad word, keyboard gesture->command mappings is better
<beach> dim: Stuff like that is abstracted into CLIM command tables.
<beach> dim: All you need is to swap the command table.
<dim> so all it needs is for one of the regular contributors to use an alternative command table I guess
<jackdaniel> that's why I've said it is not a big problem, just mentioned it since we were at gestures
<jackdaniel> in perfect world that would be simply configurable, so the user enters McCLIM configuration screen and picks preferable editor bindings
<jackdaniel> (we don't have such screen yet of course :)
<dim> self-insert-command is the command that inserts a into the buffer at the current position when you hit the 'a' key, and in Emacs if you're using a read-only mode (Gnus or something) it might be something else, such as 'a runs the command gnus-summary-post-news'
<dim> I remember having an “ah!” moment when I saw that
<jackdaniel> thanks, I've understood when beach answered (thanks!)
themsay has joined #lisp
frgo has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
hhdave has joined #lisp
elderK has quit [Quit: Connection closed for inactivity]
zigpaw has quit [Quit: Vanishing into darkness in 1..2..3...]
zigpaw has joined #lisp
DGASAU has quit [Remote host closed the connection]
nowhere_man has joined #lisp
kajo has quit [Ping timeout: 245 seconds]
pierpal has joined #lisp
nanoz has joined #lisp
frgo has quit [Remote host closed the connection]
orivej has joined #lisp
deng_cn has quit [Quit: deng_cn]
bendersteed has joined #lisp
DGASAU has joined #lisp
LeoLiang has joined #lisp
bendersteed has quit [Remote host closed the connection]
esrse has quit [Ping timeout: 240 seconds]
<shka_> beach: btw, don't feel preasured in any manner, but you often already have those things done. What about case study of first climacs and what needs to be redesigned for the second climacs?
<beach> shka_: A lot of the redesign is already done.
<beach> The buffer has a better structure (using Cluffer).
razzy has joined #lisp
<beach> In Common Lisp mode, I use (or will use) Eclector to parse the buffer contents.
<shka_> well, i typed cluffer in google
<shka_> fluffer came out first
<shka_> "cluffer lisp" is better idea
<beach> (I currently use the SICL reader, but Eclector is an improvement of that one).
<shka_> ok
<beach> The goal for Second Climacs is to be very good with editing Common Lisp code.
<beach> That's why I have been concentrating my efforts on that part.
<shka_> yeah
<beach> In Emacs, (first) Climacs, and other editors, Common Lisp code is parsed using regular expressions, or something with similar power.
<beach> But there is only one true way of parsing Common Lisp code.
<beach> And that's with the Common Lisp READ function.
<beach> So that's what I decided to do.
<shka_> lovely
frgo has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
<beach> This technique then opens up interesting possibilities. The plan is to adapt Cleavir (which it was written to facilitate, so no big deal here) to invoke the first few passes of the compiler to analyze the code at typing speed.
<dim> usually editors refrain from using the language's parser not because it's complex to call a READ function, but because the job is to parse incomplete forms while the user is typing them...
<beach> Indeed.
<beach> And that's why we adapted Eclector to be able to do that.
<dim> how do you approach that, than?
<jackdaniel> beach: you had a presentation about that during this year ELS, right?
<dim> I think you covered the topic in your ELS talk this year, but I'm not sure
<beach> I did.
<dim> yeah you did ;-)
<beach> Or was it last year.
<beach> I forget.
nanoz has quit [Ping timeout: 268 seconds]
<dim> I remember mostly about the speed of typing vs the speed of figuring out what you typed, not about adapting read to invalid input
<beach> I see.
<dim> thanks jackdaniel
<jackdaniel> I think it tells about incomplete input
<jackdaniel> but not 100% sure
<beach> Eclector is also capable of "reading" skipped material such as comments.
orivej has quit [Ping timeout: 268 seconds]
frgo has quit [Ping timeout: 252 seconds]
<scymtym> the support for incomplete input needs more work. it is definitely a high-priority feature
marvin2 has joined #lisp
<jackdaniel> "Thoughts on the Formalization of Program Construction" here https://european-lisp-symposium.org/static/proceedings/2018.pdf was also an interesting talk
<jackdaniel> (relevant to editing)
<jackdaniel> and proposing solution, where incomplete input simply doesn't happen
<heisig> I loved that talk. The author also has a website for the project: http://www.expressionsofchange.org
<jackdaniel> oh, thanks, didn't know about that
orivej has joined #lisp
fikka has quit [Quit: leaving]
fikka has joined #lisp
frgo has joined #lisp
rippa has joined #lisp
frgo has quit [Ping timeout: 268 seconds]
jochens has quit []
jmercouris has joined #lisp
<jmercouris> so, I'm running Lisp in a production setting as a webserver, and what I usually do is ssh into the box, run screen, and then start my lisp application
m00natic has joined #lisp
<jmercouris> I can then disconnect and exit the session
<jmercouris> this however means that whenever I want to restart the server, I have to ssh onto the machine, connect to the running screen session C-d and then restart the program
<jmercouris> does anyone else do things a different way? interested in hearing ideas
<otwieracz> Oh my.
<otwieracz> „lisp in a production” gone wild.
DGASAU has quit [Ping timeout: 260 seconds]
<otwieracz> jmercouris: if this is recently-dated operating system, you probably have `systemd`.
<jmercouris> otwieracz: I have systmd, I'm running freeBSD11
<jmercouris> can you elaborate on what you mean?
<otwieracz> I don't think you have `systemd` init system on FreeBSD.
<jmercouris> s//don't
<otwieracz> OK. So you should probably create FreeBSD rc file for your service.
<shrdlu68> jmercouris: Start your program with a swank listener. Then daemonize it with your system's init mechanism (probably systemd, upstart, sysv, openrc, etc.)
jochens has joined #lisp
<jackdaniel> jmercouris: running it from screen is hardly a practice at all, especially for a "production" setting. you need to write a service file for your application (that depends on your init system) and run it like any other daemon on it
<jackdaniel> keep in mind, that to be able to restart it properly you need to handle certain (operating-system dependent) signals inside the application
<jackdaniel> basically what otwieracz said
<jmercouris> jackdaniel: properly being a "clean" restart, instead of a kill -9, is what you mean?
<jackdaniel> otwieracz and shrdlu68 °, if you want to be able to modify it
<jackdaniel> kill -9 something is to restart is what burning the house is to moving out
<jmercouris> :D
<jmercouris> I like it, nice metaphor
<otwieracz> jmercouris: one more question - are you delivering it as binary image (like `saves-lisp-and-die`) or running it from source?
benjamin-l has quit [Ping timeout: 240 seconds]
<jmercouris> otwieracz: running from source
<otwieracz> OK
<jmercouris> I'm not sure if the kernel can handle images on different OS
<jmercouris> because I would be compiling on macOS, and running on FreeBSD, not sure the SBCL kernel can do that
<otwieracz> you don't want to use image if you don't have to
<otwieracz> and if you ever had to - beware, tharr will be dragons
<jmercouris> that's the gist of my understanding, yes
LeoLiang has left #lisp ["ERC (IRC client for Emacs 26.1)"]
hel-io has joined #lisp
<jmercouris> it's just too bad I have to write some sh to get things in rc conf
<jmercouris> alea iacta est
<otwieracz> You probably also want to write some pid tracking mechanism
madrik has joined #lisp
<otwieracz> So rc script will know which PID to kill.
<heisig> jmercouris: You could use cl-launch to keep the amount of sh at a minimum :)
<jmercouris> I'll also probably want to compile the application in the make and add a make install to put it into the path
<jmercouris> that way my rc script can be as trivial as possible
<jmercouris> heisig: I'm familiar with cl-launch, it's not really applicable here, unfortunately
fikka has quit [Ping timeout: 246 seconds]
pfdietz has quit [Remote host closed the connection]
fikka has joined #lisp
Bike has joined #lisp
wanz has quit [Quit: wanz]
Essadon has joined #lisp
hel-io has quit [Read error: Connection reset by peer]
xkapastel has joined #lisp
astalla has quit [Ping timeout: 268 seconds]
wanz has joined #lisp
ikki has joined #lisp
frgo has joined #lisp
pfdietz has joined #lisp
igemnace has quit [Quit: WeeChat 2.3]
frgo has quit [Ping timeout: 252 seconds]
hel-io has joined #lisp
ggole has joined #lisp
carmack has joined #lisp
hel-io has quit [Remote host closed the connection]
frgo has joined #lisp
bendersteed has joined #lisp
hel-io has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
orivej has joined #lisp
shrdlu68 has quit [Ping timeout: 245 seconds]
themsay has quit [Ping timeout: 252 seconds]
themsay has joined #lisp
themsay has quit [Ping timeout: 244 seconds]
bendersteed has quit [Read error: Connection reset by peer]
bendersteed has joined #lisp
dddddd has joined #lisp
rozenglass has joined #lisp
cylb has joined #lisp
bendersteed has quit [Quit: bye]
bendersteed has joined #lisp
shrdlu68 has joined #lisp
nly has joined #lisp
astalla has joined #lisp
Lycurgus has joined #lisp
nicksmaddog has joined #lisp
astalla has quit [Ping timeout: 268 seconds]
bendersteed has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 245 seconds]
bendersteed has joined #lisp
cylb has quit [Remote host closed the connection]
cylb has joined #lisp
quazimodo has quit [Ping timeout: 268 seconds]
bendersteed has quit [Read error: Connection reset by peer]
quazimodo has joined #lisp
ikki has quit [Ping timeout: 240 seconds]
Bike_ has joined #lisp
Bike_ is now known as Trike
Trike is now known as Quike
fikka has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
LiamH has joined #lisp
orivej has joined #lisp
frgo has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 252 seconds]
frgo has joined #lisp
carmack has quit [Ping timeout: 250 seconds]
wanz has quit [Quit: wanz]
fikka has joined #lisp
warweasle has joined #lisp
cylb has quit [Remote host closed the connection]
cylb has joined #lisp
rozenglass has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 252 seconds]
nowolfer has quit [Quit: Lost terminal]
sjl_ has joined #lisp
fikka has joined #lisp
wanz has joined #lisp
bendersteed has joined #lisp
rumbler31 has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 244 seconds]
fikka has joined #lisp
quazimodo has quit [Ping timeout: 246 seconds]
quazimodo has joined #lisp
benjamin-l has joined #lisp
dale_ has joined #lisp
dale_ is now known as dale
jochens has quit [Read error: Connection reset by peer]
jochens_ has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 244 seconds]
nicksmaddog has quit [Ping timeout: 268 seconds]
carmack has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
Inline has joined #lisp
smokeink has quit [Ping timeout: 260 seconds]
hel-io has quit []
shrdlu68 has quit [Ping timeout: 244 seconds]
fikka has quit [Ping timeout: 252 seconds]
* fiddlerwoaroof always uses images to distribute his applications
fikka has joined #lisp
wanz has quit [Quit: wanz]
anewuser has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
igemnace has joined #lisp
fikka has joined #lisp
heisig has quit [Quit: Leaving]
fikka has quit [Ping timeout: 245 seconds]
<beach> Sometimes, ordering something from Amazon is strange. A few years back when I ordered the book Advanced Compiler Design Implementation by Muchnick, it came with a Cover with Chinese characters on it.
<beach> Today I received Modern Operating Systems by Banenbaum and Bos, and it has a text on the cover: Circulation of this edition outside the Indian subcontinent is UNAUTHORIZED.
<beach> Tanenbaum
<beach> not Banenbaum
fikka has joined #lisp
<Quike> in college i got an "international" version of a class's discrete math textbook and it turned out they just removed a chapter and otherwise it was the same
<Quike> they like doing weird things for marketing purposes
<beach> Sure.
nanoz has joined #lisp
<beach> I am convinced these books are the same no matter where I buy them. But it is strange to order from the French branch of a large international company, and have them ship me an unauthorized edition.
<Quike> it is kind of weird. you got it new?
<beach> Yes.
<Quike> Bizarre.
<beach> That's what I think, yes.
<warweasle> Generally international textbooks are printed in black and white and are much cheaper.
fikka has quit [Ping timeout: 276 seconds]
<beach> I see.
anamorphic has joined #lisp
<jcowan> Note that "unauthorized" does not mean "illegal". Circulation of books in the U.S., if they are published by the legitimate publisher, can't be limited.
<beach> Yes, it's doubtful that this restriction is legally valid.
fikka has joined #lisp
<beach> But I assume in this case that the publisher only makes it available in India, and considers exporting it to be unauthorized.
<beach> Perhaps by buying a copy, you implicitly agree to that.
<Quike> couldn't it violate copyright?
emaczen has joined #lisp
<fiddlerwoaroof> beach: I had that same experience with a book on compiler design
<beach> Quike: I don't see how.
<beach> fiddlerwoaroof: In what country?
<fiddlerwoaroof> US
<beach> I see.
<fiddlerwoaroof> I believe it was the exact same book and I got the edition that was meant for distributing in China
<fiddlerwoaroof> The text was in English, though, so I didn't do anything abuot it
<shka_> Quike: copyrights belong to the author, but the remark suggests publishing rights, but publishing rights already belong to the publisher
<shka_> so it is like stealing from yourself
<Quike> Well I was thinking the publisher is doing whatever price discrimination, then another firm buys books from them in India and sells them in France.
<shka_> i would say that this is inconsequential, but amusing
<beach> Quike: I think that is the case exactly.
emdeesee has quit [Ping timeout: 260 seconds]
<Quike> oh. i forgot the first sale doctrine exists. doy.
<Quike> no idea how it goes outside the US, though.
fikka has quit [Ping timeout: 268 seconds]
<Quike> doesn't apply in the EU for art, at least
rumbler31 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
nly has quit [Ping timeout: 252 seconds]
<shka_> it is confusing
<Quike> naturally.
<|3b|> beach: probably didn't actually buy from amazon, just through them
<beach> Yeah, I think you are right.
robotoad has joined #lisp
fikka has joined #lisp
frgo_ has joined #lisp
<jcowan> Quike: Really? You can't sell a painting you have bought without the painter's consent?
anewuser has quit [Quit: anewuser]
frgo has quit [Ping timeout: 260 seconds]
shka_ has quit [Quit: WeeChat 1.9.1]
fikka has quit [Ping timeout: 246 seconds]
varjag has joined #lisp
fikka has joined #lisp
frgo has joined #lisp
fikka has quit [Ping timeout: 250 seconds]
flazh has quit [Read error: Connection reset by peer]
frgo has quit [Remote host closed the connection]
frgo_ has quit [Ping timeout: 264 seconds]
optikalmouse has joined #lisp
flazh has joined #lisp
jkordani has joined #lisp
<Quike> jcowan: you can, but you have to pay the artist a fee.
<jcowan> huh.
hhdave has quit [Ping timeout: 268 seconds]
<jcowan> I never heard of this (U.S. parochialism)
<Quike> me neither, but it doesn't surprise me
benjamin-l has quit [Ping timeout: 246 seconds]
<jmercouris> Quike: I don't think things are so simple, consider the recent scandal with the John Cena's reselling of his Ford GT
<Quike> that's about a specific contract, not copyright law
danielxvu has quit [Remote host closed the connection]
danielxvu has joined #lisp
<jmercouris> does Ford not own Copyright on a "published" (manufactured) instance of each Ford-GT they produce?
<jmercouris> I don't see how it is any different
<Quike> uh, no, they don't.
Zaab1t has joined #lisp
fikka has joined #lisp
<Quike> also i don't want to go any more off topic.
<jmercouris> Design copyright? I'm way out of my depth here, I'll step out :D
<jackdaniel> this could be suspected of being an offtopic too despite being interesting
fikka has quit [Ping timeout: 240 seconds]
jeosol has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
fikka has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
frgo has joined #lisp
fikka has joined #lisp
frgo has quit [Ping timeout: 246 seconds]
shka_ has joined #lisp
<shka_> good evening
<beach> Hello shka_.
<shka_> i wonder
<shka_> what was the FIRST character to be used as comment designator
<shka_> was it ;?
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
<ggole> Early assemblers had column position comments, I think
<ggole> That is, anything to the right of column X was a comment.
<shka_> interesting, but sounds unwieldy
<oni-on-ion> REM
varjag has quit [Ping timeout: 240 seconds]
mkolenda has quit [Remote host closed the connection]
mkolenda has joined #lisp
<jmercouris> shka_: sounds pretty wieldy to me, actually seems like it would be really clean, probably you had a comment on almost every line since assembler is pretty hard to decipher without comments
<jmercouris> shka_: so it most likely looked like a table, on the left hand code, and on the right hand explanations
<jmercouris> also assembler functions, from what I understand RARELY would need to be wide enough to be multiple lines
jochens_ has quit [Remote host closed the connection]
<edgar-rft> God never documented his code when he created earth. That's why it's such a mess.
jochens has joined #lisp
<jackdaniel> comments, assembler, religion, and god put a close paren to end it. https://www.xkcd.com/312/
jochens has quit [Ping timeout: 268 seconds]
<edgar-rft> In early programming languages it wasn't important to have a special comment char because the program text was written to be read by humans, not computers. The programmer had to look-up the CPU op-codes in the CPU manual and program the machine via hex numbers (memory address + op-code). No joke.
frgo has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
frgo has quit [Client Quit]
frgo has joined #lisp
frgo_ has joined #lisp
<jmercouris> yes, but we're talking about assembly, not writing directly in hex
<oni-on-ion> compilers took our jobs!! =(
frgo has quit [Ping timeout: 245 seconds]
madrik has quit [Remote host closed the connection]
<oni-on-ion> well, humans were/are the original computers and compilers
<ggole> You can still hand-compile Lisp if you want!
<zigpaw> eight bit zx spectrum was great in this, as you had every op code translated directly to a single byte; you could literally learn most of those often used so you could transliterate asm code to hex on the paper (probably other 8bit computers too, but I had only experience with this one).
<oni-on-ion> probably similer to remembering ascii codes
sauvin has quit [Read error: Connection reset by peer]
m00natic has quit [Remote host closed the connection]
nicksmaddog has joined #lisp
on_ion has joined #lisp
nanoz has quit [Ping timeout: 244 seconds]
oni-on-ion has quit [Ping timeout: 246 seconds]
on_ion is now known as oni-on-ion
ggole has quit [Quit: ggole]
eddof13 has joined #lisp
nly has joined #lisp
<edgar-rft> jmercouris: I was talking about assembly language, too. On my first two computers it was *me* who was the assembler.
<edgar-rft> I first wrote the assembly program on a piece of paper, then I programmed the computer via hexdumps.
bendersteed has quit [Read error: Connection reset by peer]
<edgar-rft> oni-on-ion: 101 120 97 99 116 108 121 33
<oni-on-ion> ^_^
<jcowan> "A host of compilers darkened the face of learning." (Edward Gibbon)
igemnace has quit [Ping timeout: 245 seconds]
anamorphic has quit [Quit: anamorphic]
mutenewt has joined #lisp
mutenewt has quit [Remote host closed the connection]
nly has quit [Quit: Quit]
<oni-on-ion> i realised my positive perspectives on C are related to how it "let" me feel like half computer half human
<pfdietz> I very much like that quote.
<jcowan> More accurately: "The name of Poet was almost forgotten; that of Orator was usurped by the sophists. A cloud of critics, of compilers, of commentators, darkened the face of learning, and the decline of genius was soon followed by the corruption of taste."
fikka has quit [Ping timeout: 268 seconds]
nly has joined #lisp
drmeister has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
drmeister has joined #lisp
myrkraverk has quit [Ping timeout: 240 seconds]
<oni-on-ion> =( powerful
nicksmaddog has quit [Ping timeout: 252 seconds]
<Lycurgus> in the intro i take it (and look out here come the topic nazi)
eddof13 has quit [Quit: eddof13]
<Lycurgus> of the decline and fall of chat
nowhereman has joined #lisp
nowhereman is now known as Guest70792
nowhere_man has quit [Ping timeout: 260 seconds]
varjag has joined #lisp
emar has quit [Ping timeout: 245 seconds]
nirved has quit [Quit: Leaving]
emar has joined #lisp
fikka has quit [Ping timeout: 250 seconds]
warweasle has quit [Quit: nothing is real]
didi has joined #lisp
<didi> Hey, little trick: if you have a list on slime, but you want to kill and yank one of its elements, eval (values-list *) and then you can kill and yank it.
jochens has joined #lisp
jmercouris has quit [Ping timeout: 260 seconds]
eddof13 has joined #lisp
Zaab1t has quit [Quit: bye bye friends]
astalla has joined #lisp
jmercouris has joined #lisp
jochens has quit [Ping timeout: 268 seconds]
orivej has quit [Ping timeout: 252 seconds]
<oni-on-ion> hm, did not realise values are editable in/with slime
<didi> I use it all the time.
<LdBeth> good morning
<oni-on-ion> hmm. i wonder if geiser can do this
rozenglass has joined #lisp
<Xach> didi: neat
anamorphic has joined #lisp
Lycurgus has quit [Quit: Exeunt]
neirac has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
eddof13 has quit [Quit: eddof13]
vlatkoB has quit [Remote host closed the connection]
robotoad has quit [Read error: Connection reset by peer]
robotoad has joined #lisp
fikka has joined #lisp
charh has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
scymtym has quit [Ping timeout: 252 seconds]
n3k0_t has quit [Ping timeout: 272 seconds]
n3k0_t has joined #lisp
josh5tone has joined #lisp
fikka has joined #lisp
eddof13 has joined #lisp
n3k0_t has quit [Ping timeout: 244 seconds]
fsmunoz has joined #lisp
n3k0_t has joined #lisp
<jmercouris> sly vs slime? anyone have a really compelling reason to use sly?
<jmercouris> I struggle to see one
<anamorphic> stickers are cool
<jmercouris> anamorphic: what are you talking about?
<anamorphic> the stickers feature in sly
<jmercouris> Ah, I just looked it up
<jmercouris> stickers are indeed cool
<jmercouris> they're like breakpoints for lisp!
Roy_Fokker has joined #lisp
<jmercouris> well, without typing (break)
<jmercouris> do most people just have (declaim (optimize (debug 3))) in their sbclrc?
<anamorphic> I have (sb-ext:restrict-compiler-policy 'debug 3) in mine
<sjl_> No, I write things that rely on LCO fairly often. I have debug 2 + safety 3 in my vlime config though
eddof13 has quit [Quit: eddof13]
<anamorphic> what's lco?
<sjl_> last call optimization
<jcowan> aka proper tail calling
<jmercouris> sjl_: what is vlime?
astalla has quit [Ping timeout: 268 seconds]
nly has quit [Ping timeout: 268 seconds]
it3ration has joined #lisp
<jmercouris> ah, I keep forgetting you don't use emacs
<fiddlerwoaroof> I used to use slimv for everything
eddof13 has joined #lisp
<jmercouris> I'm not sure why you torture yourself, when you could just use spacemacs
<fiddlerwoaroof> But, I've discovered that evil-mode is the best implementation of the vim standard
<jmercouris> but whatever, to each their own
<jmercouris> you don't even have to use spacemacs, could even use doom
<fiddlerwoaroof> I've never been able to get into spacemacs
<jmercouris> there is literally no reason to use VI in this day and age when emacs can emulate it
<sjl_> I try emacs every couple of years. I've tried viper, vile, evil, vimpulse... I think that's it. They're all meh compared to actual vim.
<no-defun-allowed> Being able to quit Emacs is one of its features, unfortunately.
<sjl_> It usually takes me about 30 minutes to run into a situation where I wonder "how can I do Vim thing X in whatever-the-emacs-vi-mode-is-called-this-year?" and the answer is "oh yeah you can't do that"
themsay has joined #lisp
<fiddlerwoaroof> sjl_: yeah, there are a couple things I miss from vim, but the better lisp experience + discovering how easily I could migrate the important parts of my vim config convinced me to make the jump
<it3ration> Hey folks - I've been using Clojure in my day job for about a year and have been reading Practical Common Lisp. I'm curious if there are any good comparative resources on Clojure vs CL out there. So far, I vastly prefer Clojure's syntax, brevity, [] / #{} / {} syntax for vectors / sets / maps, consistency, etc. Basically, I'm looking for someone to show me benefits of CL over Clojure from a usage POV (not a performance POV). Thanks!
<jmercouris> sjl_: the key to success in a tool is embracing the new tool instead of fighting it
<fiddlerwoaroof> restartable exceptions make a huge difference it3ration
<it3ration> fiddlerwoaroof: yeah I was reading about that, pretty nice
<anamorphic> it3ration, error messages and stack traces that are readable
<fiddlerwoaroof> They enable a fairly unique debugging workflow
<fiddlerwoaroof> In other languages, you start your program in your debugger if you want to debug it
<sukaeto> fwiw, I've been using emacs+evil for ~3 years now. I believe myself to be a heavy user of "vi the text editing language" + some of the VIM extensions to that language
<it3ration> The names of things seem super antiquated compared to Clojure (aka, remove-if-not instead of filter, etc)
<sukaeto> I have yet to encounter a thing that you can do in VIM that you can't do in evil
<fiddlerwoaroof> In common lisp, the debugger is always listening and it pops up in the stack frame where the error happened when there's an error
<it3ration> Of course, CL is like 50+ years old or something so no surprise there
<fiddlerwoaroof> it3ration: that's sort of true, but there are also 40 year old code bases that still work
<sukaeto> granted, I was never a heavy user of VIM plugins. I mostly just used it out of the box for the dozen or so years that I used it.
<sjl_> Yeah being able to write code now and be confident it won't break in ten years is a big advantage of CL.
<shka_> it3ration: common lisp object system continues to be peerless imho
<TMA> the emulation is not good enough. it has annoyances that are just wrong (like search timeout. pause for half a second while writing a regular expression and bam, the next character won't be part of the regex, but a normal command
<TMA> )
<shka_> good night all
<sjl_> Clojure 1.3 breaking the world by removing clojure.contrib was one of the big things that pushed me away from Clojure.
themsay has quit [Ping timeout: 244 seconds]
<fiddlerwoaroof> I've also found that multimethods in Clojure sound really useful but they never work the way I want them to when I try to use them
<sjl_> it3ration: I moved from Clojure to Common Lisp and have no regrets. I haven't written specifically about Clojure vs CL, but I wrote about why I like CL here: http://stevelosh.com/blog/2018/08/a-road-to-common-lisp/
<fiddlerwoaroof> Maybe that's solvable, but there've been several occasions where I've thought "Ah, a use case for a multimethod" and then discovered that the limitations of Clojure's multimethods mean they usually don't do what I want them to
<fiddlerwoaroof> As far as vim/emacs goes, though, I agree that evil-mode isn't actually a complete vim replacement. But, I've generally found that I can take advantage of other emacs packages to come up with a decent new workflow
<jcowan> sjl_: I like "The Hamster Wheel of Backwards Incompatibility"
<jcowan> great phrase
shka_ has quit [Ping timeout: 244 seconds]
quazimodo has quit [Ping timeout: 245 seconds]
<cgay> it3ration: even at 50 years old, i think i am still capable of change. CL should be too. :)
<sjl_> sometimes it's more of a hamster centrifuge
optikalmouse has quit [Quit: optikalmouse]
quazimodo has joined #lisp
<jcowan> "As long as it can balance parentheses, highlight comments and strings, and autoindent Lisp code that’s all you need to start." Of course, I write Lisp with an editor that can do none of those things (well, balance parens, but it's awkward to do so).
<sjl_> I did the Schemer books with pen and paper, but *some* basic editing support really helps.
<it3ration> sjl_: nice I'll take a look
themsay has joined #lisp
<it3ration> Is CLOS just OOP? I like that Clojure uses protocol-driven development
<fiddlerwoaroof> Depends what you mean by OOP
<fiddlerwoaroof> CLOS is protocol-centric
<it3ration> ah nice, I haven't gotten to it yet
xrash has joined #lisp
<it3ration> I will say, having []'s in let blocks, and [], {}, #{} for vectors / maps / sets is super nice
<it3ration> I quite dislike writing (let ((a 1) (b 2)) ..) kind of stuff, parentheses vomit
<cgay> I feel the opposite. The indentation makes it clear, whereas mixing () and [] means I have to balance parens mentally.
<cgay> To some extent...i.e., it makes the parens into more of a big deal.
<oni-on-ion> Chez uses [] like clojure =/
<oni-on-ion> i like [] better than #() for vectors. shifting becomes a nuisance for any code, but snoopy-mode helps
themsay has quit [Read error: Connection reset by peer]
<jcowan> oni-on-ion: Chez (like all R6RS) treats [] like (), so you can use whatever convention you want.
themsay has joined #lisp
<oni-on-ion> ohhhhhh. well thats cool actually! did not know it was R6 either. opinion changed
anamorphic has quit [Ping timeout: 252 seconds]
msb has quit [Ping timeout: 272 seconds]
msb has joined #lisp
<sjl_> You can make CL read [] as vectors if you want, but it won't help you when reading other folks' code. It took a while but I got used to the extra parens.
<it3ration> At the risk of getting yelled at, I appreciate that Clojure is a Lisp-1
<sjl_> That was another thing I found annoying at first but now love about CL.
<sjl_> I think Lisp-1's are better for teaching, but much prefer Lisp-N for actual work.
<Xach> i like the freedom of naming very much.
scymtym has joined #lisp
themsay has quit [Ping timeout: 268 seconds]
msb has quit [Ping timeout: 268 seconds]
themsay has joined #lisp
<Xach> so much
msb has joined #lisp
sakalli__ has quit [Quit: Connection closed for inactivity]
<jcowan> Does anyone have a class diagram (showing classes and their subclasses) for the CL package, either an actual picture (text or image) or code to generate it? Doesn't have to be pretty, just correct.
<sjl_> http://clqr.boundp.org/ has one, page 32
<sjl_> but it'll hurt your neck
<sjl_> (page 25 of the pdf)
jmercouris has quit [Remote host closed the connection]
rumbler31 has joined #lisp
<jcowan> Thanks. Right-click "Rotate Clockwise" is my friend.
<rumbler31> how exactly do people find this useful
<aeth> find what?
<Quike> I'm fond of the pretty colors.
<rumbler31> a visualization of the type heirarchy
<rumbler31> perhaps that sounded antagonistic, I didn't mean it like that
<rumbler31> I am usually beholden to the types that libraries make be use
<aeth> rumbler31: jcowan is the chair of the r7rs-large committee and since Common Lisp is the closest language to Scheme/Racket jcowan is probably mining Common Lisp for ideas
<aeth> rumbler31: A diagram like that is probably only interesting to language implementers and people going really deep into MOP/CLOS/type stuff
<jcowan> Actually I am not wearing my Scheme hat today
<jcowan> I find things like this easier to understand when there is a conspectus view
<oni-on-ion> oh, jcowan also CLIM has a way to do that with all sorts of inputs
<sjl_> It highlights weird things like (subtypep 'real 'complex) => NIL T
<oni-on-ion> not sure if this is the same thing but this is the version i've seen, outside of CLIM or Slime : http://sellout.github.io/2012/03/03/common-lisp-type-hierarchy/
it3ration has quit [Ping timeout: 268 seconds]
<jcowan> well, yes, that fits the CL model of numbers (the Scheme numeric tower is another story)
it3ration has joined #lisp
<jcowan> oni-on-ion: It's the same
<oni-on-ion> ok
<it3ration> what [perceived] advantage is there of a Lisp-2 over a Lisp-1? It seems to just make everything more verbose ..
<sjl_> it3ration: being able to name your parameters like a literate person
<sjl_> (foo (lst) ...) what the heck is lst? last? list? lost?
<aeth> it3ration: it's not actually 2.
<oni-on-ion> it3ration: i can say nothing except for the advantages of a lisp-1
<aeth> it3ration: What you wind up doing is having a type foo made with the function foo and calling it the variable foo.
<oni-on-ion> sjl_: last
charh has quit [Ping timeout: 268 seconds]
LiamH has quit [Quit: Leaving.]
<oni-on-ion> (fst, snd, ..)
<aeth> it3ration: e.g. list is of type list, is made with list (or make-list) and is best called list when there's only one
<aeth> So effectively using a lisp-2 is all about (ab)using the same name like that
<oni-on-ion> there is also things like ((compose sqrt +1) 13) ... which has no alternative
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
fikka has quit [Ping timeout: 272 seconds]
orivej has joined #lisp
<sjl_> I find it allows SBCL to catch some of my stupid mistakes too -- like if I name a parameter "timestamp" but try to use it in the body as "timestamp" it will tell me I'm an idiot, instead of evaluating time as the built-in function time.
<sjl_> er, "use it in the body as "time""
loli has quit [Quit: WeeChat 2.3]
dariken has joined #lisp
<oni-on-ion> oh thats a feature that something like GCC would have... just years and years of patterns, may as well get the compiler to warn about common things. not sure if it is smart
Quike has quit []
fsmunoz has quit [Quit: rcirc on GNU Emacs 26.0.50]
<jcowan> IMO the Lisp-1/Lisp-2 (really more than 2) distinction is trivial
<fiddlerwoaroof> sjl_: yeah, the extra "type-checking" a lisp-2 enables makes a huge difference
<fiddlerwoaroof> I keep on doing things like (defn do-something [keys map] ...) in clojure and then scratching my head when clojure tells me sometime later that "keys is not a function"
<fiddlerwoaroof> Or, even worse, "map is not a function"
<it3ration> I do prefer the way Lisp-1's look
<fiddlerwoaroof> And, a lisp-2 isn't all that more verbose: when you're doing "functional" stuff, you just pass function values or symbols around
<it3ration> I know it's silly, but I hate seeing (funcall stuff ..)
<it3ration> But I digress
<jcowan> call/cc, proper tail calls, syntax-rules, dynamic-wind vs. unwind-protect, and relentless monomorphism are much more significant.
<fiddlerwoaroof> You can defer funcall quiote a ways...
<oni-on-ion> for how i code, lisp-1 is a world of difference
<fiddlerwoaroof> You can defer funcall quiote a ways...
<it3ration> oni-on-ion: which are you a proponent of?
<fiddlerwoaroof> only one funcall and a bunch of function manipulation inside
<oni-on-ion> also yeah jcowan . also engines =P
<jcowan> that's a consequence of call/cc.
<aeth> it3ration: write a reader macro to make [foo 42] into (funcall foo 42)
<oni-on-ion> it3ration: lisp-1? one sec i will search up that word.
<oni-on-ion> ah. just learned about them yesterday
smokeink has joined #lisp
<fiddlerwoaroof> I know eval is evil, but I also like that scheme's eval takes an environment as a parameter
<aeth> eval isn't evil in Lisps
<it3ration> I actually wondered if someone has written a package to use clojure-like names
<oni-on-ion> it3ration: ah, in favor of lisp-1
<fiddlerwoaroof> If there were a good scheme-in-cl, I'd use that feature for safe remote code execution in a web context
<jcowan> SEND + AETH = MONEY
<it3ration> I do like the functional nature of Clojure, gotta say
<oni-on-ion> fiddlerwoaroof: there is a lot of cl-in-scheme -- for eg. guile supports CL style defmacro , remote repl, etc
<fiddlerwoaroof> Yeah, but I'd have to use a lisp-1 ;)
<it3ration> I've been an engine programmer in the game industry for a decade, and wanted to [make the worst choice possible] have some fun and build a little engine in Clojure, but the memory management is just not gonna cut it probably, even with something like LWJGL
<aeth> fiddlerwoaroof: eval(foo) in other languages is (eval (read-from-string foo)) in Common Lisp (and probably something similar in Scheme).
<fiddlerwoaroof> And I'd have to give up FORMAT and LOOP as well as CLOS
<it3ration> I just think it'd be cool to pop into a repl in-game
<oni-on-ion> i've written some game stuff in clojure and cljs, before Cl
<fiddlerwoaroof> aeth: sure, eval still has sother issues
<aeth> fiddlerwoaroof: It's the read[-from-string] part that you have to trust, especially if *read-eval* is T
<it3ration> I've taken a look at some of the things out there, there's one guy doing some fun things in CL
<aeth> fiddlerwoaroof: In CL, the main issue with eval is that you probably want a macro instead
<it3ration> At least in CL I can mutate state (for better or for worse)
<fiddlerwoaroof> look at #clgames it3ration if that's what you're interested in
<oni-on-ion> it3ration: lots of guys doing CL game stuff. check #lispgames
<aeth> fiddlerwoaroof: It's #lispgames
<fiddlerwoaroof> listen to oni-on-ion and aeth
<fiddlerwoaroof> :)
<jcowan> eval takes a global environment object in Scheme
<fiddlerwoaroof> Yeah, that's cool
<fiddlerwoaroof> If it's what I think it is, it allows for some nice sandboxing stuff
<jasom> it3ration: I assume you're familiar with Naughty Dog's usage of lisp?
<it3ration> jasom: yep I have some friends that work there
<it3ration> I've been a hardcore emacs user for about 15 years - using Clojure has been fun, I'm so tired of the imperative shitshow that is C / C++
<oni-on-ion> why is GOAL the default mention for lisp and games? isnt that a couple decades ??
<it3ration> Been living in that world for a decade
<jasom> oni-on-ion: because it's the last significant usage of lisp in a AAA game?
<oni-on-ion> also lisp was well used in mario64 and nintendo64 stuff, also no one mentions ABUSE by crack dot com, with also their own lisp interpreter (that was my second exposure to it)
<fiddlerwoaroof> xelf.me looks pretty cool too, but I've never been able to get it to work on mac
<it3ration> Dave Taylor is one of my good friends actually, he made Abuse :)
<fiddlerwoaroof> As does https://github.com/borodust/cl-bodge
<oni-on-ion> jasom: is that like saying steven spielberg used Xyz supercomputers and sets and actors, so whatcha gonna do for your hobby project ?
<it3ration> I may be way off base here, but it seems like Clojure has better parallelism / concurrency support on the JVm
<oni-on-ion> it3ration: what! actually ? i read the history on it. worked in an apartment etc. (similar to my adventures in vancouver )
<oni-on-ion> abuse is one of my heaviest inspirations =P
<fiddlerwoaroof> it3ration: depends what you mean
<aeth> The thing is, that's Lisp as a scripting language. #lispgames is more about Lisp as an engine implementation language, or at least partially as one (lots of C/C++ libraries and in some cases like OpenGL they're unavoidable).
<jasom> oni-on-ion: even outside the AAA field, games written completely in any lisp are unusual
loli has joined #lisp
<fiddlerwoaroof> The CL standard doesn't specify concurrency semantics
<oni-on-ion> jasom: i heard the space program was a good game
<oni-on-ion> =p
<aeth> (Well, as an engine implementation language in addition to a scripting language)
<it3ration> aeth: yeah, that's the only reason I haven't fully dived in - it'd have to be for fun only, because writing a cross-platform engine in CL is the path to NEVER EVER SHIPPING haha
<fiddlerwoaroof> But it's not too hard to implement core.async-like patterns using something like ChanL
<fiddlerwoaroof> and then there's also lparallel which provide equivalents of clojure's pmap, as well as more complicated constructs
<oni-on-ion> oh ah yep. CL and its images. its like you marry a lady then she got her dog the cat her cousins grandma parents old collections of dolls ahhhh
<it3ration> I'd have to write backends for Metal et al, Apple deprecated OpenGL
<aeth> it3ration: The copyright in my license starts at 2013.
<oni-on-ion> if i were doing real parallel or gpu or numeric work, i would go full-forward face-first into julia hands-down
<aeth> it3ration: But it's not never shipping, it's more like full maturity in 10 years from the start point, perhaps with something shippable a few years before it's really mature.
<jasom> writing a cross-platform engine has almost always been hard; OpenGL appears to have been a historical anomoly
<aeth> it3ration: You don't have to write a backend for Metal. You can just (1) ignore macOS or (2) use Vulkan and moltenvk
<aeth> You only *need* a Metal backend if you're writing iOS games
<aeth> And mobile is basically its own genre at this point
<aeth> I'd say the bigger issue is console support
<fiddlerwoaroof> Or you can do that opengl-in-metal route, right?
<oni-on-ion> https://github.com/part-cw/lambdanative <-- now you know
nanoz has joined #lisp
<it3ration> I mean, i've been an engine programmer for a long time - writing an engine is so orthogonal to shipping a game
<oni-on-ion> also the simple/tiny/crossplat "raylib" works in web and mobiles. also i heard SDL does too. lots of solutions....
<it3ration> I bet shipping a CL game on mobile would be an absolute nightmare, but I'm not sure
<oni-on-ion> what does orthogonal mean in that context, intertwined ?
<aeth> it3ration: I agree to both points
<jcowan> fiddlerwoaroof: Unfortunately, there's no portable way to create global environments at runtime. There is the interaction environment (the one the REPL uses, if there is a REPL, which there usually is), and you can create environments from libraries, but they are not reliably mutable
<it3ration> I just want a repl goddammit haha
<oni-on-ion> dto (maker of xelf) did some experiments with ECL. its just slow and fat
<aeth> it3ration: Except certain kinds of games definitely are best made on a custom engine, e.g. Factorio or Minecraft.
<it3ration> yep fer sher
<it3ration> I'd have to substantially limit my audience
<aeth> If you're shipping a typical game, a mainstream engine probably is the best fit, but if you stray too far, a custom engine can still make sense given how much you'd have to hack around insomething like Unity to get acceptable performance.
<it3ration> like Windows / OSX / *nix only
<aeth> s/insomething/in something/
<it3ration> I wonder how CL's FFI is
<it3ration> when it comes to memory management
<aeth> Of course, you *can* hack around something like Unity to make a game it's not suited for, e.g. Cities: Skylines.
<it3ration> Yeah sure - their ECS stuff is really performant now too, you
<aeth> I was about to say that things might be changing there
<it3ration> would not be able to touch it in something like CL
<aeth> eh
<it3ration> They're generating near-optimal code with intrinsics per-platform in Unity these days, they tried to hire me awhile ago
<fiddlerwoaroof> it3ration: cl can do intrinsics
<fiddlerwoaroof> At least, various implementations can
<it3ration> I'm not saying it's not possible, just not easily possible ;)
<it3ration> haha
<aeth> it3ration: You could non-portably use SBCL's define-vop and then have a fallback in native CL for non-supported implementations and architectures.
<fiddlerwoaroof> It's actually trivial
<it3ration> How much control do you have over memory in CL?
fikka has joined #lisp
<it3ration> What platforms is SBCL on?
<aeth> it3ration: What I do is I preallocate everything before the game loop. Essentially the object pool pattern with a twist
<fiddlerwoaroof> Mac/Windows/Linux/*BSD/etc.
<jasom> it3ration: all desktops, no mobile.
<aeth> Preallocating is not quite the same thing as manual memory management, of course.
<it3ration> fiddlerwoaroof: what about consoles?
<aeth> it3ration: Of course if you wanted platform support you'd have to port it to the consoles yourself
<it3ration> I wonder how hard it'd be to compile to those platforms
<aeth> For consoles it supports the architectures, but not the OSes
<aeth> You'd also have to write a renderer backend for each
<it3ration> I'd say at that point, you pay someone to rebuild the game if you make $ ;)
<fiddlerwoaroof> Yeah, the os is the hard part
<jasom> it3ration: sbcl can cross compile, but you'd have to implement the runtime.
<fiddlerwoaroof> here's some more code using intrinsics for SSE stuff: https://www.pvk.ca/Blog/2013/06/05/fresh-in-sbcl-1-dot-1-8-sse-intrinsics/
<aeth> it3ration: What I'd personally do if I ever was successful enough to think about console ports is make the console ports a commercial feature of my permissively-licensed engine.
<aeth> it3ration: i.e. The three PC OSes are free, but you'd pay to have the console renderers
igemnace has joined #lisp
<fiddlerwoaroof> Lispworks already supports mobile too
<fiddlerwoaroof> If you're really to pay them for it :)
<fiddlerwoaroof> s/really/willing/
<aeth> The commercial Lisps are about features, but SBCL is about maximum performance.
<aeth> I'd stick to SBCL for serious game engine projects.
<fiddlerwoaroof> Lispworks isn't particularly slow
<aeth> Obviously make sure it's still portable to CCL, etc.
<fiddlerwoaroof> but, SBCL is pretty fast for numeric stuff
<aeth> fiddlerwoaroof: The core of a game engine is pretty much entirely numeric stuff
<oni-on-ion> getting to know *any* compiler well, will have the same general outcome.
<aeth> fiddlerwoaroof: Or at least, you can express it as such with enough macros
<it3ration> bbiab guys (and gals?) - gotta eat quick
<it3ration> I know there's some guy doing CL game stuff on Youtube, I can't remember his name
<aeth> The task of game engines definitely plays to SBCL's strengths, although my engine is still geting acceptable FPS in CCL
<aeth> it3ration: One good thing about SBCL is that it's mostly public domain with a fallback to BSD (iirc) and with some permissively licensed components from elsewhere. So if porting to consoles is incompatible with the GPL, you can still do it with SBCL.
<White_Flame> it3ration: baggers?
<aeth> CCL is apparently Apache licensed so it should also be compatible with console ports even where the task is GPL-incompatible
<aeth> (I don't know if this is an issue or not. If I ever have a problem where I need to port one or more implementations to consoles, I'd have enough money to pay someone to solve that problem.)
<didi> TIL SBCL let me (declare (optimize (debug 0.5))). I thought only natural numbers were allowed.
<no-defun-allowed> it executes code with (debug 0) half the time and (debug 1) the other half
<aeth> didi: I'm not very surprised because it probably uses <, =, >, <=, and >= to make its decisions
<aeth> Not sure if it's portable, though
it3ration has quit [Ping timeout: 244 seconds]
<didi> oic
paul0 has joined #lisp
<sjl_> > SBCL allows any real value for optimization qualities. It may be useful to specify 0.5 to get backtrace argument display without argument documentation.
<aeth> Wow, so it's actually intentional
<sjl_> clhs optimize
<sjl_> it is not portable
<sjl_> > value---one of the integers 0, 1, 2, or 3
<aeth> So I guess you'd have to #+sbcl 0.5 #-sbcl 1 every time you use it
neirac has quit [Remote host closed the connection]
orivej has quit [Remote host closed the connection]
orivej has joined #lisp
emaczen has quit [Ping timeout: 252 seconds]
sjl_ has quit [Quit: WeeChat 2.3-dev]
eddof13 has quit [Quit: eddof13]
eddof13 has joined #lisp
didi has quit [Remote host closed the connection]
anewuser has joined #lisp
warweasle has joined #lisp