<Bike>
flet is lexical, not dynamic, so the new binding won't be in effect in some other function you call
<Bike>
there's no way to dynamically bind functions, but you can do something like (funcall *check-menu-complete* ...)
<Bike>
assuming you control check-menu-complete to begin with, but it sounds like you don't
<Xach>
welll
<Xach>
you control it if you like. write a new function that uses a special or something.
rumbler31 has quit [Ping timeout: 246 seconds]
akoana has left #lisp ["Leaving"]
lotuseater has quit [Ping timeout: 245 seconds]
gitgood has quit [Remote host closed the connection]
orivej_ has quit [Ping timeout: 268 seconds]
quazimodo has quit [Ping timeout: 252 seconds]
sebboh has quit [Ping timeout: 260 seconds]
quazimodo has joined #lisp
nij has joined #lisp
tempest_nox has joined #lisp
<nij>
Hello, is there an expressive way to access to a (deep slot) or an instance X by syntax like (get X (a b c)), in which I'm looking (the slot c of (the slot b of (the slot a of X)))?
<nij>
I find this more satisfactory than expression like (b-c (a-b (X-a X))).
<nij>
Of course, I'd also hope to (setf (get X (a b c)) 172).
sebboh has joined #lisp
anticrisis has joined #lisp
Codaraxis__ has joined #lisp
Stanley00 has joined #lisp
<no-defun-allowed>
You could use an "arrow" macro, for something like (-> X a b c)
Codaraxis_ has quit [Ping timeout: 246 seconds]
curtosis has joined #lisp
slyrus has quit [Quit: Leaving]
rumbler31 has joined #lisp
curtosis is now known as curtosis[away]
Nilby has joined #lisp
wxie has joined #lisp
<nij>
But with that I still need to do (-> X (X-a) (a-b) (b-c))
hendursa1 has quit [Quit: hendursa1]
<nij>
Hmm.. looks a lot nicer.
<nij>
However, usually the name is much longer.
hendursaga has joined #lisp
<nij>
For example, I have (dyn-float-group-dyn-order group) now.
<nij>
where dyn-float-group is X, and dyn-order is a.
<nij>
Without an accessor with "structure", I have to keep track of how "dyn-float-group-dyn-order" breaks down.
<nij>
With "structure", I can say (get (dyn-float-group dyn-order) group).
tainguyen has quit [Quit: Connection closed]
curtosis[away] has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
pjb has quit [Ping timeout: 248 seconds]
sabra has quit [Quit: Konversation terminated!]
<nij>
-------
<nij>
I wonder why the accessor `dyno` isn't SETF-able in a LET expression .. https://bpa.st/2QCA
<nij>
In the code, I figured a work-around.. but I'd rather like `dyno` to be SETF-able..
frost-lab has joined #lisp
<no-defun-allowed>
That is not an "accessor", that is a variable.
<no-defun-allowed>
You could use SYMBOL-MACROLET instead of LET to use DYNO to name that place though.
<nij>
Oh! I see :-D.
<nij>
Thank you!
karlosz has quit [Quit: karlosz]
prxq_ has joined #lisp
ramHero has quit [Ping timeout: 240 seconds]
prxq has quit [Ping timeout: 246 seconds]
Stanley|00 has joined #lisp
possible has joined #lisp
Stanley00 has quit [Ping timeout: 252 seconds]
Stanley|00 has quit [Ping timeout: 252 seconds]
Stanley00 has joined #lisp
possible has quit [Quit: Leaving]
asarch has joined #lisp
cobax has joined #lisp
dsrt^ has joined #lisp
cobax has quit [Ping timeout: 240 seconds]
Stanley00 has quit [Read error: Connection reset by peer]
kini has quit [Remote host closed the connection]
kini has joined #lisp
mmontone has quit [Ping timeout: 240 seconds]
Stanley00 has joined #lisp
sp41 has quit [Ping timeout: 240 seconds]
a0 has joined #lisp
mason has left #lisp [#lisp]
mindCrime has quit [Ping timeout: 265 seconds]
<beach>
Good morning everyone!
Sheilong has quit []
mindCrime has joined #lisp
mrchampion has quit [Ping timeout: 252 seconds]
mrchampion has joined #lisp
semz has quit [Ping timeout: 250 seconds]
DHARMAKAYA has joined #lisp
<asarch>
Good morning!
<asarch>
Today is NetBSD's birthday: 4/19/1993, 28th anniversary!!!
<asarch>
Any NetBSD user?
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
waleee-cl has quit [Quit: Connection closed for inactivity]
<beach>
Do they use that silly date format where you live as well? If so, I am sorry to hear that.
<Nilby>
I dislike date formats so much, I've started using 3827879332 in text documents.
<asarch>
Well, that format date is from vintage
<no-defun-allowed>
My girlfriend would probably use ISO8601. At least that way lexicographic sorting works correctly.
<beach>
I think that's the best format around.
<beach>
Where I grew up, it was introduced more than half a century ago.
<beach>
And I believe there is some kind of consensus to use it in FLOSS work around the world.
<MrtnDk[m]>
What is 3827879332?
<no-defun-allowed>
Too large to be a Unix timestamp (for now), but it could be a CL universal time.
<beach>
It is.
<beach>
2021-04-20 05:48:52 or something like that.
<beach>
Speaking of which, "universal" seems a bit pretentious. I mean, it seems to be tied to a very tiny piece of the universe after all.
<contrapunctus>
beach: nice ^ xD
<p_l>
asarch: heh, 1993
<no-defun-allowed>
"Space is a very long time!"
* p_l
somewhat recently had an issue involving year around 1993, and various forks of BSD4.x
<asarch>
Yeah!
<Nilby>
I have a plan for a more universal time system, but it requires agreement on the age of the universe and gravition physics.
<p_l>
a BSD libc issue that stumped me playing with CADR emulator
<p_l>
Nilby: it would also require special reference frame, I believe
<MrtnDk[m]>
beach Yeah, global would be more accurate, it seems.
<contrapunctus>
Or "terran" 😏
<MrtnDk[m]>
Nilby Like a universal epoch?
<Nilby>
Yes. The refreence would be part of the date.
<Nilby>
MrtnDk[m]: Yes.
* p_l
notes that people somehow miss the "C" part in UTC
shka_ has joined #lisp
<no-defun-allowed>
As I have taken a break from concurrent and distributed programming, I have to say that I have not seen a clock in years* while reasoning about time and I don't miss them.
xkapastel has quit [Quit: Connection closed for inactivity]
<no-defun-allowed>
*approximately 0 years
<MrtnDk[m]>
p_I: Coordinated?
Kundry_Wag has quit [Remote host closed the connection]
<p_l>
yep
<p_l>
and it's only used for earth-centric date keeping, and even there it's not the only global time kept, because UTC makes sense for *most*, but not *all*, uses on earth
<Nilby>
Also an offset for scale, since the fundamental unit would be Plank units.
<p_l>
hell, some of the crucial clocks in use on earth are based on finite fields and have relatively short periods, thus being impossible to be useful as absolute date
<MrtnDk[m]>
Nilby: How many Plank units for a second? Approximately ...
<Nilby>
10e-34
<Nilby>
or something?
<MrtnDk[m]>
Wow, that answer was fast.
<no-defun-allowed>
Honestly, you're asking too much. Not only do you want a total ordering on events, you want a clock too? Kids these days...
<Nilby>
I had a lot of Plank units to space.
<Nilby>
s/space/spare/
<MrtnDk[m]>
p_l Finite fields?
<p_l>
(gps clocks operate on what can be considered finite field where the set is the whole period of a specific pseudorandom function with predefined seed)
aartaka has joined #lisp
<p_l>
MrtnDk[m]: essentially GPS clock value is a pseudorandom number, and you get the time by finding where in the sequence of possible numbers it is
<Nilby>
p_l: I don't know much about GPS, but I would guess the units are bigger than I'm thinking of.
<MrtnDk[m]>
Nilby If it follows the laws of physics, which seems to be a reasonable assumption.
<p_l>
there are no duplicates on the numbers, and you can get the time since the start of the period by (position clock-value +gps-clock-sequence+)
aartaka_d has quit [Ping timeout: 240 seconds]
<MrtnDk[m]>
p_l Hopefully there is a library for that. 😁
<p_l>
Nilby: because planck time by itself isn't useful in macroscale (and I suspect that using as basis of measurement might invoke certain nasal demons)
<Nilby>
MrtnDk[m]: I think a true universal time system would not actually require physica, just math. But there would have to be agreed upon cosmological reference points.
<p_l>
MrtnDk[m]: well duh, that's usually handled by the GPS receiver for you :)
<p_l>
MrtnDk[m]: translating that into time data from multiple sats is how it figures the position, after all :)
<Nilby>
I looks like GPS only goes down to 30cm?
<p_l>
in impossible to satisfy conditions, maybe
<p_l>
since disablement of SA scrambling I can see depending on CEP of 15m or so, but just in case I continue to treat GPS as having 100m error
Bike has quit [Quit: Lost terminal]
<Nilby>
p_l: The "timezone" in my universal time would be on "useful" offset constant from Plank units. What useful is, is quite dependant on what scale of creature you are. But we already use macroscale units based on silly wobbly Earth seconds.
<Nilby>
How many clocks seconds go to 61?
<p_l>
well, the base underlying clock doesn't use any of that babylonian numeric
<p_l>
and second is afaik at worst problematic to compare without taking local spacetime curvature in compared locations (dates based on locally counting seconds might require history of the curvature over time between known synchronizations)
<Nilby>
Right. True time actually requires something of a hash code of space and time, but I think there is a real integer number of Plank units since the Universe was size 1.
<Nilby>
And the curvature is the nonuniformity of that.
<Nilby>
Which makes sense because it's tree-like.
mindCrime has quit [Ping timeout: 265 seconds]
<Nilby>
Sorry for off-topic. But at least I think Lisp is well positioned to handle the future time system.
<MrtnDk[m]>
I wonder why the big bang seems to have pushed the universe mostly in the time direction. I guess it is matter of perspective?
skapata has quit [Remote host closed the connection]
<Nilby>
I think there's nothing to push. The universe (size/shape/age) is the time direction.
<moon-child>
MrtnDk[m]: what makes you say that? Expansion is rampant!
<moon-child>
near as we can tell, expansion of space is superlinear wrt time
<Nilby>
Yes. I think expansiion and time is equivalent. But our measurement, or thinking about "empty" space isn't quite correct.
mindCrime has joined #lisp
Kundry_Wag has joined #lisp
<Nilby>
The much more than superlinearity is because all of history has to fit.
nitrix has quit [Quit: Genius is one percent inspiration and ninety-nine percent perspiration]
hypercube has quit [Ping timeout: 252 seconds]
nitrix has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
mindCrime has quit [Ping timeout: 240 seconds]
Codaraxis_ has joined #lisp
aeth has quit [Ping timeout: 260 seconds]
noobineer1 has joined #lisp
cpape has quit [Read error: Connection reset by peer]
cpape has joined #lisp
xsperry has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
<MrtnDk[m]>
Do you think measuring gravitational waves will help us change our understanding of "empty" space?
Codaraxis__ has quit [Ping timeout: 265 seconds]
noobineer has quit [Ping timeout: 265 seconds]
<Nilby>
I'm not sure. But I think really understanding causality will.
<Nilby>
One problem with gravity wave communication is the disruptiveness of compression/encryption. Oh and affording the equipment.
<p_l>
MrtnDk[m]: btw, your comment about "hopefully there is a library" reminded me of how some implementation outright skirted export controls by making a dumb if against easily modified variable :D
srhm has quit [Quit: Konversation terminated!]
<no-defun-allowed>
Reminds me further of that digital TV broadcasting system for which recording is prevented using an easily-missable "don't record" bit.
<p_l>
that's common in AV world
<MrtnDk[m]>
*no-defun-allowed* That seems like a good way to implement it. If it's illegal to record, the law should regulate that, not the hardware.
<p_l>
MrtnDk[m]: thing is, even with the bit set, the law might say that you're allowed to record
<MrtnDk[m]>
Nilby Causality is a tough one. It seems to be embedded in the way we see most things.
<p_l>
and /somehow/ the weasel wording used to give DRM schemes legal protection sometimes fail if the DRM is too simple
daphnis has joined #lisp
<MrtnDk[m]>
p_l and vice versa. The law may say you're not allowed to copy, even if the bit is not set. Point being, you should follow the law, and only use the bit as guidance.
<p_l>
I dunno if they changed that later, because my layman mind immediately noticed issue in law declaring that "circumventing *successful* DRM is illegal"
<p_l>
technically the word could have been translated as effective, but the word has wildly preferred meaning of "successful" XD
<Nilby>
MrtnDk[m]: Causality is equivalent to return values of a function, so it shouldn't be that hard. It's just like practical programming, practical causality gets very complicated, very quickly.
asarch has quit [Remote host closed the connection]
bitmapper has quit [Quit: Connection closed for inactivity]
asarch has joined #lisp
a0 has quit [Ping timeout: 240 seconds]
gaqwas has joined #lisp
gaqwas has joined #lisp
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
imode has quit [Ping timeout: 268 seconds]
Sauvin has joined #lisp
abrantesasf has quit [Remote host closed the connection]
tempest_nox has quit [Remote host closed the connection]
asarch has quit [Quit: Leaving]
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
kopiyka has quit [Remote host closed the connection]
kopiyka has joined #lisp
orivej has joined #lisp
imode has joined #lisp
gaqwas has quit [Ping timeout: 240 seconds]
actuallybatman has quit [Quit: leaving]
ramHero has joined #lisp
xsperry has joined #lisp
imode has quit [Ping timeout: 260 seconds]
Elzington has joined #lisp
Krystof has joined #lisp
karlosz has joined #lisp
vegansbane6963 has quit [Ping timeout: 240 seconds]
klltkr has joined #lisp
hiroaki_ has joined #lisp
nij has quit [Remote host closed the connection]
OlCe has joined #lisp
nij has joined #lisp
<nij>
Hello #lisp. I wonder if I can specify the class of multiple arguments in defmethod -
<beach>
Yes.
<nij>
Something like (defmethod greet ((foo person) (line sentence))..
<beach>
It's called "multiple dispatch"
<nij>
Hmmm.. weird. It doesn't work as expected.
<beach>
You need to be more specific.
<nij>
Yes.. I'm trying to extend some package.. so when it doesn't work it might be other problems fault.
<nij>
How about this.
<nij>
If firefighter is a subclass of person, and I have a method for both firefighter and person.
<nij>
If i apply the method on an instance of firefighter, will both methods be evaluated?
<beach>
HOLY SMOKE! Let's try some terminology here.
<beach>
1. Packages can not be extended, other than by adding symbols to them I guess.
<beach>
Perhaps you mean a system?
<nij>
OHHHHH again yes system..
<nij>
sorry for that
<beach>
2. You don't "apply methods", you "call generic functions".
<nij>
Ok. So I call that generic function on an instance of firefighter.
<beach>
3. Methods are not "evaluated". They are "called" or "invoked".
surabax has joined #lisp
<nij>
Will both methods be called?
<beach>
Then only the most specific method will be called.
<nij>
beach: I get your "Holly Smoke" xD
<beach>
Unless you have a method combination that invokes them all, like LIST or PROGN.
karlosz has quit [Quit: karlosz]
<beach>
If you want to invoke the less specific one, with the standard method combination, you need to call CALL-NEXT-METHOD.
<beach>
If, in your method specialized to FIREFIGHTER you invoke (CALL-NEXT-METHOD), then the method specialized to PERSON will be invoked.
<nij>
So it will apply to the most specific once by default. Sure.
<beach>
If you want a generic function for which you want every primary applicable method to be called, then use a different method combination, like PROGN.
<nij>
Harder - say the generic function has two variables
<beach>
4. Generic functions don't have "variables". They usually have "parameters".
<nij>
:-( note taken
<nij>
Say the generic function has two parameters, both are of class person or firefighter.
<nij>
So there are four situations now.
<nij>
(* 2 2 ) ; => 4
ljavorsk has joined #lisp
<nij>
But suppose that the (and only the) case (firefighter, firefighter) hasn't been implemented.
<nij>
What would happen if I apply the generic function on (x, y), where both x and y are instances of firefighter?
<nij>
Will Lisp be smart enough to call the next specified method?
<nij>
Cuz technically speaking x and y are also instances of person.. so we cannot say it hasn't been implemented for them.
<nij>
I hope that makes sense..
<beach>
You said that only one method exists. That's what it means to say "only the case firefighter and firefighter has been implemented."
<nij>
nono.. I said
anticrisis has quit [Read error: Connection reset by peer]
<nij>
only and only the case of (firefighter, firefighter) has NOT been implemented.
<beach>
Oh, sorry.
<nij>
The other three cases, namely (person, person), (person, ff), (ff, person), are all implemented.
<nij>
I can generalize this question to N parameters..
<nij>
how would CLOS decide?
<beach>
A method is applicable if it is given a superclass of the class it specializes to. So a method that specializes to PERSON is applicable to a FIREFIGHTER. That's the same in every object-oriented programming language.
<nij>
Yes, but now CLOS needs to decide whether it should call the method for (person, ff) or the method for (ff, person).
<nij>
Both methods are equally specific in this context.
<beach>
The specificity order between methods is clearly defined in the Common Lisp HyperSpec.
<no-defun-allowed>
Then the argument precedence order is used, which defaults to choosing the most specific method for the first argument, then second, then so on.
<beach>
nij: What no-defun-allowed said.
<no-defun-allowed>
So it would choose the method specialized on (firefighter person).
<nij>
no-defun-allowed: Oh :)
klltkr has quit [Ping timeout: 265 seconds]
<nij>
Thanks beach no-defun-allowed! Lemme get back to my project then. I think I understand. The problems must have come from another place.
CrashTestDummy2 has joined #lisp
<beach>
How does the problem manifest itself?
<beach>
A common mistake is to forget the package prefix of the name of the generic function given in the DEFMETHOD form, which results in an unrelated method being created. To check that, you can use the inspector to inspect the generic function and check that it has all the methods you expect.
<nij>
Hmm.. I have (defmethod ((a x) (b y)) ..)
CrashTestDummy has quit [Ping timeout: 252 seconds]
<nij>
Which should work as I called on (a,b). But it didn't.
<beach>
Then you need to supply a name of a generic function too.
<nij>
However, by taking y away.. it works.
<nij>
oh no no I do have a name.. hmm hard to explain.
<beach>
The parameter comes before the class name.
<nij>
(defmethod f ((a x) (b y)) ...) ;; doesn't work
<beach>
(defmethod <name> ((x a) (y b)) ...) if A and B are classes.
<nij>
(defmethod f ((a x) b ) ...) ;; works
<beach>
You really have classes named x and y and parameters named a and b?
<beach>
That's very unusual.
<nij>
No. I'm trying to give an easier version.
<beach>
Also "doesn't work" is not enough information.
<nij>
Oh! I should just call that in a repl and see what happens.
<nij>
Lemme give it a try. At least I know how defmethod works. I'm sure it's some other problem related to the infrastructure of the system.
<Nilby>
I can understand learn by reading, learn by doing, learn by listening, even learn by the Socratic method, but I really don't understand learn by long tedious online chat that could have been answered by 1 line of code.
<beach>
Nilby: I am like you. But I often observe this "learning technique", so it must be common.
<Nilby>
I'm frequently very impressed by beach's diligent didactic patience
<Nilby>
It must be, seeing how popular it seems.
<beach>
Thanks! My patience depends on my mood that day.
zaquest has quit [Quit: Leaving]
ljavorsk has quit [Remote host closed the connection]
<nij>
Thanks for your patience :)
<nij>
Nilby: the problem is tricky because when you haven't learned it, you wouldn't have known which line of code you're looking at.
pve has joined #lisp
<nij>
It's an excuse I know. But it's also why it's common.
<nij>
Especially you are dealing with another problem, in which the quesiton is just a subsubsubproblem.
<Nilby>
nij: I'm also impressed by your engetic curiosity and persistence.
<beach>
Well, personally, I don't think I would have attempted a DEFMETHOD form without reading Keene's book and the PCL chapters on CLOS. Probably also the relevant Common Lisp HyperSpec pages.
<nij>
You folks must have been more energetic and curious than I am... really admire your approach.
ljavorsk has joined #lisp
<nij>
I'm just a lazy folk who wants to get an answer without reading thousands of lines.
<nij>
(to find that particular line of code)
<beach>
Nilby: Part of the reason for my relative patience with nij, is that nij seems to be making progress, and seems to want to follow advice, which may result in some net contributions to the community one day.
klltkr has joined #lisp
vegansbane6963 has joined #lisp
<nij>
beach: I do hope that !
<beach>
Nilby: Some people seeking advice here are not like that at all.
zaquest has joined #lisp
<Nilby>
beach: That very good of you. We do need more of that.
<beach>
nij: My advice for you is to get used to reading documentation more. It really helps with the understanding of the language, and of programming in general.
hendursa1 has joined #lisp
<nij>
Is it just for me, or CLHS is some thing that really takes time?
<nij>
It's not something that I could understand by reading the first 3~5 times.
<beach>
nij: It takes time because it is not meant for the application programmer.
<nij>
I also suspect that I understand a piece of it just because I have had experience on that part already.
<beach>
It is a document meant for people creating Common Lisp systems.
<nij>
Yeah.
<beach>
But PCL and Keene's book are not like that.
<nij>
Well, what I mean is that though CLHS is thorough and complete, one cannot get much from it without experiencing the repl.
hendursaga has quit [Ping timeout: 240 seconds]
OlCe has quit [Ping timeout: 240 seconds]
<nij>
You think it's more proper to read two books before starting to use CLOS?
<nij>
Having to read hundreds or thousands of technical papers I find that impractical..
<nij>
I apply that mindset on learning lisp too.. maybe what I have is not a good approach.
<nij>
My way: do + experience => encounter specific quesiton => locate answer in the ocean of answers => apply
<nij>
the third step is the trickest.. it really depends on the community and their patience
<nij>
When there's not enough channel for communication, sure, I will read two books to get started with CLOS.
<nij>
But now everything is online.. and if I could get some advice here, I'd first try.
<nij>
I thought that's the point of #lisp. Maybe I'm exploiting too much. I hope that's not the case..
<Nilby>
I think people usually like to answer questions. And frequently simple questions create insteresting discussion.
nij has quit [Remote host closed the connection]
<beach>
minion: memo for nij: That is not quite the point of #lisp. And #clschool was created for that reason. It is just that #lisp participants are tolerant with such questions; especially when things are otherwise quiet.
<minion>
Remembered. I'll tell nij when he/she/it next speaks.
OlCe has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
nij has joined #lisp
amb007 has joined #lisp
<nij>
I saw the log. Sorry my wm crashed.
<minion>
nij, memo from beach: That is not quite the point of #lisp. And #clschool was created for that reason. It is just that #lisp participants are tolerant with such questions; especially when things are otherwise quiet.
<nij>
Hm. What's the point of #lisp, then?
<beach>
One purpose of it is to discuss how to implement various Common Lisp constructs efficiently. Other purposes include libraries to create, applications to write, how to design protocols, how to organize a library or an application, etc.
<beach>
Those would be discussions between people who already know a large part of the language.
<beach>
Some people discuss ways to make Common Lisp more widely used.
ebrasca has joined #lisp
<nij>
I see. It's more about moving the community forward.
<beach>
That sounds like a good summary.
Stanley00 has quit []
<Nilby>
I just like to make Lisp jokes, and get inspiration for my work from the super smart people.
<nij>
That's also helpful for the community. We need more jokes -
<Nilby>
e.g.: Q: How many CL experts does it take to answer a question?
<Nilby>
A: most-posistive-bignum
<beach>
Heh, nice!
* Odin-
is unconvinced.
<Odin->
That's a finite number by definition, isn't it? :)
<nij>
CL-USER> most-positive-bignum
<nij>
; Debugger entered on #<UNBOUND-VARIABLE MOST-POSITIVE-BIGNUM {100748F653}>
<no-defun-allowed>
Odin-: I suppose you use the "I wrote a Lisp interpreter in C!!!1!" technique (name my own) and heap-allocate fixnums if tagging wouldn't work.
nij has quit [Remote host closed the connection]
luckless_ has quit [Remote host closed the connection]
<Nilby>
Even worse, my bit-rotted brain must have stolen the joke from jwz, who gave it much more thorough treatment
OlCe has quit [Ping timeout: 265 seconds]
luckless_ has joined #lisp
<Odin->
no-defun-allowed: Wouldn't the switch between immediate and heap allocated be the 'reasonable' place to put the switch between fixnum and bignum, though?
<no-defun-allowed>
It would, yes.
orivej has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
There is another limit still: array-total-size-limit must be greater or equal to 1024, but still a FIXNUM. But no one has a 12-bit machine for that to be a problem.
orivej has joined #lisp
Lord_Nightmare has joined #lisp
<Odin->
Pointers tend to be at least 16 bits in octet-oriented systems, so, yeah.
<no-defun-allowed>
I think there was one Microchip microcontroller with 12-bit words, but getting CL on that would pose many more problems.
* Odin-
is messing around with uLisp, a (so far) interpreted system that can run on something as small as an Arduino Uno.
<Odin->
It's an interesting exercise.
<no-defun-allowed>
That would use 16-bit pointers, and does it expose fixnum-ness to the user?
<Odin->
It didn't have any immediate objects until I got to it... :p
<no-defun-allowed>
Python does not, so MicroPython can get away with actually having fixnums (unlike CPython).
<Odin->
Oh, interesting.
lowryder has quit [Ping timeout: 260 seconds]
lowryder has joined #lisp
<Nilby>
I'm trying really hard to resist the urge to port make-most-positive-bignum to sbcl.
<jackdaniel>
cl-user> most-positive-bignum ; STORAGE-CONDITION signalled: Storage is exhausted.
aartaka_d has joined #lisp
saganman has joined #lisp
aartaka has quit [Ping timeout: 265 seconds]
saganman has quit [Client Quit]
mindCrime has joined #lisp
<Nilby>
#<massively-positive-bignum> is seeming more attractive, but might thwart my Collatz disprover
<jackdaniel>
#<sceptic-bignum>
<beach>
I remember someone is/was working on a module that provides type proclamations for all standard functions. But I can't remember who. Maybe scymtym?
<nij>
Why should there be a maximal integer in Lisp?
<jackdaniel>
nij: there isn't, that's a point
<jackdaniel>
but lisp runs on a physical machine with a finite amount of memory
<jackdaniel>
that's why allocating too big int may cause a storage exhaustion
<nij>
Indeed.
<nij>
(expt 2 10000000000000000000) crashes my stumpwm.
<no-defun-allowed>
When runs out of word bits, one uses primary memory. When one runs out of primary, one uses secondary memory. When one runs out of secondary...
<jackdaniel>
it shouldn't - it should signal a condition
<jackdaniel>
but that's a bit tricky, because when you are out of memory, then you need to take a special precaution in the condition signalling code
<jackdaniel>
to not try to allocate more :)
<nij>
StumpWM Crashed With an Unhandled Error!
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<jackdaniel>
when one runs out of secondory they take out their pen and paper and scribble
<nij>
when secondary is ran out.. why not use the disk?
<nij>
I figure there are some edge cases not handled well in stumpwm.
varjag has joined #lisp
<beach>
nij: Disk *is* secondary memory.
<contrapunctus>
jackdaniel: "when one runs out of secondory they take out their pen and paper and scribble" lol
<nij>
they first have to have enough resources to ssh into their pen and pencil
<nij>
otherwise it doesn't work
nij has quit [Remote host closed the connection]
<beach>
Actually, a module for type proclamations of all standard functions ought to also contain other properties of those functions, like whether it has side effects, whether it might be consing, etc.
<jackdaniel>
ecl cmp module has a file with such proclamations
<beach>
I can imagine. I think I'll remove the description of such a module from the SICL specification, together with any code for it that I may have started at some point.
<beach>
Yes, like that. I see no reason to repeat such a thing as part of SICL. It should be a completely separate repository.
<jackdaniel>
I imagine that particular implementations may want to provide proclamations for their extensions and internals (for sake of the compiler)
<jackdaniel>
also I wonder whether some proclamations of standard functions could vary between implementations
<jackdaniel>
i.e -- "our cl:<foo> doesn't cons"
<beach>
That too. Especially for functions with undefined behavior according to the Common Lisp HyperSpec.
<Nilby>
Aren't there a fair amount of implementation specific ftypes? like upgraded-array-element-type or even char-int ?
<beach>
So, again, we need a protocol with a CLIENT parameter, so that it can be adapted and/or extended by client code.
<beach>
Nilby: Sure. But I am also pretty sure that there are lots of functions that have completely standardized behavior.
<jackdaniel>
(I have a strong suspicion that #'cons may cons in most implementations :)
<Nilby>
Right. Btw, I think CLient would be a good name for something
heisig has joined #lisp
<jackdaniel>
of course we forget about sufficiently smart compilers
<Nilby>
nooo! :O we just nearly got sufficiently smart compilers
<beach>
Either way, it would be good to have a defined protocol for this stuff.
ikrabbe has joined #lisp
<jackdaniel>
cl-repl> (cons 1 1) ; Condition of type SUFFICIENTLY-SMART-COMPILER: That's dumb, I won't allow you to do that.
antoszka has quit [Quit: WeeChat 2.8]
<Nilby>
That seems closer to the next level: SNARKY-COMPILER
<Nilby>
or maybe smart-ass-compiler
<jackdaniel>
cl-repl> (cons 1 1) ; Condition of type SNARKY-COMPILER-MESSAGE: yeah, sure. as if.
mrSpec has quit [Remote host closed the connection]
<Nilby>
which I would totaly use :)
wxie has quit [Ping timeout: 246 seconds]
jonatack has quit [Ping timeout: 240 seconds]
jonatack has joined #lisp
<jmercouris>
anything like Pharo exist for CL?
<jmercouris>
anyone applied some of the concepts to CL?
<beach>
jmercouris: If you tell us what Pharo is/does, then people who don't know Pharo might have an answer for you.
<jackdaniel>
it is smalltalk incarnation
<jackdaniel>
and yes, i.e some cl implementations have image-based runtime
<jackdaniel>
and you may find a few inspectors in mcclim codebase - mop gives good tools for working and inspective live systems
<jackdaniel>
what cl doesn't have is a blessed ide with all features integrated - slime is the closest thing to that in the free software world
<beach>
But an IDE is being worked on. Slowly, but still...
Nilby has quit [Ping timeout: 276 seconds]
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
<beach>
So if we had a defined protocol for various features of functions, and if that protocol had a CLIENT parameter for its functions, then it could be used for implementation-defined functions as well.
Nilby has joined #lisp
<beach>
Anyone interested in creating such a module?
<beach>
... unless it exists, of course.
igemnace has quit [Remote host closed the connection]
lotuseater has quit [Remote host closed the connection]
skapata has joined #lisp
<jmercouris>
The pieces of the puzzle exist, but not together it seems
<Nilby>
jmercouris: I tried Pharo, and I thought I would like it, but something about it bugged me. I used to have a TI machine on my desk that could boot into either Smalltalk or Lisp, both with a similarly advanced GUI. I always felt better in the Lisp side, but it's hard to explain why. lukego mentioned he was working in Pharo recently and went back to CL, so maybe he has some insight.
jello_pudding has quit [Ping timeout: 260 seconds]
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
brown121407 has joined #lisp
jello_pudding has joined #lisp
kslt1 has quit [Ping timeout: 268 seconds]
kslt1 has joined #lisp
vegansbane6963 has joined #lisp
random-nick has joined #lisp
attila_lendvai has quit [Quit: Leaving]
dilated_dinosaur has joined #lisp
saganman has joined #lisp
antoszka has joined #lisp
rumbler31 has quit [Remote host closed the connection]
leeren has quit [Quit: leeren]
leeren has joined #lisp
saganman has quit [Quit: WeeChat 1.6]
saganman has joined #lisp
<jmercouris>
I just want to steal some ideas and bring them into a CL IDE
<jackdaniel>
are you writing a cl ide?
amb007 has quit [Read error: Connection reset by peer]
<phoe>
according to Zawinski's Law, every program attempts to expand until it is possible to write Lisp code in it
<phoe>
I assume nyxt is no exception
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<jackdaniel>
naming in software is a hard problem, so I will propose one: phyro ,)
amb007 has joined #lisp
l1x has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
waleee-cl has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
ebrasca has quit [Ping timeout: 240 seconds]
ebrasca has joined #lisp
amb007 has joined #lisp
aartaka has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
Nilby has quit [Ping timeout: 276 seconds]
aartaka_d has quit [Ping timeout: 260 seconds]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 268 seconds]
Bike has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
srandon111 has joined #lisp
saganman has quit [Quit: WeeChat 1.6]
saganman has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
jurov has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
zefram22 has joined #lisp
amb007 has joined #lisp
ldbeth has joined #lisp
<ldbeth>
good evening
<zefram22>
abend
<flip214>
next project should be "clakdaniej"
ikrabbe has quit [Ping timeout: 240 seconds]
ikrabbe has joined #lisp
<jackdaniel>
:)
<beach>
zefram22: Are you new here? I don't recognize your nick.
<zefram22>
yup
<beach>
Great! What brings you to #lisp?
<zefram22>
oh, curiousity havent used lisp in years, was suprised others still were
<lukego>
jmercouris: Could alternatively extend GToolkit (http://gtoolkit.com/) to act as a Common Lisp dev environment i.e. swap out Emacs for a "full Lisp Machine" level UI (albeit one written in Smalltalk.)
<beach>
zefram22: I think you will find that there is lots of activity. Here and in several other channels.
<lukego>
but it's hard with systems written half in one language and half in the other.
jurov has joined #lisp
<zefram22>
yay, something to keep the creative juice flowing
<zefram22>
yeah, legacy integration is no fun
hypercube has joined #lisp
<jackdaniel>
I think that the name "Smalllisp" has at least three puns hidden :)
<beach>
jmercouris: Can I assume you are aware of components such as Clouseau, the CLIM listener, and the Second Climacs project? What would your design look like?
<beach>
jmercouris: Like, for instance, how would you handle indentation and highlighting? And what would your debugger look like?
kmeow has quit [Remote host closed the connection]
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
<beach>
zefram22: Are you planning to write some Common Lisp code?
<zefram22>
only if i have a proper use case
<beach>
For yourself you mean? Otherwise, there is plenty of code needed.
* jackdaniel
bestowes a proper use case to zefram22
<jackdaniel>
bestows?
<jackdaniel>
yes, bestows:)
<lukego>
jmercouris: Pharo/GToolkit is also a bit too integrated for my taste. I know that's the idea and there's a benefit to doing everything in one unified tool -- but there's also a cost to cutting me off from my preferred text editor, git client, etc, and forcing me to use their own relatively primitive and immature versions.
<lukego>
jmercouris: I'm not sure exactly where is the sweet spot on integration. Maybe there's also something to be said for a post-modern environment that embraces more diverse tools e.g. builds its debugger on rr as the bottom layer and does back-in-time lisp-level debugging. I dunno.
saganman has quit [Ping timeout: 252 seconds]
<jackdaniel>
contrapunctus: bringing lisp to 21 century by replacing hyphens with camel case made me chuckle :)
<jackdaniel>
is it meant as a joke?
wsinatra has joined #lisp
nicktick has joined #lisp
<contrapunctus>
jackdaniel: haha, yes, it's from r/lispmemes
<contrapunctus>
* I found it on
hypercube has quit [Ping timeout: 240 seconds]
<semz>
not too far off from many "modernization" attempts, sadly
zefram22 has quit [Quit: zefram22]
yitzi has joined #lisp
zefram22 has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
zefram22 has quit [Client Quit]
aeth has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
ldbeth has quit [Ping timeout: 246 seconds]
<semz>
Is there a project you'd recommend as a "good" example of using numerous or very advanced MOP concepts? While reading TAOMP I always get this feeling of a powerful tool that is simply overkill in many situations, so I'm trying to get an idea of where to use it.
zefram22 has joined #lisp
<beach>
semz: TAOMP = AMOP?
<beach>
semz: I don't think you will find many projects that use numerous MOP features, but you will find many projects that each relies on a specific MOP feature.
<semz>
Ah, I guess the "The" is dropped.
<semz>
But yes
<semz>
oh, I also apparently switched the M and O
<semz>
must be TAOCP influence
ldbeth has joined #lisp
rumbler31 has joined #lisp
ldbeth has quit [Ping timeout: 240 seconds]
theseb has joined #lisp
<theseb>
Anyone know about implementing a Lisp compiler that emits assembly? I'm stuck
daphnis has quit [Ping timeout: 265 seconds]
<beach>
semz: So for instance the "stealth mixin" library uses the possibility of customizing ENSURE-CLASS-USING-CLASS. And Costanza (I think it was) used the MOP to create a metaclass that used special variables as backing store for slots (for thread savety).
<Xach>
theseb: you could look at mezzano or movitz.
<beach>
theseb: What would you do with the assembly output?
Josh_2 has quit [Remote host closed the connection]
<semz>
beach: Thanks, these sound like good starting points.
<Xach>
theseb: or sbcl, cmucl, clozure cl, Anatomy of Lisp, Lisp in Small Pieces.
<theseb>
beach: i created a simple cpu emulator...I want to be able to compile the assembly to machine code and have it actually work
ldbeth has joined #lisp
<theseb>
beach: I implemented eval in python
<theseb>
beach: some thought I had were to implement eval in my tiny lisp and then implement eval in a tiny C like language and then write a compiler for that tiny c lang?
<theseb>
beach: seems more stages are needed to avoid the mental block i have
<beach>
theseb: I am not so sure that many Common Lisp systems emit assembly that can then be fed to a traditional assembler. Plus, the machine code that Common Lisp compilers emit is highly dependent on the runtime.
<theseb>
beach: Wait...you seem to be saying there is some issue with converting common lisp to assembler
<theseb>
or that somehow the assembly has to be special in some way
<splittist>
theseb: do you mean assembly, or machine code?
<theseb>
splittist: assembly as in ADD r1, r2, r3 LOAD, STORE ,etc
<beach>
theseb: No, of course not. But Common Lisp systems generate code that is meant to work with a runtime, so you can't expect that code to run without the Common Lisp system that generated it.
<White_Flame>
also, the 6502/NES assembler in lisp was an interesting assembly-level view of things
<theseb>
beach: runtime == virtual machine like JVM?
<theseb>
bytecode n' all that?
<beach>
theseb: No, I mean how to find a function given a function name, how to find non-trivial constants, how to invoke effective methods.
<theseb>
beach: i think in SICP they implemented scheme in a register machine...that is more like what I want to do
<beach>
Scheme has similar issues, but not quite as many perhaps.
<theseb>
beach: yea! i agree...all the minutia is making my head blow up....i somehow need to split this into lots of doable pieces...i'm going crazy
ldbeth has joined #lisp
<beach>
theseb: I have worked for around 13 years (not full time every year) on SICL, and there is still some work to be done before native code can be executed.
<beach>
Scheme is simpler, of course.
attila_lendvai has quit [Ping timeout: 240 seconds]
<theseb>
beach: can you outline the broad outlines of how you'd implement a compiler for at least just the bare bones basics of common lisp?
<theseb>
beach: is my ideas somehow the standard way to do it?....implement in a lisp subset then implement that in a c subset then implement c subset in assembly?
<theseb>
beach: i feel like that might be the general steps but not sure
<beach>
That is the way I present in the first presentation in my series "Creating a Common Lisp implementation", and that is also how many systems are written. And it is absolutely not how I would do it, as parts 1, 2, and 3 talk about.
<theseb>
a compiler is about transforming language X to Y to it makes sense (i think) you'd teach students to break it up into baby steps X -> A -> B -> C -> Y but what do i know
ldbeth has quit [Ping timeout: 265 seconds]
<theseb>
s/to/so
<White_Flame>
while it might not be the first step, since you're targeting a specific platform, you should design the ABI and figure out how things like tagging, dynamic bindings, condition handlers, GC information, etc, are implemented
<White_Flame>
that can give you a sense of the type of data you need to generate, which gives you a more concrete target to transform into
<beach>
theseb: For SICL, we use the full Common Lisp language to implement every module, and we generate machine code directly from Common Lisp code, translating the source to AST, the AST to intermediate representation, and the intermediate representation to machine code.
<Odin->
theseb: C has a runtime. It's often called "the operating system".
<theseb>
beach: so you do CL -> "intermediate representation" -> machine code
<theseb>
beach: is your "intermediate representation" more lisp-like or c-like? just curious
<White_Flame>
Odin-: or the stdlibs
<beach>
It is a pretty traditional control graph.
<beach>
A graph of instructions. See any book on compilers, e.g., Muchnick.
ldbeth has joined #lisp
<beach>
theseb: CL -> AST -> IR -> machine code
<theseb>
beach: i always felt like lisp was sort of an AST already so not sure why you had to parse CL into your AST
<Odin->
White_Flame: Well, yes. And on most contemporary systems, it's not easy to distinguish those from the rest of the OS.
<theseb>
beach: seems like an unnecessary extra loop around the horn
<Odin->
CL is ... not straightforward.
<Odin->
At all.
<beach>
theseb: The AST contains things like source position, and it has macros expanded already as required by "minimal compilation".
<Odin->
theseb: What kind of assembler are you thinking about?
<theseb>
Odin-: for a really simple assembly lang instruction set I made up
<theseb>
Odin-: however, even if I targeted a "real" ISA like x86 note sure it would be much easier
<beach>
theseb: If you want to give error/warning messages in terms of the code that the programmer wrote and give the source location of the relevant code, you can't do simple transformations on Common Lisp source code.
<Odin->
theseb: x86 is a nightmare, so, no, pretty sure it wouldn't.
ldbeth has quit [Ping timeout: 260 seconds]
<theseb>
beach: thanks for sharing your thoughts
<beach>
Sure.
<Odin->
theseb: The thing here is that you need to consider calling conventions, stack layout, and all kinds of further detail, and that's just to get to the point where you have something to compile _to_.
<theseb>
Odin-: well things like stack layout and calling conventions might be annoying but they aren't mind blowing.....what was mind blowing was not even knowing the general brush strokes...i think now i realize having lots of intermediate stages at least is part of the "general brush strokes"
<Bike>
well. you don't really need much of an IR for a non-optimizing compiler.
<White_Flame>
"write a compiler" and "write a CL compiler" are basically 2 tasks. Are you familiar with the former?
<semz>
Writing something that merely _targets_ x86 is not that difficult. The big issue is generating efficient code.
<White_Flame>
of course, for general compiler stuff, not CL specific. But since it totally skips the lexer/parser stuff intentionally, the meat is common to most languages
MrFantastik has joined #lisp
<theseb>
White_Flame: nice thanks
<White_Flame>
compilers are things that are actually quick to demystify
ldbeth has quit [Ping timeout: 252 seconds]
<theseb>
White_Flame: good to know
<theseb>
White_Flame: just have to confront your fears ;)
<Odin->
https://craftinginterpreters.com/ <-- Despite the name, it does do compiling. Just to a stack-based VM rather than a register machine. :p
<White_Flame>
but yeah, if you've not done compilers before, and want to map down to "good code" for a specific ISA, CL is certainly going to be larger challenge than something lower level
Kundry_Wag has quit [Ping timeout: 246 seconds]
ldbeth has quit [Remote host closed the connection]
ldbeth has joined #lisp
<beach>
theseb: Bike is right. If you don't need optimization and debugging information, you don't need much of an IR.
mrSpec has joined #lisp
mrSpec has joined #lisp
mrSpec has quit [Changing host]
<splittist>
You could develop within your lisp system by building things in a static-area byte vector and calling them. What could go wrong?
<White_Flame>
for some reason, I can't connect to metamodular.com either. Keep getting SSL_ERROR_INTERNAL_ERROR_ALERT
<jmercouris>
You'll have to just use HTTP
<beach>
jmercouris: Are you planning to parse the entire buffer at every keystroke?
<jmercouris>
probably, yes
<beach>
And you think that will be fast enough?
<jmercouris>
very inefficient, but also very simple
<jmercouris>
no, I don't think so
<beach>
jmercouris: And how do you plan to handle incorrect or incomplete input?
<jmercouris>
I like to start from basics, and iterate
<beach>
I see.
<jmercouris>
I will probably simple not handle incorrect input at first
<jmercouris>
same with incomplete
<jmercouris>
s/simple/simply
<beach>
OK. That's what we have spent a lot of time figuring out over the years.
<jmercouris>
It will be good to leverage your learnings!
<beach>
jmercouris: Also, do you plan to use READ to read the contents of the buffer?
<jmercouris>
No, I don't believe so
Spawns_Carpeting has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
<jmercouris>
the contents of the buffer will be known
<jmercouris>
I capture all keystrokes
<jmercouris>
no need to write to a buffer to read from it
Spawns_Carpeting has joined #lisp
<beach>
But if you want to communicate with the Common Lisp system, how do you communicate code if it is not READ?
<phoe>
metamodular seems offline to me too
<jmercouris>
ah you mean CL read
<jmercouris>
yes, that I must do
<jmercouris>
I have a very primitive REPL implementation that I will build off of
<beach>
If so, how do you handle symbols with a package prefix indicating a non-existing package?
<jmercouris>
no idea :-)
<jmercouris>
it is just a little seed in my brain today
<beach>
I see. Well, if you want to know how we plan to do it, then just let me know.
<beach>
Eclector is an essential part of that, of course.
<jmercouris>
I will let you know
<jmercouris>
I am afraid a lot of it will be over my head..
<beach>
It can't say there for very long if you want to create an IDE.
<beach>
jmercouris: But thanks. I now have a much better idea of the state of your plans.
<jmercouris>
I've learned a lot in the past few years, I'm sure theres at least a couple of kb free disk in my head, hopefully I can understand
<splittist>
There are lots of approaches to an 'IDE' - a full Lisp Machine/Climacs++ experience is only one of them. There are very productive programmers who use vi (not even vim) and a repl in a terminal.
<splittist>
I'm not saying that's optimal for many people - but I don't see why diversity cannot be a strength (:
<jmercouris>
beach: no problem, as you can imagine, such a process takes many years... I was thinking about Nyxt for two years before I even wrote a single line of code
<jmercouris>
and it was C at first! I wrote a lisp interpreter!
<beach>
I understand.
<jmercouris>
in fact, you were the one who argued to me that it was not necessary to write it in C
<jmercouris>
I don't know if you remember that conversation
<ldbeth>
a minimalist's ide has only the repl
<beach>
jmercouris: Not really, but I can look it up.
<jmercouris>
it was a long long long time ago
<beach>
jmercouris: We discuss these things mostly in #sicl, for when you want to know more about our plans.
<jmercouris>
yes
<beach>
jmercouris: Sure, and I have problems remembering what I did last week. :)
<jmercouris>
ah, the benefits of old age!
<ldbeth>
not even vi because you can do structural editing and dump the sexps
<beach>
jmercouris: yeah, my bad memory started at the age of 15.
<jmercouris>
hm, that can be often triggered by bad experiences, not saying it /is/ in your case, but it can be
<beach>
That's when I had to get my first calendar, to remember what day and time to do what.
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
<saganman>
Hello beach. How are you and how is the research going?
<beach>
saganman: Hello. Fine thank you. no-defun-allowed is going to do register allocation for me, and Gnuxie[m] might do the disassembler. That frees up some time for me to do more research, more documentation, etc.
<beach>
saganman: How about you?
<saganman>
I am okay, currently in self imposed lockdown because of covid.
<jmercouris>
C O V I D
<beach>
saganman: India, right?
<saganman>
yeah beach, the situation is pretty bad here now.
<beach>
So I hear.
<beach>
Oh, and it might be time to get some external financial support so that I can pay some people to help me with SICL.
<saganman>
that's good
<saganman>
beach: you can hire lisp enthusiats
<beach>
But I am waiting for the Common Lisp foundation to create some infrastructure, so that we can avoid those vulture platforms.
<beach>
saganman: There are very few people who are both qualified and available.
<jmercouris>
beach: what are vulture platforms?
<beach>
jmercouris: The ones where you can post bounties and stuff. They keep a significant part of the money.
<jmercouris>
oh I see, those
<beach>
jmercouris: And they change the rules after the fact.
<jmercouris>
any payment processor will charge you fees
<jmercouris>
you will probably be best served by setting up your own funding directly via Square, Stripe, or some bank
<beach>
I would rather the Common Lisp foundation keep some percentage.
<saganman>
I see
<beach>
jmercouris: I suppose that is possible.
waleee-cl has quit [Quit: Connection closed for inactivity]
<jmercouris>
who would you solicit for external funding?
<beach>
I would start by asking here. I haven't really thought much about that part.
<jmercouris>
that's the most important part
<beach>
We seem to manage to get regular contributions for McCLIM.
<jmercouris>
in the hundreds of thousands?
<beach>
I wouldn't know what to do with that much money.
<jmercouris>
I see
Alfr has quit [Quit: Leaving]
hypercube has quit [Ping timeout: 240 seconds]
Alfr has joined #lisp
<beach>
I think that 2k€ per month would be a very good start. That's a decent salary in some eastern European countries, or a decent part time for a young person.
<jmercouris>
I see, so you would need about 2.5k per person/month to handle the other expenses
<jmercouris>
taxes, accounting, etc
<beach>
I suppose.
<jmercouris>
that's just 30k /year, seems easily doable
<jmercouris>
could you do that on a donation basis? I am doubtful
<jmercouris>
I would think you would need to get support from a governmental entity/research organization
<beach>
You may be right. I guess I'll find out.
<beach>
jackdaniel: What monthly donations do we get for McCLIM?
<jmercouris>
If you want a gauge for how much money you could get, you can look at large open source projects, and see the ratio of people interested in a project/donating to a project
mindCrime has joined #lisp
<jmercouris>
you'll see that this number is a rather unfavorable ratio :'(
<ldbeth>
>> <beach> jmercouris: And how do you plan to handle incorrect or incomplete
<ldbeth>
input? >> Probably a good direction is implementing "holes", as in https://hazel.org
<Jachy>
beach: If you go the donation route, have you considered applying for GitHub Sponsors? As far as I know there are no fees, but of course that being true for the indefinite future is at the discretion of Microsoft.
<beach>
Jachy: I have not considered that. I might look into it. Are you saying they give people money?
<Jachy>
beach: They did have some matching funds set up for a while, I don't know if they do that still. But the intent is for other github users or orgs to give people money.
<beach>
ldbeth: The current plan is to have Eclector handle it, as it is already able to do.
yitzi has quit [Quit: yitzi]
<beach>
Jachy: Oh, I see.
<phoe>
gendl: ^
<phoe>
there's talk about donations, you might want to take a look at it
<beach>
Yes, this topic is for gendl.
<beach>
I believe jackdaniel is involved in a dialogue with the Common Lisp Foundation.
<beach>
... for the McCLIM funding.
<beach>
McCLIM used one of those platforms, but it became clear that it wasn't a good solution.
zefram22 has quit [Read error: Connection reset by peer]
<beach>
I see.
zefram22 has joined #lisp
xkapastel has joined #lisp
daphnis has joined #lisp
Josh_2 has joined #lisp
waleee-cl has joined #lisp
cosimone has joined #lisp
curtosis has joined #lisp
hjudt has joined #lisp
<gendl>
The CLF fundraising apparatus can disburse payments thru a beneficiary’s GitHub sponsors page, if one exists, to trigger any doubling or uplift which may be in effect.
amb007 has quit [Read error: Connection reset by peer]
<gendl>
We have done that for Faré for asdf, for example.
Josh_2 has quit [Remote host closed the connection]
amb007 has joined #lisp
kiroul has joined #lisp
<gendl>
beach: phoe: following up the the above.
amb007 has joined #lisp
ldbeth has quit [Quit: ERC (IRC client for Emacs 27.1)]
long4mud has quit [Ping timeout: 268 seconds]
MidHotaru_ has joined #lisp
Josh_2 has joined #lisp
<beach>
gendl: Great! So is the infrastructure in place for accepting funding and for paying for work?
bitmapper has joined #lisp
<beach>
gendl: I would be interested in asking people to contribute to some account specifically for SICL development, and then for people who do some work to get paid from that account.
srhm has joined #lisp
<beach>
gendl: And it would be fine with me for the foundation to keep a percentage for the service.
imode has joined #lisp
* beach
might have misunderstood what jackdaniel and the CLF discussed about McCLIM.
zefram22 has quit [Quit: zefram22]
<gendl>
beach: we have core infrastructure for accepting payments. It still needs some polishing. Preview here:
<gendl>
We do not have infrastructure for monitoring nor enforcing work or results
<gendl>
CLF has a general directive to retain 10% of any inflows, after paying overhead expenses and disbursements.
<gendl>
This is done in order to ensure the Foundation (a volunteer organization) always runs "in the black," and so that we might in due course build up an investment fund which can be applied to tracked investments.
yonkunas has joined #lisp
<gendl>
I'm open for volunteers to help with polishing the the payment acceptance infrastructure.
<gendl>
ball's in my court on that to some extent to make a proper README.md and CONTRIBUTING.md for the project.
Sheilong has joined #lisp
elinow has quit [Quit: Leaving]
yitzi has joined #lisp
curtosis has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
rogersm has joined #lisp
varjagg has joined #lisp
Necktwi has quit [Quit: leaving]
Necktwi has joined #lisp
aeth has quit [Ping timeout: 260 seconds]
nij has joined #lisp
<nij>
Hello! Is there any de facto package that collects modern data structures like tries or rings?
DHARMAKAYA has joined #lisp
aeth has joined #lisp
<nij>
And for such data structures, if I want to define them by my own, does it make sense to use CLOS? I'm afraid that it's a over-kill and might compromise efficiency.
cosimone has quit [Remote host closed the connection]
daphnis has quit [Ping timeout: 260 seconds]
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
<nij>
Hmm it doesn't release with versions. phoe how did you decide which commit to use?
saganman has quit [Quit: WeeChat 1.6]
<phoe>
nij: I use whatever quicklisp serves
<nij>
I see. That's a good rule of thumbs.
gitgood has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
l1x has quit [Quit: Connection closed for inactivity]
nij has left #lisp ["ERC (IRC client for Emacs 27.2)"]
aeth has quit [Ping timeout: 260 seconds]
aeth has joined #lisp
curtosis has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
rogersm has joined #lisp
<beach>
gendl: Sounds perfect! Thanks!
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
gumman has quit [Read error: Connection reset by peer]
gumman has joined #lisp
theseb has quit [Quit: Leaving]
<jackdaniel>
beach: currently none because the bountysource account is suspended. before that we had recurring donation around $300 / month
MidHotaru_ has quit [Quit: Connection closed for inactivity]
<jackdaniel>
and regarding the rest, gendl is putting hard work to get us platform on cl.net
<lukego>
gendl: that's awesome that you're doing this!
jeosol has joined #lisp
madage has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
<jackdaniel>
it is
amb007 has joined #lisp
<lukego>
gendl: re "enforcing work and results" that's potentially more trouble than it's worth. I believe in a lot of EU countries you're allowed to receive tax-free gifts from foundations like this - great - but if you have a deliverable then it would be classified as work and ~half will disappear in taxes. I'm sure it varies a lot between countries but I've heard this about Germany at least.
madage has joined #lisp
<lukego>
(someone asked their accountant if the grant would be taxed, they said no it's an exempt gift, great, then they changed their mind when they saw the receipt and said nah that's contract work)
amb007 has quit [Read error: Connection reset by peer]
Sauvin has quit [Remote host closed the connection]
<jackdaniel>
clf in past campaigns ran appreciation fundraisers and that's imo a very fine approach
amb007 has joined #lisp
<lukego>
yeah I'd be more inclined to give for one of those. also because it's nice to recognize good work that people have done while sometimes sponsored work ends up heaping obligations on people for below-market compensation and is a bad like a badly paid job.
<lukego>
also great if it's done in such a way that a company can make a contribution and get an invoice that can be expensed e.g. get their name put on a website somewhere so it's a sponsorship/marketing/advertising expense.
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<lukego>
(sorry of this is veering off topic but that's all I have to say anyway :))
amb007 has quit [Read error: Connection reset by peer]
<jackdaniel>
with McCLIM when I've set the fundraiser I've declared that money will go to sponsor part of my time to work (and part on bounties, but bounties didn't pan out as well as I have expected them)
amb007 has joined #lisp
<jackdaniel>
and that money didn't run out yet; also all I had to say ,)
dieggsy has quit [Ping timeout: 245 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
dieggsy has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
CrashTestDummy2 has quit [Quit: Leaving]
fourier has quit [Ping timeout: 240 seconds]
hjudt has quit [Quit: leaving]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
CrashTestDummy has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
CL-ASHOK has joined #lisp
VincentVega has joined #lisp
<CL-ASHOK>
fellow lisp geniuses
<CL-ASHOK>
How do I re-write the below that it doesn't give me an error "port already in use" every time I re-load the file?
<phoe>
oh wait! yes, what jackdaniel said, use DEFVAR; this way the hunchentoot:start form it will only be evaluated once
<phoe>
s/it//
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
mindCrime has quit [Ping timeout: 265 seconds]
<CL-ASHOK>
Wow - thanks! So easy
<CL-ASHOK>
You guys are too good ;)
pch2013 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
contrapunctus has left #lisp ["Disconnected: closed"]
amb007 has joined #lisp
nij has joined #lisp
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
contrapunctus has joined #lisp
nij has quit [Quit: ERC (IRC client for Emacs 27.2)]
amb007 has quit [Read error: Connection reset by peer]
CrashTestDummy2 has joined #lisp
hjudt has joined #lisp
hjudt has quit [Client Quit]
hjudt has joined #lisp
hjudt has quit [Client Quit]
<jackdaniel>
of course, that's why we're confined on this channel
<jackdaniel>
we are cybernetical beings in prison
hjudt has joined #lisp
CrashTestDummy has quit [Ping timeout: 240 seconds]
amb007 has joined #lisp
<CL-ASHOK>
@jackdaniel :D
rogersm has quit [Quit: Leaving...]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
jeosol has quit [Quit: Connection closed]
jeosol has joined #lisp
VincentVega has quit [Quit: Connection closed]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
karlosz has joined #lisp
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
hypercube has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
CL-ASHOK has quit [Quit: Connection closed]
ljavorsk has joined #lisp
terpri_ has joined #lisp
terpri has quit [Ping timeout: 240 seconds]
CrashTestDummy has joined #lisp
CrashTestDummy2 has quit [Ping timeout: 245 seconds]
hypercube has quit [Ping timeout: 245 seconds]
prxq has quit [Ping timeout: 252 seconds]
ljavorsk has quit [Ping timeout: 240 seconds]
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 260 seconds]
Lord_of_Life_ is now known as Lord_of_Life
terpri__ has joined #lisp
CL-ASHOK has joined #lisp
terpri_ has quit [Ping timeout: 240 seconds]
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
CrashTestDummy2 has joined #lisp
hiroaki_ has quit [Ping timeout: 260 seconds]
CrashTestDummy has quit [Ping timeout: 245 seconds]
CL-ASHOK has quit [Quit: Ping timeout (120 seconds)]
shka_ has quit [Ping timeout: 240 seconds]
hiroaki_ has joined #lisp
long4mud has joined #lisp
MrFantastik has quit [Remote host closed the connection]
spaethnl has quit [Ping timeout: 240 seconds]
hjudt has quit [Remote host closed the connection]
hjudt has joined #lisp
krid has joined #lisp
scm has joined #lisp
jeosol has quit [Quit: Connection closed]
wsinatra has quit [Ping timeout: 246 seconds]
GreaseMonkey has quit [Remote host closed the connection]
aartaka_d has quit [Read error: Connection reset by peer]
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
wsinatra has joined #lisp
greaser|q has joined #lisp
nij has joined #lisp
<nij>
Hello! IIRC, ambrevar's sly main shell isn't released back then. Any news on that? I cannot wait but putting my hands on the goodies described in the wonderful article: https://ambrevar.xyz/lisp-repl-shell/index.html
arpunk has quit [Remote host closed the connection]
gaqwas has quit [Ping timeout: 268 seconds]
krid has quit [Ping timeout: 245 seconds]
wsinatra has quit [Quit: WeeChat 3.1]
kevingal has quit [Remote host closed the connection]
pve has quit [Quit: leaving]
mindCrime has joined #lisp
akoana has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
nij has quit [Ping timeout: 250 seconds]
scymtym_ has joined #lisp
heisig has quit [Quit: Leaving]
mindCrime has quit [Ping timeout: 265 seconds]
scymtym has quit [Remote host closed the connection]
gaqwas has joined #lisp
gaqwas has joined #lisp
krid has joined #lisp
ramHero has quit [Remote host closed the connection]
varjagg has quit [Ping timeout: 260 seconds]
spikhoff has joined #lisp
frgo_ has joined #lisp
frgo has quit [Remote host closed the connection]
surabax has quit [Quit: Leaving]
anticrisis has joined #lisp
raeda has joined #lisp
gaqwas has quit [Ping timeout: 265 seconds]
nicktick has quit [Ping timeout: 252 seconds]
hypercube has joined #lisp
Sheilong has quit [Quit: Connection closed for inactivity]
amb007 has quit [Read error: Connection reset by peer]
Krystof has quit [Ping timeout: 246 seconds]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
sm2n_ has joined #lisp
sm2n has quit [Ping timeout: 252 seconds]
X-Scale` has joined #lisp
tempest_nox has joined #lisp
X-Scale has quit [Ping timeout: 240 seconds]
X-Scale` is now known as X-Scale
scm has quit [Quit: Leaving]
Nilby has joined #lisp
sm2n has joined #lisp
cantstanya has joined #lisp
sm2n_ has quit [Ping timeout: 246 seconds]
random-nick has quit [Ping timeout: 246 seconds]
Colleen has quit [Remote host closed the connection]
Colleen has joined #lisp
hiroaki_ has quit [Ping timeout: 260 seconds]
igemnace has joined #lisp
hendursa1 has quit [Remote host closed the connection]
hendursa1 has joined #lisp
hendursa1 has quit [Remote host closed the connection]
xsperry has quit [Remote host closed the connection]
hendursa1 has joined #lisp
Codaraxis__ has joined #lisp
ebrasca has quit [Remote host closed the connection]