<jmercouris>
Why might it be that my standalone program can call obj-c no problem, but when I use slime to call those same functions/methods, nothing is recognized
<whoman>
clim-listener i understand is close (well, Jupyter lets say is closer to original CLIM listener ?)
<whoman>
jmercouris: link in the objc runtime ?
<Shinmera>
whoman: there already is cl-jupyter
<jmercouris>
whoman: ?
<whoman>
oh !
<whoman>
jmercouris: objc requires a runtime .so/.a
smurfrobot has joined #lisp
<jmercouris>
whoman: Well, my application works, I just can't call the obj-c functions via slime invokations
<Bike>
jmercouris: mac has a thing where you can only do things in the main thread, and the slime repl isn't the main thread. might be related, don't know.
<whoman>
Bike: i am not sure if that has changed in objc 2.0 but that is mostly for Cocoa app main loops (NSApplication##)
<Bike>
jmercouris: :style :spawn means it spawns threads.
<jmercouris>
Hmmm ok, let me try removing that line, maybe it'll be on the same thread
<jmercouris>
there is probably some weird context among threads
<jmercouris>
though I imagine the instance should be able to respond to a selector among all threads
kartik1 has joined #lisp
kark has quit [Ping timeout: 248 seconds]
<jmercouris>
I have no idea how the runtime works internally, but that's worth a shot
quazimodo has joined #lisp
<whoman>
dont think that would affect the objc runtime. its never had anything much to do with threads as it is
smurfrobot has quit [Ping timeout: 240 seconds]
<whoman>
i would be concerned if sending messages had such a requirement
<jmercouris>
Still "unrecognized selector"
<jmercouris>
maybe there is part of CCL that does the lisp -> objc translation that is not getting compiled into my image resulting in malformed selectors
<jmercouris>
let me try compiling with no --no-init flag
Josh_2 has quit [Remote host closed the connection]
<whoman>
ohh. objc needs a few more ABI-level stuff. not quite as heavy as C++, but it needs special handling afaik.
<whoman>
selector names at least in pre-2.0 objc were like "_i__ClassName___selectorName_arg_arg2_"
<whoman>
so yeah. its been a while, check the FFI and that sort of thing, also have a look at Objective-CL written by a local
cromachina has quit [Read error: Connection reset by peer]
<jmercouris>
huh, still unrecognized selector
<jmercouris>
again though, mabye in making my custom image I'm removing some crucial thing
<jmercouris>
whoman: What do you mean the Objective-CL written by a local?
wxie has joined #lisp
<whoman>
nothing just ignore me im just typing completely unrelated stuff, im sure you will work out your issue soon enough
quazimodo has quit [Ping timeout: 240 seconds]
<jmercouris>
whoman: I can't tell if you are being sarcastic or not, because the thing about the threads you are correct, that is related, and would be strange if the runtime behaved that way
damke has joined #lisp
damke_ has quit [Ping timeout: 240 seconds]
teddy_error has joined #lisp
<jmercouris>
Problem figured out, thanks!
kartik1 has quit [Ping timeout: 248 seconds]
orivej has quit [Ping timeout: 248 seconds]
turkja has joined #lisp
<whoman>
aewmsoe! what was it, btw?
<jmercouris>
Subclass ccl::ccl-application in the standalone application instead of ns:ns-application
<jmercouris>
Apparently ccl::ccl-application provides some of these faculties, and I guess without them, the translation couldn't be made correctly/atall
<whoman>
ahh, ccl has mac-specific things? that is great =)
<jmercouris>
whoman: Again, I'm really confused if you are being sarcastic :D
<jmercouris>
CCL is built with an obj-c bridge and cocoa support
cromachina has joined #lisp
<jmercouris>
so there is a large portion of it that is mac specific
<jmercouris>
it's actually a descendant from maclisp iirc
applePrincess has joined #lisp
SuperJen has joined #lisp
<jmercouris>
Bike: You were also partially correct, it seems that one must launch slime on the same thread as the cocoa ui to avoid issues
<Bike>
the second best kind of correct.
<jmercouris>
yeah, so basically if you call it in the cocoa thread and it launches a new thread, it loses its mind
CrazyEddy has joined #lisp
<jmercouris>
I don't think it ever gets correct context, I'm not super interested in debugging it actually, becuase I don't think it's a heavy penalty to have swank on the main thread, probably an advantage if anything
<whoman>
minion memo jmercouris papyrus is lighter and cleaner, but org is structured and allows other code as well. i think i will stay with org for literate docs
dieggsy has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
<Bike>
sbcl probably has fewer docstrings.
<waynecolvin>
it has more, and style suggestions!
Josh_2 has joined #lisp
astronavt has joined #lisp
dieggsy has joined #lisp
<Zhivago>
aeth: See destructuring-bind :)
<aeth>
I'm considering building a very complicated, almost loop-like language with keywords
<Zhivago>
I'd recommend considering not doing that.
<Zhivago>
Very complicated things rarely work well in general, much like loop.
z3t0 has joined #lisp
<aeth>
I think I have three possibilities. I can have a family of related macros that largely share the same code. This is sort of like do-foo. I can build a complicated syntax that basically requires Emacs+SLIME to know what's going on through the names. Or I can sort of build almost a loop-like thing (really just keyword arguments) that could ideally be at least readable without an API reference.
mint has quit [Ping timeout: 240 seconds]
<Zhivago>
I'd suggest a radically different idea.
<Zhivago>
Start by writing functions.
<Zhivago>
Then write macros which expand into calls to those functions.
<_death>
macros with &key can be tricky.. think preservation of the order of evaluation
mson has joined #lisp
Guest99667 has quit [Remote host closed the connection]
<Zhivago>
That way you can separate the functionality from fiddling endlessly with syntax.
Guest99667 has joined #lisp
z3t0 has quit [Remote host closed the connection]
esthlos has joined #lisp
fikka has joined #lisp
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
z3t0 has joined #lisp
d4ryus3 has joined #lisp
<whoman>
so i guess packages are flat? or could one construct a tree organization ?
esthlos has quit [Client Quit]
<Zhivago>
They're flat in CL, but there are some extensions for heirarchy.
<aeth>
whoman: You can do that manually. e.g. foo, foo/bar, foo/bar/baz. uiop:define-package's :use-reexport is useful for this
<aeth>
i.e. foo uses :cl (so you can in-package) and use-reexports foo/bar and foo/quux and foo/bar use-reexports foo/bar/baz, etc.
esthlos has joined #lisp
CrazyEddy has quit [Remote host closed the connection]
d4ryus2 has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 240 seconds]
<whoman>
hmm. hopefully i can keep things simple
<aeth>
use-reexport keeps things simple
smurfrobot has joined #lisp
<aeth>
You have hierarchies of packages all building up exports, but with only the bottom level (or top level? depends on how you look at it) actually naming what it exports
neoncontrails has joined #lisp
<Zhivago>
The reason that it is flat is separate compilation -- and that the package is part of the symbol name.
<whoman>
well. i figure if i were to conflict with my own names, either my names are not good enough or i'm making up too many things that need names.
<aeth>
Zhivago: What I've been doing with the more complicated macros is relying on helper macros, so each layer of abstraction can technically be avoided. e.g. with-foobar might use a with-bar, which can be used on its own, too.
<Zhivago>
Well, you can always make more packages :)
<whoman>
too many similar things**
<whoman>
and that=)
<Zhivago>
aeth: Perhaps, but I'd recommend that with-bar expand to a call to a bar-foo function.
<whoman>
aeth scared me yesterday about name conflicts and i had haskell and js nightmares so i got edumacated
z3t0 has quit [Remote host closed the connection]
<Zhivago>
aeth: Then your macro can look like (defmacro with-bar (zoo &body body) `(bar-foo ,zoo (lambda () ,@body)).
z3t0 has joined #lisp
<aeth>
whoman: but I should emphasize again that my package layout in zombie-raptor is the nuclear carpetbombing solution to name conflicts and there are probably simpler ways.
smurfrobot has quit [Ping timeout: 248 seconds]
<whoman>
haha true enough. ive closed the tab because of so many keyword symbols
<aeth>
Zhivago: The problem is that these macros are run very frequently in loops within loops (possibly within loops)
<Zhivago>
Macros aren't run at all -- the code they expand to is run.
<aeth>
(And the macros can possibly create loops)
<Zhivago>
Fortunately we have the ability to control the in-lining of function calls.
ahungry has joined #lisp
<whoman>
hmm what is the opposite word for Scale. macros shouldn't shrink stuff, but expand them. no? i mean they arent called micros. and code Scales well sure, but what is the opposite ? well now i just dont know any more.
<Josh_2>
Scale works both way no?
<Josh_2>
gets bigger and can get smaller
<whoman>
that is what i am used to, eg. scale 0.5
neoncontrails has quit [Ping timeout: 258 seconds]
<whoman>
it kind of feels that aeth is going in a certain direction with the macros. but i am a newbie, never wrote more than 1 level of macaroni
CrazyEddy has joined #lisp
<Zhivago>
Aeth's plan seems to be to invent a new language which consists of a flat list of values and keywords in order that slime not be confused by its structure.
<aeth>
whoman: Macros could shrink things, even usefully. Consider a macro that removes trivial arithmetic operations like multiplication by 0. Iirc, sbcl's compiler's optimizer won't remove them for floating point numbers because that technically can change the outcome of the floating point operations.
<Zhivago>
I expect it will be very educational. :)
<whoman>
lmao
<aeth>
whoman: But it is probably useful to remove things like multiplication by known 0f0
<Josh_2>
I am like Slime, I get confused very often
<Zhivago>
Macros should probably be called syntax transforms.
<whoman>
paradigm shifters
<aeth>
(Sorry, I mean multiplying something by zero and then adding... clearly that could be replaced with nothing.)
<aeth>
(For just multiplying, multiplying by 1 could just be removed.)
<Zhivago>
aeth: Although for those cases you probably want compiler-macros which are a little different.
<whoman>
SPELs
ahungry has quit [Remote host closed the connection]
ahungry has joined #lisp
<aeth>
Zhivago: What I have (and it certainly wastes memory, but that's okay for me) is a bunch of data stored in specialized 2D and 1D arrays of the same length. What I'm doing is hiding that. I actually use symbol-macrolet to make something very similar to with-accessors, which mostly takes care of hiding that.
<aeth>
(For 2D arrays, they're obviously not of the same length as the 1D arrays or even necessarily each other, but they're of the same outer length)
CrazyEddy has quit [Remote host closed the connection]
<aeth>
I either provide a specific ID or I provide nothing. If I provide nothing, I iterate over everything. Either way, code is only executed if the thing implements *all* of the things that I'm accessing with the accessors (checked very efficiently through boolean sets implemented as fixnum bits).
<aeth>
(I think I could actually greatly save memory if I implement a hash function and turn the arrays into a custom hash table, with the ID as a hash key instead of an actual index number to the arrays. But I'm not sure that would work because that wouldn't avoid the worst case of everything implementing everything. It would at least make things more cache-friendly in cases that aren't as bad.)
<aeth>
I'm essentially building something that's almost an ECS and almost an in-memory NoSQL database, and where the language-in-macros part comes in play is that I could greatly expand the possible ways to query the data other than ID match or everything.
<fouric>
"within things"?
wigust has quit [Ping timeout: 240 seconds]
Rawriful has quit [Quit: WeeChat 1.4]
<fouric>
"aeth | Hmm, so macros can have &optional and &key within things apparently" <- have time to elaborate?
* fouric
has written simple macros before (little opengl binding things) but doesn't know enough to know what this is
<aeth>
"code is only executed if the thing implements all of the things" => "code is only executed if the entity contains valid data for all of the tables with accessors in the query"
<aeth>
"macros can have &optional and &key within things apparently" => "macros can have &optional and &key within lists within the top level lambda list apparently"
<aeth>
I think I de-thingified everything
<fouric>
lololololol
<fouric>
(incf aeth) ty!
<aeth>
A specific example: (ecs (index-name &optional index-number) tables-and-accessors &body body)
<fouric>
O.o
<aeth>
Macros have special lambda-lists
<fouric>
i did *not* know that
<fouric>
is that automatic destructuring that i see there, too?
z3t0 has quit [Remote host closed the connection]
<aeth>
for the embedded list?
<fouric>
t
<aeth>
t
z3t0 has joined #lisp
z3t0 has quit [Remote host closed the connection]
<aeth>
And it's slime-friendly, so you can actually figure out what's valid, unlike with tables-and-accessors, which is complicated and arbitrary length, so I have to deal with that myself
z3t0 has joined #lisp
<fouric>
that is *super* cool
<fouric>
thanks for 'splaining!
<aeth>
I'm considering just putting a &key there and allowing complicated queries!
<fouric>
:D
wigust has joined #lisp
<fouric>
dewit
<aeth>
Maybe I can put &allow-other-keys there and be evil, if that's allowed.
<fouric>
uh, is that actually a thing
* fouric
runs to CLHS
<aeth>
it's used in make-instance
<aeth>
And it would be very evil to put it in a gigantic full-of-magic macro
<fouric>
eh, only evil if other people are meant to read it
<fouric>
and even then it's not just evil, but clever, too
damke_ has joined #lisp
* fouric
thinks more code should be clever
ahungry has quit [Remote host closed the connection]
<aeth>
I guess it's future-proofing
dieggsy has quit [Remote host closed the connection]
damke has quit [Ping timeout: 246 seconds]
<aeth>
Oh, I'm writing very clever, terse code. And it's becoming more like that every time I add more functionality. Soon, I'm going to allow a special definition for helper functions so I don't constantly requery the ECS. i.e. implicitly pass just the arrays that are being used, and use with-entity-accessors only, without any direct access to the ECS.
<aeth>
Of course, it leads to people questioning things like why I set a variable to multiple values, e.g. (setf velocity (values x y z))
ahungry has joined #lisp
pierpa has quit [Quit: Page closed]
<aeth>
(setf velocity (values x y z)) is really, roughly: (setf (array-row-of-3 %velocity id) (values x y z)) where array-row-of-3 sets the first three values of a row in a 2D array when given three values... so ultimately (psetf (aref %velocity id 0) x (aref %velocity id 1) y (aref %velocity id 2) z) and quite a few things are being hidden
z3t0 has quit [Quit: Leaving...]
<aeth>
oh, and that's essentially (psetf (aref (velocity-velocity (velocity ecs)) id 0) x (aref (velocity-velocity (velocity ecs)) id 1) y (aref (velocity-velocity (velocity ecs)) id 2) z)
groovy2shoes has quit [Ping timeout: 255 seconds]
Josh_2 has quit [Remote host closed the connection]
fikka has joined #lisp
groovy2shoes has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
<Zhivago>
Very clever, terse code sounds like a recipe for a maintenance disaster. :)
wigust has quit [Ping timeout: 240 seconds]
<aeth>
on the other hand, it reduces the maintenance to a handful of unreadable macros instead of the entire source code
<Zhivago>
If the code is as clever as you can make it, it's probably too clever for you to debug.
<Zhivago>
I'd recommend making the code as boring as possible.
<Zhivago>
(Which often requires more thought)
<Zhivago>
For example, above, how am I supposed to know that velocity is magical like that?
<aeth>
it's actually in the macro above it
<whoman>
ouu interesting. i like that idea. puppet strings for a whole project, the One macro...
<aeth>
(with-selection ecs (id entity-id)\n ((velocity (velocity velocity :row-of 3)))\n (setf velocity (values x y z)))
<aeth>
A bit confusing because the name velocity is used a lot but :row-of 3 basically says it's magical like that, and even says how many values it takes
<whoman>
do u even lisp bro
<Zhivago>
Ok, that's probably a little less horrible but, even so it seems like it would be simpler to have an obvious accessor.
<aeth>
Basically: with the selection from the ecs where id=entity-id from the table velocity bind velocity to the row-of 3 called velocity
<fouric>
if your unreadable, terse code needs to be modified, all aeth has to do is just rewrite it with equally unreadable, terse code that has the new functionality
<whoman>
the hero in Realm[s] of Racket is named Chad
<fouric>
it's easier to write code than read it anyway
<Zhivago>
I'd agree that you probably shouldn't change the meaning of a function.
<fouric>
whoman: i haven't ): school forced me to spend all my time writing verilog instead
<Zhivago>
fouric: But if he doesn't understand what the original does, how will he understand what the new version should do? :)
<fouric>
comments! :D
<fouric>
well, *one* comment
<fouric>
or maybe a docstring
<whoman>
C/java/objc/js//make/etc i can type fast and a lot with some nice music going, its quite chill and mindless. i like how lisp and haskell and ocaml 'force' me to reflect and think, as itchy as my hands are to type.
<aeth>
Zhivago: The accessor is (velocity velocity :row-of 3) and that's the same syntax as directly using with-entity-accessors, it's just combined into the database query
<Zhivago>
Ah, two versions -- one in uncompiled English, the other in perl-in-lisp.
sword has joined #lisp
<whoman>
comments or not, the compiler is still the one "doing" it. code is generally quite specific
<aeth>
Doing things this way saves a lot of repetition (and potential typo bugs) since it's both fetching velocity and accessing velocity in the same place
<aeth>
s/accessing velocity/symbol-macrolet abstracting over the accessor for velocity/
<Zhivago>
I'm not going to stop you from doing this -- but I will point out that as developers mature they move from fancy to boring code. There's a reason for this.
<whoman>
yea Zhivago knows whats up
<aeth>
Zhivago: The array doesn't exist, though. The structs don't exist, either. Those are just implementation details that I want to completely hide from the user.
<aeth>
Otherwise I have to rewrite about a third of my game engine every time I change how the data is structured.
<aeth>
I have already done this about 3-4 times.
ListenBuddy has joined #lisp
<ListenBuddy>
Hello!
ListenBuddy has left #lisp [#lisp]
<aeth>
not even a minute.
<whoman>
=) perhaps just came to share some hellos
daniel-s has joined #lisp
<beach>
Good morning everyone!
ahungry has quit [Remote host closed the connection]
dieggsy has joined #lisp
wxie has joined #lisp
smurfrobot has joined #lisp
daniel-s has quit [Remote host closed the connection]
<fouric>
o7
smurfrobot has quit [Ping timeout: 248 seconds]
ahungry has joined #lisp
dieggsy has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
wxie has quit [Remote host closed the connection]
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
pillton has joined #lisp
EvW has joined #lisp
<aeth>
I didn't think about using macros to generate *inlined* functions, though. hmm...
<aeth>
Is there a resource for this?
EvW has quit [Ping timeout: 248 seconds]
dddddd has quit [Remote host closed the connection]
bigdaddytank has joined #lisp
mson has quit [Quit: Connection closed for inactivity]
grublet has quit [Ping timeout: 255 seconds]
bigdaddytank has quit [Quit: Peace out!]
fikka has joined #lisp
varjag has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
varjag has quit [Ping timeout: 248 seconds]
damke has joined #lisp
damke_ has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 248 seconds]
Josh_2 has joined #lisp
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 255 seconds]
smurfrobot has joined #lisp
k-stz has quit [Remote host closed the connection]
smurfrobot has quit [Ping timeout: 240 seconds]
yeticry_ has quit [Ping timeout: 248 seconds]
asarch has quit [Quit: Leaving]
test1600 has joined #lisp
Josh_2 has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
Josh_2 has joined #lisp
fikka has joined #lisp
damke has quit [Read error: Connection reset by peer]
damke has joined #lisp
wheelsucker has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 248 seconds]
<aeth>
Is there a way to see if a function with a given name exists?
MrBismuth has quit [Read error: Connection reset by peer]
MrBismuth has joined #lisp
phax has joined #lisp
<aeth>
fboundp
Bike has quit [Quit: Lost terminal]
Guest99667 has quit [Remote host closed the connection]
<Ober>
y
Guest99667 has joined #lisp
raphaelss has joined #lisp
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
smurfrobot has joined #lisp
teddy_error has quit [Quit: Peace ☮︎]
smurfrobot has quit [Ping timeout: 255 seconds]
nika has joined #lisp
Josh_2 has quit [Remote host closed the connection]
red-dot has joined #lisp
EvW1 has joined #lisp
EvW1 has quit [Ping timeout: 240 seconds]
phax has quit [Quit: phax]
SaganMan has joined #lisp
ahungry has quit [Remote host closed the connection]
SuperJen has joined #lisp
yeticry has joined #lisp
orivej has joined #lisp
CrazyEddy has joined #lisp
Guest99667 has quit [Ping timeout: 240 seconds]
smurfrobot has joined #lisp
ketralnis has joined #lisp
yeticry has quit [Ping timeout: 255 seconds]
smurfrobot has quit [Ping timeout: 240 seconds]
CrazyEddy has quit [Remote host closed the connection]
test1600 has quit [Quit: Leaving]
yeticry has joined #lisp
Jen has joined #lisp
Jen is now known as Guest46797
CrazyEddy has joined #lisp
vlatkoB has joined #lisp
SuperJen has quit [Ping timeout: 248 seconds]
<SaganMan>
Good Morning
<beach>
Hello SaganMan.
<SaganMan>
I read sbcl realesed a new version recently
<SaganMan>
any major changes?
orivej has quit [Ping timeout: 240 seconds]
<jackdaniel>
important changes are usually mentioned in the announcement
<jackdaniel>
so you need to type "sbcl.org" and select tab with news
<jackdaniel>
(in web browser)
<SaganMan>
-_-
smurfrobot has joined #lisp
<SaganMan>
yes
cess11 has joined #lisp
heurist has quit [Ping timeout: 276 seconds]
heurist has joined #lisp
smurfrobot has quit [Ping timeout: 255 seconds]
CrazyEddy has quit [Remote host closed the connection]
rippa has joined #lisp
CrazyEddy has joined #lisp
CrazyEddy has quit [Changing host]
CrazyEddy has joined #lisp
fikka has joined #lisp
heurist has quit [Read error: Connection reset by peer]
orivej has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
heurist has joined #lisp
wheelsucker has joined #lisp
FreeBirdLjj has joined #lisp
yeticry has quit [Ping timeout: 240 seconds]
heurist has quit [Read error: Connection reset by peer]
SlowJimmy has joined #lisp
smurfrobot has joined #lisp
SlowJimmy has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
yeticry has joined #lisp
heurist has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
mynick has joined #lisp
mynick is now known as Guest11576
Guest46797 has quit [Remote host closed the connection]
Guest46797 has joined #lisp
kartik1 has quit [Ping timeout: 268 seconds]
aeth has quit [Ping timeout: 246 seconds]
aeth has joined #lisp
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
wxie has joined #lisp
dddddd has joined #lisp
mishoo has joined #lisp
yeticry has quit [Ping timeout: 250 seconds]
muresanvlad has joined #lisp
yeticry has joined #lisp
nika_ has joined #lisp
nika_ has quit [Client Quit]
varjag has joined #lisp
nika has quit [Ping timeout: 248 seconds]
varjag has quit [Ping timeout: 258 seconds]
nika has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
yeticry has quit [Ping timeout: 255 seconds]
yeticry has joined #lisp
JenElizabeth has joined #lisp
muresanvlad has quit [Quit: WeeChat 1.4]
flip214 has quit [Read error: Connection reset by peer]
flip214 has joined #lisp
flip214 has quit [Changing host]
flip214 has joined #lisp
muresanvlad has joined #lisp
Guest46797 has quit [Ping timeout: 248 seconds]
d4ryus3 has quit [Quit: WeeChat 1.9.1]
hexfive has quit [Quit: WeeChat 1.9.1]
Devon has joined #lisp
fikka has joined #lisp
troydm has quit [Ping timeout: 240 seconds]
heurist` has joined #lisp
Devon has quit [Ping timeout: 240 seconds]
heurist has quit [Ping timeout: 248 seconds]
troydm has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
cmatei has joined #lisp
wxie has quit [Remote host closed the connection]
varjag has joined #lisp
d4ryus has joined #lisp
xor-xor has joined #lisp
<Ober>
fouric: left handed salut bent at the wrist?
cess11 has quit [Ping timeout: 248 seconds]
random-nick has joined #lisp
grublet has joined #lisp
pillton has quit [Remote host closed the connection]
JenElizabeth has quit [Remote host closed the connection]
JenElizabeth has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
astronavt has quit [Ping timeout: 255 seconds]
SaganMan has quit [Ping timeout: 255 seconds]
scymtym has quit [Ping timeout: 240 seconds]
wheelsucker has quit [Ping timeout: 255 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
damke_ has joined #lisp
red-dot has joined #lisp
damke has quit [Ping timeout: 240 seconds]
JenElizabeth has quit [Remote host closed the connection]
scymtym has joined #lisp
raphaelss has quit [Ping timeout: 240 seconds]
JenElizabeth has joined #lisp
FreeBirdLjj has joined #lisp
Karl_Dscc has joined #lisp
scymtym_ has joined #lisp
SuperJen has joined #lisp
BitPuffin|osx has joined #lisp
scymtym has quit [Ping timeout: 250 seconds]
wxie has joined #lisp
JenElizabeth has quit [Ping timeout: 246 seconds]
wigust has joined #lisp
wxie has quit [Client Quit]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 240 seconds]
shrdlu68 has left #lisp [#lisp]
nika has quit [Quit: Leaving...]
raphaelss has joined #lisp
shenghi has quit [Remote host closed the connection]
shenghi has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
knobo has joined #lisp
karswell has joined #lisp
karswell has quit [Remote host closed the connection]
karswell has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
EvW has joined #lisp
Tobbi has joined #lisp
Ven`` has joined #lisp
yeticry has quit [Ping timeout: 248 seconds]
markong has joined #lisp
yeticry has joined #lisp
Bike has joined #lisp
vap1 has quit [Ping timeout: 250 seconds]
zaquest has quit [Read error: Connection reset by peer]
francogrex has joined #lisp
<francogrex>
http://paste.lisp.org : Due to continued abuse, this service has been disabled
<francogrex>
so that's it, the end of the pastebin?
<jackdaniel>
the end of paste.lisp.org, it's not pastebin. there is plenty of other paste services
<random-nick>
is there a pastebin service which does rainbow parentheses or parentheses highlighting?
yeticry has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
<jackdaniel>
most do. one created by Shinmera has also CL-specific highligting: https://plaster.tymoon.eu/
yeticry has quit [Ping timeout: 240 seconds]
<Shinmera>
It doesn't do paren highlighting though.
<Shinmera>
I should check codemirror if it has a setting for that, actually
<Shinmera>
Ah, there's a plugin.
<Shinmera>
I'll see about adding that.
red-dot has joined #lisp
yeticry has joined #lisp
rgrau has joined #lisp
FreeBirdLjj has joined #lisp
xor-xor has quit [Quit: Killed by buffers]
<francogrex>
pastebin is the end of an era!!! it's yet another setback for common lisp... really makes me sad a little
<francogrex>
0
francogrex has quit [Quit: ERC Version 5.3 (IRC client for Emacs)]
<oleo>
?
<oleo>
use dpaste.com
<beach>
oleo: I think that was supposed to be funny.
yeticry has quit [Ping timeout: 255 seconds]
<Shinmera>
Okey, plaster now does paren matching.
<Shinmera>
Doesn't do rainbow parens, but I never liked that anyway.
yeticry has joined #lisp
attila_lendvai has joined #lisp
yeticry has quit [Ping timeout: 248 seconds]
yeticry has joined #lisp
<pjb>
The big problem with the absence of lisppaste, is that the other don't keep the history. With lisppaste, I could refer to pastes 3 or 5 year old!
knobo has quit [Ping timeout: 255 seconds]
Jen has joined #lisp
Jen is now known as Guest87309
<oleo>
who owned it ?
<oleo>
and why is it gone ?
SuperJen has quit [Ping timeout: 240 seconds]
<oleo>
btw could not someone else had maintained it instead ?
smurfrobot has joined #lisp
<oleo>
i suppose it requires much space too.....
EvW has quit [Remote host closed the connection]
EvW has joined #lisp
<jackdaniel>
oleo: it is gone due to huge volume of spam which couldn't be easily dismissed
yeticry has quit [Ping timeout: 268 seconds]
<jackdaniel>
there was a discussion on mailing list about possibilities, nobody stepped in to propose that he can maintain it *and* keep it safe from spam
yeticry has joined #lisp
<pjb>
Eventually I'll stop using email for spam too… But not right now.
<pjb>
But there's spam everywhere.
<oleo>
yah
<oleo>
and sometimes you don't know what is spam and what is not....
Kundry_Wag has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
igemnace has joined #lisp
Amplituhedron has joined #lisp
FreeBirdLjj has quit [Ping timeout: 240 seconds]
nyef` has quit [Ping timeout: 248 seconds]
wigust_ has joined #lisp
FreeBirdLjj has joined #lisp
wigust has quit [Ping timeout: 255 seconds]
Amplituhedron has quit [Ping timeout: 276 seconds]
varjag has quit [Ping timeout: 248 seconds]
varjag has joined #lisp
josemanuel has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
jmercouris has joined #lisp
jmercouris has quit [Remote host closed the connection]
jmercouris has joined #lisp
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
dddddd has quit [Ping timeout: 248 seconds]
ebrasca has joined #lisp
j0nd0e has joined #lisp
dddddd has joined #lisp
fikka has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 248 seconds]
jfe has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Remote host closed the connection]
jfe has joined #lisp
j0nd0e has quit [Remote host closed the connection]
igemnace has quit [Ping timeout: 248 seconds]
Guest11576 has quit [Remote host closed the connection]
fikka has joined #lisp
Kundry_Wag has joined #lisp
alexmlw has joined #lisp
dieggsy has joined #lisp
asarch has joined #lisp
terpri` has quit [Remote host closed the connection]
Josh_2 has joined #lisp
sz0 has joined #lisp
Josh_2 has quit [Remote host closed the connection]
fnodeuser has joined #lisp
fnodeuser has left #lisp [#lisp]
jfe has quit [Ping timeout: 240 seconds]
Josh_2 has joined #lisp
damke has quit [Quit: quit]
fnodeuser has joined #lisp
fnodeuser has left #lisp [#lisp]
bend3r has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
<waynecolvin>
Ahhhh YOUR NAME IS PASCAL! sorry sorry sorry sorry!
damke has joined #lisp
<phoe>
waynecolvin: wtf
<waynecolvin>
wrong line, pascal joke. i'm just an idiot...
<jmercouris>
Is there something with the way I've set up my code?
<Xach>
jmercouris: it is working
<_death>
remove-if is not destructive
<jmercouris>
Ah shit, yes
<jmercouris>
Thank you
<Xach>
jmercouris: the list you get back doesn't have any document-modes in it, does it?
<jmercouris>
I keep forgetting that
<jmercouris>
_death: That is the problem
<jmercouris>
Xach: Yes, correct!
EvW has quit [Ping timeout: 250 seconds]
fikka has joined #lisp
Guest87309 has quit [Remote host closed the connection]
jfe has joined #lisp
Guest87309 has joined #lisp
<jmercouris>
What happened was I originally mistook NIL as "no matches" for remove-if, rather than the list was now empty
DeadTrickster has joined #lisp
DeadTrickster__ has quit [Ping timeout: 248 seconds]
igemnace has joined #lisp
terpri has joined #lisp
<lisp_guest>
does using a macro in COND's clauses work?
<beach>
lisp_guest: You can use a macro in every place that is evaluated normally.
<lisp_guest>
the key here being "normally" i guess?
<Bike>
you can't use a macro AS a clause, if that's what you mean.
<beach>
Drop the "normally" if you like.
<lisp_guest>
what i'm doing for example is (COND (macro ...) (macro ...))
<Bike>
yes, you can't do that.
<beach>
Won't work.
<lisp_guest>
i guess COND is taking those forms and treating them as code to evaluate, without expanding them?
<Bike>
no, it treats them as cond clauses.
<Bike>
(condition ...body...)
DeadTrickster has quit [Ping timeout: 248 seconds]
<lisp_guest>
right, then it proceedes to eval the first form, and bla bla
<Bike>
this is the non-normal evaluation beach alluded to.
<lisp_guest>
proceeds*
<lisp_guest>
yes, that's what i was thinking of
Josh_2 has quit [Remote host closed the connection]
<lisp_guest>
does a way around this exist? i'm just curious
<Bike>
what are you trying to do exactly?
<lisp_guest>
i knew you were going to ask that :D. i'm doing a simple rot-13 but it's not relevant. i'm just curious whether it's possible
<lisp_guest>
the problem i'm solving is solved already
<Bike>
well it depends on what you mean by possible.
<Bike>
you could have a macro that expands into cond with constructed clauses.
jmercouris has quit [Ping timeout: 258 seconds]
<Bike>
i don't know whether you think that counts.
DeadTrickster has joined #lisp
<lisp_guest>
yeah, not really
<Bike>
macros expand into code. cond clauses are not code.
<Bike>
simple
<lisp_guest>
hm, right
<beach>
Bike: The correct terminology here would be "form", as opposed to "code".
<Bike>
true
<lisp_guest>
hm, what about a version of cond that would first macroexpand the forms in its clauses?
<Bike>
you could do that, but you'd have ambiguous behavior.
<Bike>
say you have a macro named foo and a variable named foo, what does (mycond (foo ...) ...) do?
<Bike>
additionally, the macros would only be valid in this one context, so if they appeared somewhere else by mistake you'd get hard to understand errors.
<lisp_guest>
Bike: why exactly is that case ambiguous? isn't it always treated as function or a macro call in normal code?
<Bike>
not in cond, obviously.
<beach>
lisp_guest: Your macros would have to expand to something that is not a form.
<Bike>
(cond (foo ...) ...) conditionalizes on the value of the variable 'foo'.
<lisp_guest>
right
<lisp_guest>
beach: yeah, i was just thinking about that. essentially what i wanted was for this macro just to expand into a cond clause
<lisp_guest>
but i forgot that the code returned by macros is eval'd
<beach>
It wouldn't be if you macroexpand it yourself into a context where it is not evaluated.
<lisp_guest>
hm yeah i guess
<beach>
I was just agreeing with Bike that "the macros would only be valid in one context".
FreeBirdLjj has quit [Remote host closed the connection]
ult has left #lisp [#lisp]
<lisp_guest>
Bike: ah i see what you mean by ambiguous. i was thinking of MYCOND as something that would allow *only* macros for its clauses, but that it would indeed be limiting. if you allow both macros and "normal" clauses, then it's ambiguous
drdo has quit [Quit: ...]
<Bike>
would you also have macros expand only once? because they could expand into ((condition ...) ...) which can't be macroexpanded, or into (foo ...) which only maybe means a variable and maybe is another macro
<Bike>
well, in short, it sounds kind of confusing. and i still don't really understand how this would be used.
Josh_2 has joined #lisp
<lisp_guest>
yeah, i agree, it's a mess. it was just a mental exercise, is all.
<lisp_guest>
didn't think of coding this even
<lisp_guest>
i was just wondering why (1) my code failed and (2) would there by a way around it
<lisp_guest>
stretches the brain :-)
<Bike>
understandable.
drdo has joined #lisp
jfe has quit [Ping timeout: 240 seconds]
dieggsy has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 258 seconds]
Josh_2` has joined #lisp
Josh_2 has quit [Read error: Connection reset by peer]
LiamH has joined #lisp
jmercouris has joined #lisp
<jmercouris>
What's a way to find the class of a particular object (find--class) does not seem to do what I want
<phoe>
jmercouris: why?
Guest7354 is now known as kolb
<phoe>
I mean, what do you want, and what does FIND-CLASS give you?
<jmercouris>
Yes, find class seems to find a class given some name of it
<jmercouris>
What I want to do is given Object X, find out what the class is
<jmercouris>
beach: That is not where I am using class-of, I'm only using it in add-or-switch-to-mode
<shka>
this way buffer subclass can act as a factory for modes
<beach>
shka: The class is not known at compile time.
<jmercouris>
The reason being that I want someone to be able to Create an Instance of a mode and pass it to add-or-switch-to-mode which will then EITHER ADD the mode, or SWITCH TO AN EXISTING MODE OF SAME CLASS
<jmercouris>
I feel like the least interested community is the actual lisp community lol
<shka>
just keep it simple
<jmercouris>
Yeah I'll switch it to hash table
<shka>
if you want select mode by some name, select it by symbol
<shka>
jmercouris: i actually tested this browser
<shka>
so i am kinda interested :P
<jmercouris>
You should test it again, it's significantly improved!
<Bike>
so basically, you have a list of things, and you want to have a function that selects a node by class, and you use the actual class rather than anything it's an indirect instance of.
<jmercouris>
Bike: Correct
<Bike>
in particular, the things in the list are "modes", whatever those are
<Bike>
what if it has more than one mode of the same class? does it not matter what gets picked? or does that not happen?
<jmercouris>
Bike: Modes are objects of classes that inherit from Mode Class
<jmercouris>
Bike: That should never happen
jfb4 has quit [Ping timeout: 248 seconds]
<jmercouris>
There should only be one instance of a particular mode type for a given buffer
<jmercouris>
shka: Make sure to compile it though, the changes aren't available in the release binary
<Bike>
it's unusual to discriminate objects by their class like that, is all. the only time i've ever seen it is clos internals.
FreeBirdLjj has quit [Ping timeout: 255 seconds]
jfb4 has joined #lisp
<jmercouris>
Yeah, I don't imagine it comes up often
ak5 has joined #lisp
CrazyEddy has quit [Remote host closed the connection]
jfe has joined #lisp
<beach>
jmercouris: SELF is not a very good name for a parameter.
<beach>
jmercouris: It is better to use the name of the type of it.
<jmercouris>
beach: You mean like instead of (self buffer) (buffer buffer)?
<beach>
Yes.
<jmercouris>
I guess that would make it easier to read when specializing on multiple classes
<jmercouris>
is that the idea?
CrazyEddy has joined #lisp
FreeBirdLjj has joined #lisp
<beach>
That's part of it, yes. SELF suggests a single dispatch language where you are not allowed to use the same name for a type and a parameter.
<beach>
More basically, though, SELF is no better than X or some other meaningless name.
<jmercouris>
I think I'm finally deep enough into lisp where I can let go of self I guess
<jmercouris>
Ok, I'll try to do this for new code and slowly refactor it out of old things
<jmercouris>
Thank you for the suggestion
jfe has quit [Ping timeout: 248 seconds]
<jmercouris>
I'm afraid of what Lisp is doing to me mentally lol, maybe I won't be able to work with other languages again :D
zmt00 has quit [Ping timeout: 240 seconds]
<beach>
That's a very real risk. So if you don't want that to happen, you had better quit now, while there is still time.
<jmercouris>
I was writing python the other day and I started typing (print "something {}".format(some-variable)) which is of course a non-sensical mix of python and lisp
jfe has joined #lisp
<jmercouris>
Is this the rabbit hole matrix scene of my pedestrian life :D?
FreeBirdLjj has quit [Ping timeout: 240 seconds]
<Shinmera>
What annoys me most about working with other systems is typically not the syntax but the APIs. In Lisp I've so far had the "luxury" of just building everything myself.
<jmercouris>
Shinmera: Or even writing a macro on top of an API to use it in the way you wish
<Shinmera>
With anything else I always spend hours constantly googling documentation and how to do things.
<jmercouris>
Yeah, that is super annoying isn't it
<Shinmera>
And then get pissed because it turns out the designers didn't really design at all and you have to write some kinda shitty workaround.
<jmercouris>
and every project has their own distinct magical paradigm
<jmercouris>
consider Numpy and Pandas, completely break everything about python, get two of the most popular packages
<jmercouris>
s/get/yet
xor-xor has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
zmt00 has joined #lisp
parjanya has quit [Remote host closed the connection]
<shka>
oh
jfe has quit [Ping timeout: 260 seconds]
<shka>
Shinmera: nice to hear that i am not the only with this impression
CrazyEddy has quit [Remote host closed the connection]
<jmercouris>
beach: How serious are you? do you find yourself unable to work in other languages? Do you not frequently work in C?
attila_lendvai has quit [Quit: Leaving.]
<shka>
hehe
CrazyEddy has joined #lisp
FreeBirdLjj has joined #lisp
Kundry_Wag has joined #lisp
<shka>
jmercouris: after working with lisp for extended period of time with lisp you start to feel like jim carrey of programming
CrazyEddy has quit [Remote host closed the connection]
<phoe_>
It only mentions that its arguments should be sequences. Reading from glossary, "sequence n. 1. an ordered collection of elements 2. a vector or a list."
<phoe_>
And, "list n. 1. a chain of conses in which the car of each cons is an element of the list, and the cdr of each cons is either the next link in the chain or a terminating atom. See also proper list, dotted list, or circular list. 2. the type that is the union of null and cons."
<drdo>
_death: Right, but if you are using a circular list, you presumably want it to be an infinite list
<_death>
drdo: sure, and you can designate it as such without infinite regress
vlatkoB has quit [Remote host closed the connection]
SuperJen has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Guest87309 has quit [Ping timeout: 276 seconds]
<whoman>
infinite ======= circular
<whoman>
literally the same exact thing
nowhere_man has quit [Ping timeout: 268 seconds]
<whoman>
metaphorically
<whoman>
and physically and logically
fourier has joined #lisp
<_death>
infinite doesn't have to be circular..
Kundry_Wag_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 255 seconds]
<phoe_>
shka: vectors aren't circular, and this task explicitly deals with circular data structures.
nowhere_man has joined #lisp
<phoe_>
I mean, I could have used AREF MOD, but oh well.
<aeth>
There are many ways to get a "circular" data structure without literal circular lists.
<aeth>
I personally prefer mod and arrays
<_death>
phoe: the access pattern hinted at by the problem suggests lists would not be efficient
jmercouris has joined #lisp
<aeth>
A struct as circular buffer (array, start, end, emptyp) with two additional accessors (after enqueue and dequeue), for arbitrary middle access (but not deletion from the middle) would probably fit a lot of circular needs.
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<aeth>
It wouldn't work well for arbitrary middle insertion/deletion (but even there there's probably a list scheme that doesn't require actual circularity)
<phoe_>
_death: yes, I get it. Computing this hash is instantaneous enough on my laptop though.
<_death>
phoe: sure, I'm not criticizing your solution :)
xor-xor has quit [Ping timeout: 240 seconds]
<aeth>
looks like advent of code only tracks how fast you get a solution, not how fast it runs
<aeth>
writing an efficient solution might actually be a bad idea in that case.
<Fade>
Xach: I'm noticing a build failure in buildapp
<phoe_>
reduce will work on lists of arbitrary length where apply will only works on lists shorter than CALL-ARGUMENTS-LIMIT
<lisp_guest>
phoe_: yup, great, thanks. quite surprised to find that CALL-ARGMENTS-LIMIT is 4611686018427387903 :D
<aeth>
reduce will work on all sequences. apply can work in strange ways, such as taking in a plist and making those keyword arguments when applying. It doesn't just work on &rest functions.
pierpa has joined #lisp
<phoe_>
lisp_guest: depends on the implementation, but the minimum for portable code is 50.
<lisp_guest>
yeah, ofc
<phoe_>
So you might theoretically get a surprise when you are working on a 60-element list.
<aeth>
phoe_: Theoretically, yes, but theoretically even long docstrings cause issues. There's a de facto minimum and it's usually much higher, with clisp as the lowest, when you go look for de facto minimums. It's no exception here, either. clisp is by far the lowest, at 4096. ecl and ccl are 65536 and sbcl is very, very large.
karswell has quit [Read error: Connection reset by peer]
<aeth>
4096 is still low enough that it might cause problems with portable code, though.
<phoe_>
aeth: 4096, you mean, maximum array length?
<aeth>
call-arguments-limit
<phoe_>
oh, right.
<phoe_>
why do you mention docstrings then?
astronavt has quit [Remote host closed the connection]
EvW has joined #lisp
astronavt has joined #lisp
<aeth>
phoe_: iirc, arrays are non-portable after a length of 1024
<aeth>
Even though they're much higher in all modern implementations
<aeth>
49 in CLISP, 62 in ECL, 61 in CCL, 63 in SBCL
<aeth>
Portably, the minimum is 16
<aeth>
I should put together a document for all of the minimums given in the spec, but then I'd have to install a ton of additional implementations, including 32 bit versions of every implementation
SuperJen has quit [Remote host closed the connection]
<_death>
just yesterday sbcl exhausted heap when compiling my custom core.. so had to tweak dynamic-space-size.. there are more limits than standard limits ;)
SuperJen has joined #lisp
<phoe_>
the mighty non-standard limits
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
astronav_ has quit [Remote host closed the connection]
Jen has joined #lisp
Jen is now known as Guest30181
fikka has joined #lisp
random-nick has quit [Remote host closed the connection]
SuperJen has quit [Ping timeout: 260 seconds]
jfb4 has quit [Ping timeout: 260 seconds]
jfb4 has joined #lisp
astronavt has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
astronavt has quit [Remote host closed the connection]
astronavt has joined #lisp
<jmercouris>
Why do people use CLISP? what are some advantages over sbcl?
astronavt has quit [Remote host closed the connection]
<aeth>
People use CLISP because it was the most recommended implementation 10 years ago, and lots of people read things from 10 years ago.
<aeth>
At least, every time it comes up, that seems to be it.
<jmercouris>
huh interessant
<aeth>
It also (1) has a REPL with readline in the terminal without any hacking so it's approachable to people who aren't using emacs+slime and (2) has "C" in the name.
<phoe_>
3) people confuse Common Lisp and CLISP.
<jmercouris>
Doesn't CCL also have a repl?
<jmercouris>
I thought most all of them had repls
<phoe_>
ALL implementations have repls.
<aeth>
jmercouris: readline repl, though, so you can C-a, C-e, etc.
<jmercouris>
is it the fact that they don't support prev-next with arrows/backspace
<phoe_>
but CLISP includes readline bindings, so it has a pleasant REPL where arrow keys work and such.
<jmercouris>
etc?
<jmercouris>
It's not that hard to make readline work, why is this such a big selling point?
<phoe_>
4) it is an interpreter and has good support for unix commands, so can be fast and useful for scripting.
<phoe_>
jmercouris: OOBE
<jmercouris>
why not make it work for other implementations? licensing issues or?
<phoe_>
yes.
<jmercouris>
phoe_: What is OOBE?
<phoe_>
readline is GPLv2.
<phoe_>
out of box experience
<jmercouris>
Speaking of GPL v2
<phoe_>
CLISP has the nice repl out of the box, for other implementations you need to use rlwrap or such.
<jmercouris>
I was recently convinced to move my app from BSD to GPL
<jmercouris>
is there a good GPL comparison?
<jmercouris>
other than what's available by the FSF?
SuperJen has joined #lisp
<phoe_>
googling for `gpl comparison` gives me a few sane links
<aeth>
For an alternative view to the FSF's, you may want to look into what defenders of the GPLv2 (e.g. Linus) said back during the GPLv3 release controversy.
<aeth>
New GPLv2 projects are released as "GPLv2 or later" so they're not explicitly GPLv3-incompatible, though.
Guest30181 has quit [Ping timeout: 240 seconds]
<jmercouris>
Yeah, Linus is actually the reason I'm very carefully considering which license to release under
<jmercouris>
if I have contributors to my project under License X, can I change the License at a latter time, or must I have all rights to all submitted work like the FSF does?
<aeth>
The third non-FSF approach to the GPL is the commercial approach where vendors require copyright assignment and sell an identical proprietary version of their library. I don't think there's an ideological view behind this, it's just a business model.
<jmercouris>
I'm just worried I'm going to make a bad license decision and it will be a pain later
<jmercouris>
I also am kind of taking the Shinmeraesque view point a little bit, that likely if someone wants to they can just steal my code regardless of the license, but I still feel like I should set the "correct" license
fikka has joined #lisp
<jmercouris>
aeth: So wait, you are telling me they SELL their GPL software? why wouldn't someone just download it and use it?
<aeth>
jmercouris: You can go from a GPL-compatible license to the GPL. It's trickier going the other direction, especially since no one wants to do copyright assignment because of e.g. what Oracle did to Sun's projects.
<phoe_>
dual licensing, yes.
astronavt has joined #lisp
<phoe_>
jmercouris: they have the copyright, they can release two versions of the code with different licenses.
<jmercouris>
I wish I could dual license with BSD and have a clause that says you cannot use it for commercial purposes or something
<aeth>
"GPLv2 or later" or "GPLv3 or later" isn't a technicality, it's a necessity if you want to change licenses later on.
<aeth>
But only along that GPL line
<phoe_>
one is GPL and you don't need to pay for it, the other is proprietary and you need to pay fro it.
<phoe_>
jmercouris: feel free to, there are a few commonly used non-commercial licenses around.
<phoe_>
as long as you hold the copyright, you decide how you license your code.
* phoe_
afk
<aeth>
jmercouris: The GPL doesn't stop people from using it for commercial purposes (e.g. Red Hat or Oracle or Canonical or even Google) and there's a network loophole to the GPL that the AGPL attempts to fix (i.e. if you make your Foo library I can make a commercial Foo as a Service website and since I'm not distributing binaries of your Foo, it's allowed)
<aeth>
In fact, forbidding commercial use (e.g. half of the Creative Commons licenses) is explicitly not allowed under the open source definition.
<aeth>
The idea of the GPL is to just make it unattractive for commerical use, not forbid it.
<phoe_>
>The idea of the GPL is to just make it unattractive for commerical use
<phoe_>
Wrong, the idea of GPL is to make sure the users of the software have the four freedoms defined as essential by the FSF.
<aeth>
phoe_: well, the idea of using the GPL if you don't like commercial users
<phoe_>
...but that's already becoming #lispcafe material I think.
JenElizabeth has joined #lisp
random-nick has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
SuperJen has quit [Ping timeout: 248 seconds]
whoman has quit [Ping timeout: 240 seconds]
Kundry_Wag_ has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
shenghi has quit [Remote host closed the connection]
shenghi has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 248 seconds]
jmercouris has quit [Ping timeout: 255 seconds]
yeticry has joined #lisp
random-nick has quit [Remote host closed the connection]
kokonaisluku has joined #lisp
jfe has quit [Ping timeout: 250 seconds]
aphprentice has joined #lisp
yeticry has quit [Ping timeout: 255 seconds]
jmercouris has joined #lisp
<jmercouris>
aeth: You are correct, certainly it does not prohibit that use, but I am developing an application, not a library, so it'd be hard to spin it into something else
Kundry_Wag has quit [Read error: Connection reset by peer]
shenghi has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
shenghi has joined #lisp
jfe has joined #lisp
shenghi has quit [Ping timeout: 240 seconds]
shenghi has joined #lisp
pseudonymous has joined #lisp
applePrincess has quit [Read error: Connection reset by peer]
whoman has joined #lisp
whoman has quit [Remote host closed the connection]
<aeth>
jmercouris: I'm not sure what the difference between an application and a library really is, especially in a language like Lisp.
<jmercouris>
I always think I have my mind made up, but then a conversation like this makes me start all over again mentally
<Josh_2>
well not gonna find many libraries that are executables
<Josh_2>
the saved lisp images that is
lyndon has joined #lisp
<aeth>
Josh_2: An application is (probably too simply) a library with an entry point. In Lisp, you're free to ignore the entry point and directly access things, even private things. You could probably even do this on a saved lisp image that isn't tree shaken.
<aeth>
An application would have to be pretty fragile with globals everywhere, etc., to have nothing useful to someone else.
<Josh_2>
Well that's neat
<aeth>
You can just do (foo-package::some-private-function 42 :really t)
<aeth>
You shouldn't but you can.
<fouric>
Ober: just salute, i thought
<fouric>
i was under the impression that o/ was a high-five and o7 a salute
lyndon has quit [Client Quit]
lyndon has joined #lisp
jmercouris has quit [Remote host closed the connection]
lyndon is now known as whoman
jmercouris has joined #lisp
whoman has quit [Remote host closed the connection]
whoman has joined #lisp
pillton has joined #lisp
mishoo has quit [Ping timeout: 258 seconds]
yeticry has joined #lisp
<pillton>
Xach: Thanks for adding my projects to quicklisp. Sorry for the hiccup too.
sz0 has quit [Quit: Connection closed for inactivity]
nowhere_man has quit [Ping timeout: 255 seconds]
jfe has quit [Ping timeout: 240 seconds]
python476 has quit [Quit: focus]
damke has joined #lisp
emacsoma` has quit [Ping timeout: 248 seconds]
alexmlw has quit [Quit: alexmlw]
damke_ has quit [Ping timeout: 252 seconds]
jfe has joined #lisp
nowhere_man has joined #lisp
yeticry has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
jack_rabbit has quit [Read error: Connection reset by peer]
raphaelss has quit [Ping timeout: 276 seconds]
kokonaisluku has quit [Quit: ChatZilla 0.9.93 [Firefox 52.5.1/20171205141522]]
raphaelss has joined #lisp
king_idiot has joined #lisp
Josh_2 has quit [Remote host closed the connection]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
jack_rabbit has joined #lisp
pseudonymous has quit [Ping timeout: 268 seconds]
zagura is now known as Teleskopowicz
Rawriful has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Teleskopowicz is now known as zagura
Kundry_Wag has joined #lisp
Rawriful has quit [Quit: WeeChat 1.4]
nowhere_man has quit [Remote host closed the connection]