<kathe>
would you be in a position to comment on which is a good common lisp programming environment under macos?
<kathe>
i am currently on ubuntu, but might migrate to macos in 6 years time.
<kathe>
i "was" going to migrate to windows and hence use lispworks, but macos is looking very impressive.
occ has quit [Read error: Connection reset by peer]
karmichammer has quit [Ping timeout: 256 seconds]
mon_aaraj has quit [Ping timeout: 250 seconds]
<semz>
kathe: Clozure CL is probably a good choice, it focuses on Macs quite a bit and I think it even has its own IDE on there (although I've never used it so I can't say anything about its quality)
mon_aaraj has joined #commonlisp
<kathe>
semz: thanks for that tip, it led me to discover hemlock.
<kathe>
semz: and due to hemlock, i found out about clx.
<kathe>
semz: many thanks.
<kathe>
hmnn, hemlock is very interesting, but doesn't have the wide array of modes available with 'gnu' emacs.
<kathe>
i think i'd better stick with ubuntu and learn 'gnu' emacs well.
<beach>
Good morning everyone!
<kathe>
heya beach. how've you been?
<kathe>
beach: i'm here after a long time, been unwell.
<beach>
Sorry to hear that.
<kathe>
beach: you know me also as "mayuresh" and "mayureshkathe".
<beach>
Got it.
<kathe>
though i've now settled down with "kathe" as that's also my domain name.
<kathe>
i don't have any background in common lisp nor emacs, and i'm a bit confused about how to learn both in parallel without messing up my thought process.
<kathe>
i used to work with autolisp, so that's my route to common lisp.
<kathe>
i know that there is a tutorial and a manual inside emacs itself.
<kathe>
so should i first work through the emacs tutorial and manual, get well acclimatised with emacs and then start-off with common lisp?
<kathe>
though i have no idea about how to make emacs work with 'sbcl' as an 'ide'.
<kathe>
i had been quite gung-ho about forth, but after my interaction with some people from it's community regarding introducing a "condition system" and an object system via a metaobject protocol were shot down, i'm going to stick with common lisp.
<EdLangley[m]>
ccl doesn't work on M1 macs at the moment
<EdLangley[m]>
At this point, IMO, sbcl is the best implementation on macs
<kathe>
thanks EdLangley, i think i'm going to stick with ubuntu. not only does it offer better facilities for development systems but a ubuntu-based setup also costs a lot lesser than a mac.
<White_Flame>
kathe: pretty much everybody doing CL is using emacs
<kathe>
sorry about the expressing interest in macos before i'd factored in the cost.
<kathe>
White_Flame: so i've heard. even my mentor uses it.
<White_Flame>
those who don't use emacs are forging their own path, and yeah hopefully other paths get as fully supported
<ns12>
kathe: What text editor are you currently using? Perhaps your current text editor has some support for Common Lisp. This will free up more time for learning Common Lisp.
<kathe>
i cut my teeth on 'sco' openserver so i tend to lean toward vi (not vim), but i'm eager to learn emacs because of the tight integration with common lisp development routines.
<White_Flame>
after sbcl & emacs, you want to install, in order: quicklisp, quicklisp-slime-helper
<White_Flame>
you shouldn't really need to adjust any config files after following their steps
<kathe>
White_Flame: i'll look into quicklisp and quicklisp-slime-helper.
<EdLangley[m]>
https://portacle.github.io is also a good way to get a nice package of "all of the above"
<White_Flame>
oh wait, I keep forgetting about portacle
<White_Flame>
yeah
<White_Flame>
it's a "lisp in a box" singel solution
<ns12>
I personally use the SBCL REPL directly (with rlwrap for readline keybindings). That's another way to defer learning Emacs.
<minion>
kathe: look at PCL: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
<kathe>
EdLangley: i've heard rumours about 'pcl' being reworked on. true?
<kathe>
ns12: thanks for both those links. very helpful. :)
<ns12>
In the free books list, "Practical Common Lisp" and/or "Common Lisp: A Gentle Introduction to Symbolic Computation" are typically recommended to beginners.
<White_Flame>
also, the #clschool channel is dedicated to learning
<kathe>
I checked out slimv and vlime based setup, but i think i'll go with emacs because i can do almost everything else from within emacs (irc, email, notes, todo, etc.).
<lisp123>
#CLSCHOOL is a gem
<kathe>
White_Flame: thanks for that tip.
<lisp123>
kathe: Try EVIL Mode in Emacs
<ns12>
lisp123: I wish there were public logs of #clschool.
<kathe>
ns12: i've heard that the digital version of touretzky's book doesn't have corrections present in the paperback one.
<kathe>
i think that org-mode thingy is very impressive.
occ has joined #commonlisp
<kathe>
i had an exchange with phoe where he mentioned he's redoing the recipes book.
<kathe>
2 things that most impress me about common lisp are the "condition system" and the "metaobject protocol" based object-system.
OlCe` has quit [Ping timeout: 268 seconds]
<kathe>
i don't remember finding the "condition system" in autolisp, nor did any of the seniors talk about it back then.
<Bike>
"The *error* function takes a single string argument, which is supplied by AutoCAD when an error is encountered during program evaluation. This string describes the error which has caused the *error* function to evaluate." doesn't sound like it has the condition system
<kathe>
it's more like an extended control-flow mechanism. ;)
<kathe>
as phoe calls it. :)
<kathe>
the "condition system" is something else entirely. :)
<kathe>
i went through the sample session in phoe's "Appendix E". it's mind blowing. waiting to complete learning common lisp and buy phoe's book on the "condition system".
Jing has joined #commonlisp
karmichammer has joined #commonlisp
<mfiano>
I'd need conformal displacement for anything more than a flat row-major view of the backing storage, correct?
karmichammer has quit [Ping timeout: 240 seconds]
<Bike>
yeah, standard displacement is all row major all the time
<mfiano>
Currently I only need a view of a pixel in a '(width height channel-count) #3a, but I was also thinking of things like a NxM kernel view for convolutions.
<mfiano>
Guess I could just derive the shape/extents from a single pixel and mutate the original directly.
<mfiano>
Unfortunate, but doable.
semz_ has joined #commonlisp
occ has quit [Ping timeout: 240 seconds]
semz has quit [Ping timeout: 250 seconds]
occ has joined #commonlisp
karmichammer has joined #commonlisp
OlCe`` has joined #commonlisp
karmichammer has quit [Ping timeout: 256 seconds]
<kathe>
brb
semz_ is now known as semz
lisp123 has quit [Remote host closed the connection]
karmichammer has joined #commonlisp
karmichammer has quit [Ping timeout: 256 seconds]
<qhong>
recalling the discussion about software longevity a few days ago, what you guys think about a Nix/Guix replicate that runs in a single Lisp image a la asdf?
beach` has joined #commonlisp
<kathe>
qhong: would you care to elaborate for those who are neophytes?
beach has quit [Ping timeout: 268 seconds]
tyson2 has quit [Remote host closed the connection]
jealousmonk has quit [Quit: ERC (IRC client for Emacs 27.1)]
<kagevf>
I use guix to install nyxt since that's the only way I could figure out how to get all the right versions of nyxt, sbcl, and emacs ... necessary to connect to nyxt's swank server from slime
<kagevf>
qhong: what would the nix/guix inside CL do? find, and build CL systems? and allow easy switching between different versions? and also act as a package manager? so it would replace asdf and QL, plus add the versioning?
pmwals09 has quit [Remote host closed the connection]
karmichammer has joined #commonlisp
wyrd has quit [Ping timeout: 276 seconds]
beach` is now known as beach
karmichammer has quit [Ping timeout: 240 seconds]
occ has quit [Ping timeout: 250 seconds]
occ has joined #commonlisp
aartaka has joined #commonlisp
wyrd has joined #commonlisp
Bike has quit [Quit: Connection closed]
lisp123 has joined #commonlisp
karmichammer has joined #commonlisp
<kathe>
what's the difference between slime and sly?
<kathe>
i mean other than sly is modern.
<moon-child>
sly has 100% more cats
<qhong>
kagevf: Yes I think so
lisp123 has quit [Ping timeout: 256 seconds]
karmichammer has quit [Ping timeout: 240 seconds]
<qhong>
kagevf: I also think that reproducibility is a pain point of the status quo of CL eco-system. Hyrum law is real. I have no hope contemporary CL projects still work after just 20 years
<kathe>
moon-child: :)
karmichammer has joined #commonlisp
karmichammer has quit [Ping timeout: 240 seconds]
<mfiano>
Sounds like CLPM
fitzsim has quit [Read error: Connection reset by peer]
<qhong>
mfiano: AFAIU CLPM is akin to a traditional package manager (ala pip, npm etc) rather than a functional pm
Inline has joined #commonlisp
<mfiano>
Of course. Many existing software systems rely on stateful actions during installation. ASDF is programmable to do anything you could want.
lisp123w has joined #commonlisp
<lisp123w>
kathe: I was trying Sly recently last week but had some pretty bad experiences so reverted to Slime
<EdLangley[m]>
I believe POIU attempted to do something more reproducible
<lisp123w>
But in general Sly has some more advanced features (like stickers, which allows to mark a region to get automatic printing on the output) and a better search
<moon-child>
qhong: cl is in general ideologically aligned towards flexibility over analyzability
mon_aaraj has quit [Ping timeout: 250 seconds]
<kathe>
lisp123w: thanks.
<qhong>
UNIX (and UNIX toolchain) allows as much flexibility (albeit much more poorly designed) on its FS state as CL (and ASDF), yet ppl eventually curse it and invented Nix/Guix
karmichammer has joined #commonlisp
<qhong>
But maybe I'm reading too much and it's a non-problem for CL at least so far
<moon-child>
ha, this comes up again
<moon-child>
unix is referentially transparent
<moon-child>
so chroots are easier
<moon-child>
vs fcge
<mfiano>
jails > chroots
mon_aaraj has joined #commonlisp
<moon-child>
mfiano: well, that is interesting, because jails encapsulate non-referentially-transparent things (such as network devices). Probably not super relevant to present discussion
<qhong>
I think rename-package hack will work for most packages?
<moon-child>
qhong: in particular, I can trivially calculate (and isolate) the closure of some object in unix, but not in lisp
<qhong>
As for edge cases, Nix/Guix has to deal with them manually too and it doesn't seem like too much a practical issue
<mfiano>
No, it really won't. Packages can be created, and sometimes are, at runtime.
<mfiano>
Or as part of the compilation process.
<moon-child>
and I can observe all the side effects of an arbitrary operation (see ptrace, dtrace, this has been effected in practice)
<qhong>
mfiano: I understand you can certainly break it, my question is how many packages actually do it
<mfiano>
THey aren't always statically known.
<mfiano>
Quite a few
<qhong>
moon-child: you mean dependency closure or dependent closure?
<qhong>
I think dependent closure can also be calculated in Lisp
<moon-child>
qhong: the closure of an object is the set containing that object and all the objects it points to
<moon-child>
here I actually meant transitive closure, but
<moon-child>
(actually, the implementation generally gets such a closure, e.g. for fasls; but you do not)
frgo has quit [Ping timeout: 240 seconds]
<qhong>
moon-child: you mean one can get who-reference for arbitrary datum? damn I always want it so hard when CLing
<lisp123w>
kathe: I think Sly works better for multiple REPLs (I was doing a setup where I had SBCL / CCL / CLISP all on 1 command each), but I didn't want to spend time debugging the issues I had (lag on remote connection to an Image, some other strange bugs) so I reverted to Slime and it suited me.
<qhong>
moon-child: guess I should ditch CL and start BASHing
<moon-child>
:/
<lisp123w>
kathe: However, the stickers thing in SLY is really good - so don't discount it based on my words. Its just that I was doing some bespoke setups which Sly had some issues on my machine
karmichammer has quit [Ping timeout: 240 seconds]
<EdLangley[m]>
Lispworks's delivery system can do a bunch of stuff that's unsafe if symbols are interned dynamicaly
<qhong>
mfiano: I think dynamic package creation at compile time should be workable
<kathe>
lisp123w: thanks. on a different note, would you suggest that i learn to work with emacs in parallel with learning common lisp?
<EdLangley[m]>
So, heuristics like "rename package is safe" can get you pretty far
<EdLangley[m]>
But, you need some way of verifying the assumptions
<mfiano>
Can you take care of dynamic runtime code that generates symbols looking for a specific package with uiop:symbol-call, alexandria:format-symbol in macro's, etc?
<EdLangley[m]>
It's not hard to right code that doesn't do that
<qhong>
Basically, before build, all dependency are renamed to their nominal names, and after build, all dependencies plus newly created packages are renamed to their unique name
<qhong>
mfiano: if they happen at runtime then it's screwed
<mfiano>
I wouldn't want anything to do with such restrictions, but then again, I don't like Linux either.
<EdLangley[m]>
I don't use things like INTERN and UIOP:SYMBOL-CALL very much at all
<lisp123w>
kathe: Yes, it will be useful for many reasons I won't go into. The trick with Emacs is read the tutorial and guide (don't just jump in), then learn the keybindings C-h k (which lets you see what a keystroke does), C-h f (which describes function at point), C-h v (which describes variable at point), C-h b or C-h m (to see what keybindings are active in the buffer). But I'll shut up now (you can ask #emacs for more help there)
<EdLangley[m]>
And I can tell when a system uses them, because inevitably my preference of doing (setf print-case :downcase) breaks loading such systems :)
<qhong>
EdLangley[m]: That may be a nice hack to test the FPM assumption!
<mfiano>
Lisp is too dynamic :)
* mfiano
is amused at the thought of #'(setf documentation) being changed when you look at it.
<EdLangley[m]>
Macros that generate symbols need to use this :)
<qhong>
And if they use this they can break FPM assumption while passing the above test...
<EdLangley[m]>
Anyways, a lot of programs can still run if you delete all the packages
<EdLangley[m]>
As long as you keep a reference to the entrypoint somewhere
<qhong>
Actually I think there is an outrageous hack to make macros finding specific package at runtime still work
<qhong>
First I assume they will use keyword symbols instead of strings, then we can unintern those keywords after each build, and hack `find-package` so they recognize such keyword
<qhong>
(resolve them to proper dependency)
<lisp123w>
EdLangley[m]: !!! Thank you for that archaic macro, very useful to protect against unintended consequences
karmichammer has joined #commonlisp
<EdLangley[m]>
So, I think the best way (at the moment) to make building systems deterministic is to compute a dependency graph of the system you want to load and then do a depth-first postorder traversal of the graph, building each system you encounter in a subprocess
<EdLangley[m]>
Then you load all the generated FASLs in order
<qhong>
EdLangley[m]: hmm, interesting. so, because we can't do isolation in Lisp, let's use UNIX process virtualization to do isolation
<qhong>
EdLangley[m]: sounds plausible but I don't really like it because unix :/
karmichammer has quit [Ping timeout: 250 seconds]
<qhong>
EdLangley[m]: wait isn't that just using Guix
<kathe>
i gotta go now.
kathe has quit [Quit: leaving]
artchad has joined #commonlisp
lispy has quit [Quit: Leaving]
karmichammer has joined #commonlisp
azimut_ has quit [Ping timeout: 276 seconds]
karmichammer has quit [Ping timeout: 250 seconds]
xsperry has quit [Read error: Connection reset by peer]
s-liao has quit [Ping timeout: 256 seconds]
karmichammer has joined #commonlisp
mon_aaraj has quit [Ping timeout: 240 seconds]
karmichammer has quit [Ping timeout: 268 seconds]
kathe has joined #commonlisp
mon_aaraj has joined #commonlisp
Algernon69 has joined #commonlisp
Algernon91 has joined #commonlisp
Jach has left #commonlisp [#commonlisp]
rgherdt has joined #commonlisp
vats has quit [Ping timeout: 240 seconds]
Inline has quit [Ping timeout: 250 seconds]
Algernon69 has quit [Ping timeout: 240 seconds]
xsperry has joined #commonlisp
Jach has joined #commonlisp
karmichammer has joined #commonlisp
karmichammer has quit [Ping timeout: 256 seconds]
xsperry has quit [Read error: Connection reset by peer]
karmichammer has joined #commonlisp
Cymew has joined #commonlisp
xsperry has joined #commonlisp
<phoe>
kathe: you can buy the book before completing learning Common Lisp! </shameless_plug>
karmichammer has quit [Ping timeout: 240 seconds]
<kathe>
phoe: i assure you that i will definitely buy the book, only i want to be ready for it. :)
<moon-child>
I dare say if you have completely learned common lisp you will not get much value out of the book, but
<phoe>
:D
<kathe>
phoe: will you please consider writing a similar walk-through for 'clos' using 'mop'? currently there are disparate books, mostly going beyond what's really required to work under common lisp.
<moon-child>
amop?
<mfiano>
AMOP is the one to read.
<mfiano>
THough as a technical book, it is quite dry and makes many mistakes.
<kathe>
'amop' is dependent on "keene".
<phoe>
yes
<kathe>
and "keene" isn't readily available. even on amazon.
<kathe>
phoe: thanks a million for considering.
<phoe>
the only sane way to access keene's book is to *somehow* grab a physical copy or to visit Library Generic
pranavats has left #commonlisp [Error from remote client]
<mfiano>
Well I got it a few years ago, but I never opened it yet.
<phoe>
yes, these are the used ones I menioned
mon_aaraj has quit [Quit: WeeChat 3.4]
artchad has quit [Read error: Connection reset by peer]
<phoe>
the new ones have insane prices
<mfiano>
Mine is new. Arrived in pristine condition too
<kathe>
phoe: a book for the rest of us. please please please. :)
<phoe>
kathe: hm
karlosz has joined #commonlisp
gioyik has quit [Quit: WeeChat 3.3]
xsperry has quit [Read error: Connection reset by peer]
<mfiano>
Hmm I think I'll read this book this weekend. Looks like I will enjoy it better than AMOP. I found too many errors in that book that stunted my learning and questioned my sanity.
<kathe>
phoe: i think you'd do a better job of writing an error-free book.
<phoe>
kathe: if you're alluding to TCLCS, I simply had enough reviewers from all over my known Lisp world
karlosz has quit [Ping timeout: 240 seconds]
<phoe>
that was enough to catch many many mistakes I'd personally made as a writer
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
<phoe>
this, and TCLCS is so much *less* complex than the MOP
<mfiano>
I heard a bad review of TCLCS the other day :(
<phoe>
!
<kathe>
phoe: i bet you'll get similar support for a 'clos'/'mop' book which is modern.
shka has joined #commonlisp
cosimone has joined #commonlisp
<phoe>
I need to know it so I can possibly improve a future second edition
<mfiano>
Let me see if I can find it.
karmichammer has joined #commonlisp
<kathe>
phoe: there's a book on 'clos' by paepcke from 'mit' press.
<parjanya>
‘modern’ is overrated, if something works well that’s more than enough (and hi)
<phoe>
the main issue with keene book is that some examples don't really work anymore, and they're kind of badly chosen (e.g. the lock primitive)
<kathe>
phoe: the 'mit' press book explains 3 different approaches to 'mop' implementation without relying on common lisp.
<phoe>
and paepcke's is kind of a collection of articles rather than a singular and consistent book
karlosz has joined #commonlisp
<kathe>
is i agree on that about the paepcke book.
<phoe>
which makes it both interesting for some people and uninteresting for others
<kathe>
in fact most of the paepcke book seems to be available as papers in 'pdf'.
mon_aaraj has joined #commonlisp
xsperry has joined #commonlisp
karmichammer has quit [Ping timeout: 250 seconds]
Major_Biscuit has joined #commonlisp
<kathe>
i found a book called "interpreting lisp" by knotts. is it good?
<kathe>
i gotta go. time for lunch. see you all later.
kathe has quit [Quit: leaving]
mgl has joined #commonlisp
Lord_Nightmare has joined #commonlisp
Major_Biscuit has quit [Ping timeout: 268 seconds]
s-liao has quit [Ping timeout: 256 seconds]
karlosz has quit [Quit: karlosz]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
pve has joined #commonlisp
Major_Biscuit has joined #commonlisp
karmichammer has joined #commonlisp
Dynom has joined #commonlisp
karmichammer has quit [Ping timeout: 256 seconds]
OlCe`` has quit []
iamFIREc1 has joined #commonlisp
karmichammer has joined #commonlisp
karmichammer has quit [Ping timeout: 240 seconds]
occ has quit [Ping timeout: 256 seconds]
cosimone has quit [Remote host closed the connection]
karmichammer has joined #commonlisp
s-liao has joined #commonlisp
vats has joined #commonlisp
karmichammer has quit [Ping timeout: 240 seconds]
OlCe has joined #commonlisp
knobo has joined #commonlisp
davep has joined #commonlisp
artchad has joined #commonlisp
Jing has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
luna-is-here has joined #commonlisp
amk has quit [Remote host closed the connection]
amk has joined #commonlisp
Jing has joined #commonlisp
cosimone has joined #commonlisp
wyrd has quit [Ping timeout: 276 seconds]
wyrd has joined #commonlisp
karmichammer has joined #commonlisp
karmichammer has quit [Ping timeout: 240 seconds]
kevingal has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life has joined #commonlisp
kevingal has quit [Ping timeout: 240 seconds]
kevingal has joined #commonlisp
karmichammer has joined #commonlisp
knobo has quit [Quit: Client closed]
karmichammer has quit [Ping timeout: 256 seconds]
s-liao has quit [Ping timeout: 256 seconds]
kathe has joined #commonlisp
<kathe>
looks like it's either going to require extreme dedication for me to erase 24 years of ingrained key-stroke muscle memory, or i'm going to have to use "vim + vlime".
<kathe>
emacs has this interesting thing called buffers which become useful when grabbing code from/to the emacs email client, emacs code editor, emacs irc client and org-mode.
<kathe>
it would allow me to never take my hands off the keyboard and not have to switch between multiple onscreen windows for various applications. emacs has all of it in one place. in addition to having fantastic support for common lisp development.
lisp123 has joined #commonlisp
attila_lendvai has joined #commonlisp
karmichammer has joined #commonlisp
<phoe>
kathe: or use evil mode
<phoe>
all the vim keybindings on all of the emacs
<phoe>
e.g. spacemacs has an option to use it by default
Algernon91 has quit [Ping timeout: 268 seconds]
<kathe>
phoe: great! thanks for that tip. will look into it.
<ns12>
How do BSD users get their Common Lisp libraries if they do not use Quicklisp? The ports tree for FreeBSD, NetBSD, and OpenBSD are mostly devoid of Common Lisp libraries.
Equill has quit [Ping timeout: 256 seconds]
<kathe>
ns12, i don't think there are very many common lisp developers working on any of the 'bsd' systems.
occ has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<mgl>
Is there an equivalent of sb-ext:symbol-global-value on ECL?
<phoe>
ns12: it doesn't, at least for me on mostly default evil settings - but I use smartparens instead
s-liao has quit [Quit: Client closed]
s-liao has joined #commonlisp
<phoe>
mgl: maybe #ecl will be able to answer better
<mgl>
thanks
mjoerg has joined #commonlisp
mjoerg has quit [Remote host closed the connection]
Equill has joined #commonlisp
frgo has joined #commonlisp
karmichammer has quit [Ping timeout: 250 seconds]
karmichammer has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<ns12>
kathe: So what OS do Common Lisp programmers use? Linux? Some Linux distributions use NetBSD's ports tree (pkgsrc). There are zero Common Lisp libraries in pkgsrc.
karmichammer has quit [Ping timeout: 250 seconds]
<phoe>
linux here
<phoe>
I also know about macos and windows people
pjb has quit [Read error: Connection reset by peer]
<kathe>
ns12, mostly linux (debian and derived) and macos.
<kathe>
ns12, i think most common lisp libraries are got using quicklisp.
<ns12>
Yeah, Debian has many Common Lisp libraries in its package repository.
pjb has joined #commonlisp
<phoe>
(sadly)
<phoe>
they are a constant source of anguish and conflicts to anyone who has them installed and wants to use e.g. Quicklisp
<ns12>
Isn't that ASDF's fault for not allowing users to arbitrarily add/remove/reorder the directories where libraries are found?
<phoe>
it allows them to do so
<phoe>
but people need to remember to do it, and they don't
<ns12>
AFAIK, it is not possible to make ASDF ignore a single directory such as /usr/share/common-lisp/cl-asdf/
<phoe>
it's possible to remove it from its central registry variable, that's for sure
karmichammer has joined #commonlisp
<ns12>
Suppose I have installed many Common Lisp libraries using APT. The libraries get installed in /usr/share/common-lisp/ (e.g. /usr/share/common-lisp/cl-lib1/, /usr/share/common-lisp/cl-lib2, etc.).
<ns12>
How do I make ASDF completely ignore the existence of /usr/share/common-lisp/cl-lib1/ only?
<ns12>
Isn't the asdf:*central-registry* method obsolete?
<phoe>
I have no idea how to exclude it the "proper" way, I'
<phoe>
I'd simply clone cl-lib1 into my local-projects and have this one provide cl-lib1.asd
<ns12>
asdf:*central-registry* is NIL by default, so there is really nothing to remove from it.
<ns12>
"I'd simply clone cl-lib1 into my local-projects and have this one provide cl-lib1.asd" - Yes, but then ASDF will complain/warn that there are two different versions of the same library ...
karmichammer has quit [Ping timeout: 240 seconds]
<phoe>
will it? AFAIK it'll stop on the first found ASD file
<phoe>
but then again, I might very likely be wrong
karmichammer has joined #commonlisp
<phoe>
I do not have a lot of practical ASDF experience, I use it for simple cases most of the time
<ns12>
"I have no idea how to exclude it the "proper" way" - I actually have no idea whether or not it is possible. I'll read the docs again (for the fourth time...).
<ns12>
Me too, I use it for simple cases most of the time. I just have not figured out how to make ASDF ignore one single library at a specified filepath.
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
ec has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
s-liao has quit [Ping timeout: 256 seconds]
<_death>
maybe something like putting (:source-registry (:exclude "cl-lib1")) in ~/.config/common-lisp/source-registry.conf (I've not tried it.. check the manual for more info)
<_death>
add seasoning and :inherit-configuration
mon_aaraj has quit [Ping timeout: 240 seconds]
parjanya has quit [Ping timeout: 268 seconds]
lisp123 has joined #commonlisp
mon_aaraj has joined #commonlisp
lisp123 has quit [Ping timeout: 256 seconds]
<phoe>
minion: memo for marcoxa: a CDR idea would be to make DESCRIBE for symbols configurable, so e.g. if I create some custom namespace mapping from symbols to my custom objects, I can have this reflected in (describe 'foo); the portable DESCRIBE-OBJECT mechanism doesn't allow for that.
<minion>
Remembered. I'll tell marcoxa when he/she/it next speaks.
mgl has quit [Quit: Client closed]
<_death>
maybe trying to use describe for that is what's wrong
<_death>
also note that any arbitrary object can serve as a name for something
<phoe>
_death: I'm looking at LISP-NAMESPACE and the horrible hack it uses for actually adding things to DESCRIBE output
<phoe>
and the worst thing is that it seems to work, and that LISP-NAMESPACE is the 51st most popular Quicklisp system
<_death>
just because someone wrote something doesn't mean it's a good idea?.. and just because it's been downloaded many times doesn't mean it's popular (= used by many)
<phoe>
agreed, and agreed
<beach>
Perhaps it is best to supply something entirely different both for DESCRIBE and DOCUMENTATION. I mean, no other module depends on them, so we might as well design a new mechanism for them.
<beach>
That way, we could plan for internationalization, for instance, but also for something other than raw text for DOCUMENTATION.
<phoe>
yes, but that won't work with CL:DESCRIBE, which is *the* object description facility
<phoe>
same with CL:DOCUMENTATION
<beach>
Yes, that would be the point. Abandon those broken facilities.
<phoe>
they ain't broken, they just aren't extensible
<phoe>
think CL streams without Gray streams
<beach>
Whatever.
<phoe>
or CL:READ without Eclector :D
<phoe>
I assume we could use a client technique to pass additional arguments to DESCRIBE or DOCUMENTATION, just like Eclector does with READ
<Shinmera>
Colleen: look up multilang-documentation
<beach>
Shinmera: Great! Too bad the language object is not that of acclimation.
<Shinmera>
Granted, I never had the time to actually make use of it. But I hoped it would find some use when the Radiance documentation was translated into Japanese. Sadly it never got beyond the primary documentation file (so no docstrings were localised)
<beach>
Anyway, I was also thinking of structured documentation that can contain links, and that can be presented in different ways.
<beach>
But I'll be quiet now.
<Shinmera>
I think someone here used my documentation-utils package with an extension of their own to provide structured docstrings that are then just compiled down to a plaintext version for backwards compat.
<_death>
maybe some semantic network package that could allow interactive exploration
* Shinmera
has to return to gamedev
Major_Biscuit has quit [Ping timeout: 240 seconds]
vats has quit [Ping timeout: 240 seconds]
kathe has quit [Quit: leaving]
<phoe>
...the elephant in the room that is here is that none of the implementations seem to define an :AFTER (SYMBOL T) method on DESCRIBE-OBJECT
Major_Biscuit has joined #commonlisp
karmichammer has quit [Ping timeout: 240 seconds]
artchad has quit [Read error: Connection reset by peer]
occ has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
<_death>
so there's a semantic network project called sneps.. sneps3 is from 2012 and seems to use ltk/common-graphics or a java gui.. it also has allegro-specific code for loading (no asdf), wonder how much effort would be needed to get it to work portably.. and it seems they decided to rewrite in clojure :o
<_death>
anyway, it's a pretty small project (10kloc incl. ltk bundled) so.. not much effort
mepy has quit [Remote host closed the connection]
pieguy128 has quit [Ping timeout: 256 seconds]
<_death>
with some gamedev toolkit (trial) maybe an interface like http://www.wikiwebapp.com/ can be written for introspecting the lisp image
lisp123 has quit [Ping timeout: 240 seconds]
<Shinmera>
I will happily accept contributors to Trial/Alloy :)
morganw has joined #commonlisp
pieguy128 has joined #commonlisp
<_death>
ah yes, I probably meant alloy
<Shinmera>
Trial is the game engine, Alloy the UI toolkit.
karmichammer has joined #commonlisp
<_death>
maybe some weekend ;)
<_death>
I did just try some alloy examples, and seems to mostly work.. menu-bar items appear to have wrong widths (maybe has something to do with stumpwm?)
<Shinmera>
_death: The glfw backend uses the fond text renderer, which is abandoned. The maintained backend is the msdf renderer, but that one requires precompiling texture atlases for fonts using an external tool. |3b| has been working on the pure-lisp version of that for some time, and hopefully it'll be ready for use this year so I can switch to that and purge the fond one.
<_death>
I see
pieguy128 has quit [Ping timeout: 240 seconds]
<morganw>
Could I ask, was there ever a working prototype or theory about how to run a Common Lisp game on Android or iOS?
<Shinmera>
Iirc there are cl games running on android.
<Shinmera>
stuff published on the store even.
<morganw>
Would those likely be using ECL and then wrapping the native code?
<Shinmera>
yes
Bike has joined #commonlisp
karmichammer has joined #commonlisp
pranavats has left #commonlisp [Error from remote client]
pieguy128 has joined #commonlisp
wyrd has quit [Ping timeout: 276 seconds]
karmichammer has quit [Ping timeout: 240 seconds]
nij- has joined #commonlisp
taiju has quit [Remote host closed the connection]
<phoe>
replace the last part of the URI with your system name
<foxfromabyss>
yes but .. i am *searching* for a library and not sure if the one i found is the one I am looking for
<foxfromabyss>
oh I see, thanks
<Shinmera>
so just quickload it and M-. to it :)
<foxfromabyss>
pfft :D
<Shinmera>
it's not a joke
karmichammer has joined #commonlisp
azimut has joined #commonlisp
karmichammer has quit [Ping timeout: 240 seconds]
pranavats has joined #commonlisp
fitzsim has joined #commonlisp
<foxfromabyss>
i guessed as much, just too lazy to do it, hence the pfft :P
occ has joined #commonlisp
karmichammer has joined #commonlisp
parjanya has joined #commonlisp
epolanski has joined #commonlisp
<epolanski>
hey all, pretty new to common lisp. I wanted to ask if there's some library to write html front ends in pure common lisp. I don't really need much js interop I can implement all I need on my own
<phoe>
epolanski: CL-WHO comes to mind
<Shinmera>
I use clip
<Shinmera>
for pretty much everything, both static and dynamic.
<Shinmera>
I may be biased for the usual reasons though
<epolanski>
interesting I want to give it a spin, I have recently released a pet project and since I have already all E2E tests setup I thought it would be nice to create an experimental branch and TDD the same application in a different language, possibly common lisp
<Shinmera>
sounds like a plan :)
waleee has joined #commonlisp
<Josh_2>
Hello
<Josh_2>
I use spinneret for generating HTML
<pve>
epolanski: there's also CL-EMB, which has a bit of a JSP vibe
<Shinmera>
There's a *ton* of HTML generators
<Shinmera>
not sure if there's as many as there are json parsers, but it has to be close.
<semz>
it's just so simple to make one
Inline has joined #commonlisp
<epolanski>
ok but generating templates is one of the issues, what about interacting with dom APIs?
<epolanski>
e.g. making SPAs in scala, elm, haskell, ocaml is possible, wonder if that's true for common lisp as well
<Shinmera>
You can use stuff like Parenscript to pretend like you're writing CL which is then spit out as JS
<Shinmera>
But all of these approaches are severely limited and only expose a subset of CL
<Shinmera>
There is currently no full implementation that can compile to JS, and it is unlikely it would be worth it anyway, due to the runtime size imposed by the CL standard.
foxfromabyss has quit [Ping timeout: 256 seconds]
<epolanski>
is that because many cl apis are implemented in C?
<Shinmera>
Common Lisp is a big standard, with a lot of stuff that is needed to make an implementation compliant. For instance, the entire compiler needs to be available at runtime. By necessity this makes the runtime large.
<epolanski>
I'm new to CL but I've read that many CL functions are not implemented in CL itself but, e.g. in C
<Shinmera>
where did you read that
<Shinmera>
because it's bonkers
<beach>
I too would like to know the author of that writing.
<epolanski>
I've read that in Land of Lisp book
<beach>
I have that book. Can you give a page number?
<beach>
It would be another item in my list of points where that book is bad.
<ck_>
Barsky uses and recommends clisp in his books, right?
<ck_>
what's number one on that list?
<Shinmera>
epolanski: To preempt things, how functions are implemented is an implementation detail. However, all implementations that are in serious use implement most of their library in CL. C is only really used to interface with the operating system or to implement very hairy things like the GC.
<epolanski>
I'm not ultra fond of the book to be honest, not as much as I was in SICP when I've first read it
<epolanski>
found many enthusiastic comments on hacker news so I started reading it
<beach>
I recommend Practical Common Lisp instead.
<beach>
minion: Please tell epolanski about PCL.
<minion>
epolanski: please look at PCL: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
<epolanski>
thanks, I will add it to the list 💪
<beach>
epolanski: But I would still like to know the page number of that.
<beach>
... of that statement that many CL APIs are implemented in C.
<epolanski>
I will check it later as I read it on a different device
<beach>
No rush.
<epolanski>
Shinmera: then I guess that it's similar to how JS node makes syscalls implemented in a different language.
<epolanski>
but it's only a detail of the environment rather than the language itself
<beach>
epolanski: And you can remove Land of Lisp from your list. It contains so many errors that it is embarrassing, and it is likely to give the reader many incorrect ideas.
<epolanski>
thank you, never ever gonna trust hacker news on lisp again
<aeth>
iirc, Land of Lisp has a whole chapter that only works in CLISP, which hasn't had a stable release in over 10 years (July 2010)
<Shinmera>
Snide comment: "don't trust hacker news" seems like a generally applicable recommendation :)
<aeth>
and imo CLISP was never that good of an implementation unless you needed low RAM (because it's bytecode interpreted, not native compiled)
<pve>
Clearly there should exist a "html templating library construction kit", that makes the user answer questions like "Name of library?", "Use CLOS? Y/N", "Single or multiple packages?", "Coding style? [80's, 90's, ...]" etc and then output the library. This way people could get the feeling of rolling their own, without wasting a bunch of time ;)
<Xach>
There are a few users who post good/interesting Lisp info on HN. I follow lispm, mikelevins, reikonomusha and a few others directly via https://hnrss.github.io rather than going to the site.
<aeth>
HN was always about startups... Lisp and programming-in-general content has gone down and complaining-about-housing-costs-in-SF has gone up as the bull market rallies for over a decade now.
<ck_>
n-gate.com seems to be on hiatus unfortunately
waleee has quit [Ping timeout: 240 seconds]
treflip has joined #commonlisp
karmichammer has quit [Ping timeout: 256 seconds]
<tyson2>
I got very frustrated trying to figure out Land of Lisp. Now restarting with PCL
<tyson2>
indeed LoL has some very confusing code and quite a few errors
nworb has quit [Quit: Client limit exceeded: 20000]
<_death>
I found land of lisp entertaining, but I was not a newbie at the time, and I wouldn't recommend it to newbies
<aeth>
I think it needs a new edition
nworb has joined #commonlisp
<aeth>
it could probably be fixed
<aeth>
Iirc, I have an ebook PDF of it... from a Humble Book Bundle ages ago?
Bike has quit [Quit: Connection closed]
<tyson2>
aeth: I found the author's lisp style to be confusing
<tyson2>
seemed hackerish to me
<tyson2>
mind you there was some interesting ideas in the book
<aeth>
tyson2: well, my impression at the time, and it has been years, is that it seemed oudated.
<tyson2>
anyway I've committed to PCL, just need to block out regular timeslots for it
<aeth>
my impression of PCL is that it doesn't seem... linear? I definitely read the chapters out of order as needed
<aeth>
definitely more useful than LoL
<tyson2>
I decided not to try using PCL on windows, will install it in WSL (probably using Docker image), and develop from emacs on windows, which I'm comfortable with
kevingal has quit [Ping timeout: 250 seconds]
<tyson2>
sbcl I mean
karmichammer has joined #commonlisp
kevingal has joined #commonlisp
<etimmons>
qhong: Since you referenced the discussion a few days ago, I'm guessing you're also interested in loading multiple versions of the same system into the same image? Perhaps even as part of the dependency tree of a single project?
<etimmons>
If so, I think your rename-package hack will also likely make generic functions way less useful.
Bike has joined #commonlisp
<etimmons>
Let's assume there's a system (and package) FOO. It defines the class BAR and has a generic function BAZ with a method specialized on BAR.
<etimmons>
Then I have a system qux that somehow pulls in two different versions of FOO in its dependency tree. Let's say they're renamed to FOO@1 and FOO@2.
<etimmons>
Under the current practice, it'd be completely fine to share instances of BAR across different branches of the dependency tree.
<etimmons>
But if that happens with the rename-package hack, you'll likely end up calling FOO@2:BAZ on a FOO@1:BAR instance. No such method exists for that: boom.
<etimmons>
nij-: you may be interested in that ^ as well
mgl has joined #commonlisp
<beach>
Another reason for first-class global environments.
<etimmons>
beach: I really need to read your paper on that. It's very interesting to me, but so far I've been inferring capabilities based on what other people are saying
<etimmons>
Need to go directly to the source myself
<beach>
etimmons: I don't think you have to do that. It is pretty trivial, really.
<beach>
The only invention is the cell thing to make function calls as fast as in typical Common Lisp implementations.
<qhong>
etimmons: I'm still thinking about what reproducible mean under CL context. I think the problem stems from the absence of distinction between "software" and "config" in Lisp system. Different version of "software" should be definitely isolated, but maybe not so config. We may heuristically count all special variables and generic functions as configs.
<qhong>
beach: I don't think FCGE can help with the above generic function problem
<beach>
etimmons: But you can obviously read it if you like.
<etimmons>
I guess my biggest question is how can different environments interact (if at all). That's not something I've been able to glean from listening to others
scymtym has quit [Ping timeout: 240 seconds]
<beach>
It is also not described in the paper.
<phoe>
EdLangley[m]: the main issue with GENERIC-{FLET,LABELS} is the special operator CL:FUNCTION - we want it to return the GF itself, rather than some intermediate function that wraps over it (as would be the case with FBIND)
<beach>
But I think I may have a video on that. For the online Lisp meeting.
<phoe>
EdLangley[m]: it seems that a real GENERIC-FBIND trying to bind a function named FOO would need to bind a generic function object as some lexical variable #:FOO, then walk the body form and rewrite it in order to replace (FOO ...) calls with (FUNCALL #:FOO ...) and value occurrences of #'FOO with just #:FOO
<phoe>
and that's ugly but necessary if we want CL:FUNCTION to work correctly in that context
<phoe>
either that, or get an implementation-defined FBIND, or use some kind of DEFGENERIC-with-an-anonymous-name trickeries like that post mentioned
ec has quit [Ping timeout: 276 seconds]
nij- has left #commonlisp [#commonlisp]
<Bike>
i wonder if an fbind could be useful for other things. if not generic functions, some other kinds of funcallable instances.
<phoe>
I guess it could, sure
<phoe>
if you have a working implementation-defined FBIND then a GENERIC-FLET becomes easy
<phoe>
but there isn't such a thing, AFAIK, and won't be because FBIND requires evaluation before a function is bound
<phoe>
the best there is is SERAPEUM:FBIND which does macrology and binding intermediate functions to work around this
tyson2 has quit [Remote host closed the connection]
<Bike>
"won't be"? i mean, i don't see any reason it couldn't work as a language extension
<phoe>
OK, let me clarify: "won't be" as in "I have no idea if any implementer actually considers it worthy enough to implement it as a true special form"
<phoe>
and it needs to be a special form because it needs to interact with CL:FUNCTION
<phoe>
...or it needs to walk and rewrite bodies as I mentioned above
<Bike>
oh, yeah sure.
<Bike>
guess it could be slightly complicated since now #'foo can mean something other than a known function or global lookup. probably not a huge deal though.
<phoe>
the whole point of it being a special form is it interacting with CL:FUNCTION the same way that CL:FLET and CL:LABELS do
mon_aaraj has quit [Ping timeout: 240 seconds]
<phoe>
how exactly its semantics are implemented is a bit more complex I guess, because you need to grab a function as a value and stuff it back into the function namespace
<phoe>
and unlike with FLET/LABELS you have no idea what kind of function object it is, you don't know its lambda list or type
<phoe>
(and unlike with global lookups)
<phoe>
I guess that can complicate a FBIND implementation, unless the programmer provides appropriate FTYPE declarations
<phoe>
like, (defun foo (fn) (fbind ((fn fn)) ...)) - inside the body we have no idea what #'FN is like or how to optimize it
mon_aaraj has joined #commonlisp
<Bike>
yeah, but that's also true if you just write #'fn to refer to a global function.
<phoe>
yes
<phoe>
like, a naïve version would be to rewrite FBIND into LET, FUNCTION of FBIND'd functions into variable references, and calls
<phoe>
I can probably grab a code walker and make a portable PoC of sorts
cage has joined #commonlisp
<phoe>
like, if CL-CONT can do that then so can we
<Bike>
oh i'm just thinking of how to do it as an implementor. if i wanted to try a userspace thing i'd probably just shadow cl:function and #' and call it good
<phoe>
I'd call it sorta ugly and actually rewrite the body instead, so I can keep the original cl:function and #'
<Bike>
i figure it would be fine since if you're using fbind you're already doing an extension thing, and also it's lexical, so the fbind user is also the one using the shadow #'
<Bike>
fbind would toss some information into symbol-macrolet, which the function macro would then use, and if there wasn't any fbind to the name it would just expand into cl:function
kevingal has quit [Ping timeout: 256 seconds]
<phoe>
yes
<phoe>
I just want to avoid shadowing CL:FUNCTION for user convenience
kevingal has joined #commonlisp
jealousmonk has joined #commonlisp
splatt990 has quit [Quit: Gateway shutdown]
[smlckz] has quit [Quit: Gateway shutdown]
amb007 has quit [Read error: Connection reset by peer]
Cymew has quit [Ping timeout: 256 seconds]
jeosol has joined #commonlisp
amb007 has joined #commonlisp
Inline__ has joined #commonlisp
Inline has quit [Ping timeout: 256 seconds]
Oladon has joined #commonlisp
ec has joined #commonlisp
scymtym has joined #commonlisp
* phoe
has an oh-shit moment when he realizes that agnostic-lizard is GPLv3
artchad has joined #commonlisp
<beach>
What's the problem with that?
<phoe>
I supplied it as a dependency for a MIT library, and that's not a good thing licensing-wise
<beach>
I see.
<qhong>
Anyone who understand what GPL means for CL?
<pl>
qhong: people have issues understanding what GPL means for /C/, Lisp is probably exposing it even more :/
<phoe>
I guess it's same as elsewhere, you need to share source code for everything in your Lisp image when you deliver binaries containing GPL code, plus anti-tivoization clauses in case of GPLv3
<phoe>
figuring out "what's code and what's data" is left as an exercise to the reader
Inline has joined #commonlisp
Inline__ has quit [Ping timeout: 250 seconds]
<qhong>
phoe: so lispworks is screwed?
<Bike>
why would lispworks be screwed
<phoe>
I have no idea :D it probably uses the same mechanism that allows you to deliver GPLv3 code using proprietary compilers, e.g. MSVC or Intel for C/C++
ec has quit [Ping timeout: 276 seconds]
foxfromabyss has joined #commonlisp
<qhong>
phoe: but lispworks will live inside the same image/address space…
<phoe>
yes, the main exercise here is that there's no good way to tell apart the code and the platform in image-based environments
<pl>
phoe: scope of what's covered by GPL or not is apparently non-trivial
<foxfromabyss>
But it fails with HTTP 400 being unexpected, regardless whether I target a remote, known-to-work, server, or the local server, done like the example in the repo suggests
<foxfromabyss>
Any advise on how to troubleshoot this?
<foxfromabyss>
*advice
<random-nick>
I think GPL has a section about system libraries, which is what allows you to compile with proprietary C compilers but I don't know if something like the entirety of lispworks counts as a system library for the GPL
<phoe>
well, you can't run Lisp code without a Lisp implementation, so
Jing has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
tyson2 has joined #commonlisp
Algernon91 has quit [Ping timeout: 268 seconds]
Algernon666 has quit [Read error: Connection reset by peer]
treflip has quit [Remote host closed the connection]
<Bike>
EdLangley[m]: what i'm envisioning here is situations in which you want to do something with the instance other than call it.
ec has joined #commonlisp
<Bike>
in which case you can't then work with #'foo, which is just a mundane function
wyrd has quit [Ping timeout: 276 seconds]
<White_Flame>
dbotton: your URL included "web_3" and I was about to rail against that phrase ;)
<White_Flame>
thankfully, that was not the case
<EdLangley[m]>
Bike: good point
<Bike>
that said, while i've probably defined more classes of functional instances than 99.9% of lispers, i've never really needed to lexically bind them.
<Bike>
partly that's probably because i'm using them within an implementation, though. people writing software software probably have different patterns
<fe[nl]ix>
phoe: alexandria:unwind-protect-case implements the technique in your blog post
<dbotton>
White_Flame lol well nothing has changed on the web in a very long time, including people trying to hi jack names with version numbers
<dbotton>
The fact that CL is so stable is one of its greatest appeals
Bike has quit [Quit: Connection closed]
Inline has joined #commonlisp
Oladon has quit [Quit: Leaving.]
<phoe>
fe[nl]ix: !!!
* phoe
updates the post
Algernon666 has joined #commonlisp
<Shinmera>
If CL is so stable how come my game crashes all the damn time
<Shinmera>
Checkmate, atheists
<Catie>
Gottem
<phoe>
fe[nl]ix: updated, thank you!
lisp123 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
ec has quit [Ping timeout: 276 seconds]
lisp123 has quit [Ping timeout: 250 seconds]
<phoe>
EdLangley[m]: (eq #1# #'foo) ;=> NIL
<phoe>
that's the only issue, as Bike mentioned
<EdLangley[m]>
Yeah, personally I'd put up with that to avoid code-walking :)
<EdLangley[m]>
Alternatively, FBIND could just have lisp-1 semantics and just LET + FLET foo
<phoe>
I'mma go the rough route
* phoe
quickloads hu.dwim.walker
foxfromabyss has quit [Quit: Client closed]
varjag has joined #commonlisp
<dbotton>
shinmera as we I use to say in my corporate days - but it worked on my machine - ie don[t blame for human error ;)
<Shinmera>
My shitty code doesn't even work on my machine
<dbotton>
Ah but do enough ctr-alt-x and nothing works
Major_Biscuit has quit [Ping timeout: 256 seconds]
Algernon666 has quit [Ping timeout: 268 seconds]
<Shinmera>
Anyway, sure wish I had the money to hire another programmer so I could concentrate on, you know, actually designing stuff instead of fixing the myriad of bugs in my tower of yaks
Bike has joined #commonlisp
luna-is-here has quit [Quit: luna-is-here]
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #commonlisp
anticomputer_ has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
lispy has joined #commonlisp
luna-is-here has joined #commonlisp
<dbotton>
I think that is the dream of all developers
ec has joined #commonlisp
<Shinmera>
Is it? Some people love to debug.
<dbotton>
Those are programmers
<Shinmera>
Feels like semantics.
<dbotton>
I develop software as my artistic expressions
<dbotton>
I know how to program of course
<dbotton>
That is what I am loving most about CL, the ease to express my ideas
<dbotton>
If I had the money I would hire a programmer to add the robustness needed that I get in other languages like Ada that don't come for free but you are forced to address from the start
<dbotton>
not the language mind you, add the robustness to my code
ec has quit [Ping timeout: 276 seconds]
_73` has joined #commonlisp
raeda has joined #commonlisp
<Shinmera>
For the scale of the kind of game I'm building I'm definitely way under-budgeted and under-staffed :/
waleee has joined #commonlisp
_73 has quit [Ping timeout: 256 seconds]
aartaka has quit [Ping timeout: 256 seconds]
aartaka has joined #commonlisp
_73` has quit [Ping timeout: 256 seconds]
Major_Biscuit has joined #commonlisp
Major_Biscuit has quit [Ping timeout: 250 seconds]
Major_Biscuit has joined #commonlisp
Major_Biscuit has quit [Ping timeout: 252 seconds]
foxfromabyss has joined #commonlisp
<foxfromabyss>
I feel a bit overwhelmed by the amount of json libraries, that all look good
tyson2 has quit [Remote host closed the connection]
asarch has quit [Quit: leaving]
Bike has quit [Quit: Connection closed]
tyson2 has joined #commonlisp
ec has joined #commonlisp
jeosol has quit [Quit: Client closed]
artchad has quit [Read error: Connection reset by peer]
karmichammer has quit [Ping timeout: 250 seconds]
Bike has joined #commonlisp
attila_lendvai has joined #commonlisp
ec has quit [Ping timeout: 276 seconds]
karmichammer has joined #commonlisp
lispy has quit [Quit: Leaving]
karmichammer has quit [Ping timeout: 240 seconds]
aartaka has joined #commonlisp
Dynom has quit [Quit: WeeChat 3.4]
karmichammer has joined #commonlisp
davep has quit [Quit: Connection closed for inactivity]
karmichammer has quit [Ping timeout: 240 seconds]
kevingal has quit [Remote host closed the connection]
mon_aaraj has quit [Ping timeout: 256 seconds]
wyrd has joined #commonlisp
mon_aaraj has joined #commonlisp
mgl has quit [Ping timeout: 256 seconds]
aartaka has quit [Ping timeout: 250 seconds]
aartaka has joined #commonlisp
wmblathe_ has joined #commonlisp
wmblathers has quit [Ping timeout: 256 seconds]
karmichammer has joined #commonlisp
karmichammer has quit [Ping timeout: 250 seconds]
aartaka has quit [Ping timeout: 240 seconds]
karmichammer has joined #commonlisp
varjag has quit [Quit: ERC 5.4.1 (IRC client for GNU Emacs 29.0.50)]
attila_lendvai has quit [Ping timeout: 250 seconds]
akoana has joined #commonlisp
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 256 seconds]
pve has quit [Quit: leaving]
phantomics has quit [Ping timeout: 240 seconds]
jeosol has joined #commonlisp
rgherdt has quit [Ping timeout: 250 seconds]
mgl has joined #commonlisp
phantomics has joined #commonlisp
kevingal has joined #commonlisp
wmblathe_ is now known as wmblathers
shka has quit [Ping timeout: 240 seconds]
karmichammer has quit [Ping timeout: 256 seconds]
<phantomics>
For all who are interested: I will be hosting a webinar on the April APL compiler (compiles APL into Common Lisp) tomorrow at 16:00 UTC. You can see the webinar at https://zoom.us/j/858532665, the passcode is 391680 It may be early for American viewers; that's 8am on the US west coast
<phantomics>
This webinar is hosted by the British APL Association, so it'll offer a look at April from the perspective of APL users, as opposed to my last presentation which was directed at Lisp users
Algernon69 has joined #commonlisp
<phoe>
nice! will there be a recording? (I won't be able to attend)
azimut_ has joined #commonlisp
azimut has quit [Ping timeout: 276 seconds]
Algernon91 has joined #commonlisp
occ has quit [Ping timeout: 256 seconds]
Algernon69 has quit [Ping timeout: 268 seconds]
Algernon91 has quit [Read error: Network is unreachable]
karmichammer has joined #commonlisp
Major_Biscuit has joined #commonlisp
waleee has quit [Ping timeout: 240 seconds]
waleee has joined #commonlisp
Major_Biscuit has quit [Ping timeout: 256 seconds]
cosimone has quit [Ping timeout: 268 seconds]
igemnace has joined #commonlisp
nij- has quit [Quit: Using Circe, the loveliest of all IRC clients]
karmichammer has quit [Ping timeout: 250 seconds]
pranavats has left #commonlisp [Error from remote client]