toadlicker has quit [Remote host closed the connection]
toadlicker has joined #commonlisp
mala has joined #commonlisp
chiselfuse has quit [Remote host closed the connection]
chiselfuse has joined #commonlisp
poselyqualityles has joined #commonlisp
toadlicker has quit [Remote host closed the connection]
toadlicker has joined #commonlisp
admich1 has quit [Ping timeout: 276 seconds]
poselyqualityles has quit [Ping timeout: 248 seconds]
admich1 has joined #commonlisp
bpanthi977 has quit [Ping timeout: 260 seconds]
rkazak has quit [Ping timeout: 272 seconds]
<beach>
phil_bb: Can you be more specific about the nature of the tree and the DEFCLASS forms you want to build?
poselyqualityles has joined #commonlisp
rkazak has joined #commonlisp
rkazak has quit [Ping timeout: 276 seconds]
rkazak has joined #commonlisp
puke has quit [Quit: puke]
puke has joined #commonlisp
rkazak has quit [Ping timeout: 272 seconds]
screwlisp has joined #commonlisp
Alfr has quit [Remote host closed the connection]
Alfr has joined #commonlisp
pve has joined #commonlisp
rkazak has joined #commonlisp
rkazak has quit [Ping timeout: 248 seconds]
rkazak has joined #commonlisp
rkazak has quit [Ping timeout: 276 seconds]
istewart has quit [Quit: Konversation terminated!]
chomwitt has joined #commonlisp
admich1 has quit [Read error: Connection reset by peer]
admich1 has joined #commonlisp
rkazak has joined #commonlisp
edgar-rft has joined #commonlisp
edgar-rft` has quit [Ping timeout: 248 seconds]
ingeniot has joined #commonlisp
screwlisp has quit [Ping timeout: 268 seconds]
varjag has joined #commonlisp
rkazak has quit [Ping timeout: 252 seconds]
uhuh has joined #commonlisp
uhuh has quit [Changing host]
uhuh has joined #commonlisp
phantomics_ has quit [Ping timeout: 276 seconds]
phantomics has joined #commonlisp
<beach>
Let's say we have forms that produce multiple values and we have operators that consume multiple values, like MULTIPLE-VALUE-BIND, MULTIPLE-VALUE-CALL, etc. Are multiple values always produced and consumed in a LIFO (stack) way, or is it possible that some multiple values, say M1 and M2 produced in that order will be consumed in the reverse order?
<beach>
My hunch is that the LIFO order is respected, but I don't know how to go about proving that.
lusciouslover has quit [Remote host closed the connection]
lusciouslover has joined #commonlisp
rkazak has joined #commonlisp
ingeniot has quit [Ping timeout: 252 seconds]
poselyqualityles has quit [Ping timeout: 252 seconds]
chkhd has joined #commonlisp
<jackdaniel>
wouldn't that depend on the actual implementation?
<beach>
My theory is that it wouldn't.
<jackdaniel>
multiple-value-call could be implemented by pushing next values onto the stack and then consuming it wholesale
<jackdaniel>
but generally "consuming" is rather vague -- consumed from where?
<jackdaniel>
multiple-value-prog1 pushes /somewhere/ values, then in body you may have multiple forms that "consume" values
<jackdaniel>
and then multiple-value-prog1 restores them
<jackdaniel>
s/them/old ones/
rkazak has quit [Ping timeout: 248 seconds]
uhuh has quit [Remote host closed the connection]
uhuh has joined #commonlisp
uhuh has quit [Changing host]
uhuh has joined #commonlisp
rkazak has joined #commonlisp
leeb_ has joined #commonlisp
by9042 has joined #commonlisp
leeb has quit [Ping timeout: 268 seconds]
rkazak has quit [Ping timeout: 245 seconds]
ingeniot has joined #commonlisp
X-Scale has quit [Ping timeout: 260 seconds]
X-Scale has joined #commonlisp
ingeniot has quit [Ping timeout: 268 seconds]
rkazak has joined #commonlisp
<|3b|>
does non-local exit past some values count as consuming?
<|3b|>
doesn't allow reverse order, at least
<|3b|>
well, aside from throw?
<beach>
When some multiple values are no longer accessible, they are consumed.
<beach>
But non-local control is a good point. I need to look into that a bit more.
<|3b|>
throw avoids lifo order i think? though could be argued to consume then produce again
<|3b|>
(m-v-prog1 (values 1 2) (m-v-call f (values 3 4) (throw x (values 5 6))))
<|3b|>
i guess the m-v-prog1 consumes as mentioned above, so ignore that part
bpanthi977 has joined #commonlisp
<|3b|>
so yeah, depends on whether you define the things that could be out of order as "consuming" then "producing" or not
<jackdaniel>
if we take that definition then there is no stack, just a single place where you depone values. that'd make it both lifo and fifo and the stack of size 1
* |3b|
suspects that is always a valid interpretation, but also has no proof
<beach>
|3b|: Good points. I'll think about that.
<beach>
jackdaniel: I think you are considering individual values whereas my question was about multiple-values as units.
<jackdaniel>
do I understand that by a "multiple values unit" you mean a tuple of (i.e) four values produced by (values 1 2 3 4) ?
<beach>
|3b|: You are right in that some multiple values becoming inaccessible may not respect the order, but that would be fine.
bpanthi977 has quit [Ping timeout: 252 seconds]
<beach>
jackdaniel: Yes.
svm has joined #commonlisp
<jackdaniel>
then that was my understanding from the beginniong
<beach>
Great!
* |3b|
wonders if there is a distinction to make between fully constructed tuples and tuples being constructed
<|3b|>
since fully constructed tuples might only have a stack size of 1, but being constructed is arbitrary depth
<jackdaniel>
each call to values replaces the old tuple, so there is no stack. unless we consider also storing that tuple somewhere else (like multiple-value-prog1 does or multiple-value-call does, or even LET would when you use multiple-value-list), but in that case the order of "consuming" is arbitrary
<|3b|>
assuming VALUES doesn't know only 1 value is needed
msv has quit [Read error: Connection reset by peer]
<jackdaniel>
i.e when you type (VALUES (VALUES 1 2) 3) there is no nesting, after evaluating the first argument values=[1 2], then it is [3], finally it is [1 3]
<jackdaniel>
I might have dropped some paren, my head evaluator is not a strong one
<|3b|>
right, so depth of 3?
<jackdaniel>
no, it is a simple "multiple value unit", values always stores only one tuple at any given point
<|3b|>
[1..] and [2..] are stored on a stack while [3 4] is constructed
<|3b|>
as incomplete tuples
<jackdaniel>
the operator values may hold temoprary values in a variable or anywhere basically, but that's not different from (say) LET, MVP1 and MVC
<|3b|>
ah, right, i guess it is a function
<jackdaniel>
it doesn't have to be, but you don't need to invent an incomplete tuple (and probably musn't, but I don't feel like asserting this one strongly)
<jackdaniel>
MVP1 i.e usually will push values onto the stack
<|3b|>
yeah, that suggestion was based on incorrect thinking :)
<jackdaniel>
while MVC could do the same with an extra hint that TOP contains the number of values, so pushing more values pops the number, adds new values, and pushes incremented number
poselyqualityles has joined #commonlisp
<jackdaniel>
or it could append multiple-value-list onto a variable and apply it of course
* |3b|
starts to lean towards "there is no stack". the only values tuple is either returned, dropped or consumed, and making a new one would require either consuming or dropping it
<beach>
I don't think that's true. (m-v-prog1 (values 1 2) (m-v-prog1 (values 3 4) ...)) While ... is being evaluated, there are two produced "values items", that are not yet consumed.
rkazak has quit [Ping timeout: 248 seconds]
<jackdaniel>
|3b|: by saying that mvp1 pushes onto the stack I mean "some arbitrary stack not necessarily related to values"
<jackdaniel>
beach: values unit (as I've said earlier) in this interpretation may be retained by LET and processed at a user discretion in any order
<|3b|>
beach: semantically, m-v-prog1 consumes it and then produces an new one if it exits normally
<jackdaniel>
MVP1 may be (let ((x (multiple-value-list form))) ,@body (values-list x))
<|3b|>
though if the context is deciding what sort of optimizations are valid while implementing m-v-prog1, that might not be a helpful definition :)
<beach>
I think I give up trying to formulate my question in an understandable way. Thanks to both of you for your help.
<jackdaniel>
|3b|: sure (: in ECL it is implemented by pushing values onto a general purpose runtime stack and then popping from then back into the values vector (a singular place, not a stack)
admich1 has quit [Ping timeout: 245 seconds]
<jackdaniel>
of course one could push some tuple objects onto the stack instead, but what would be the purpose of this is a missing piece
admich1 has joined #commonlisp
<|3b|>
beach: might also consider nlx returning closures for odd edge cases
<jackdaniel>
but if we take that definition (tuples on a stack), then mvc could consume them in fifo order
<beach>
|3b|: Thanks!
* |3b|
doesn't think you can break ordering with closures, but much less confident about that
poselyqualityles has quit [Ping timeout: 244 seconds]
rkazak has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
admich1 has quit [Read error: Connection reset by peer]
<phil_bb>
This is what I'm trying to do, in an effort to simplify maintaining extremely long class definitions
Gleefre has joined #commonlisp
rkazak has joined #commonlisp
ingeniot has quit [Ping timeout: 248 seconds]
by9042 has quit [Quit: Konversation terminated!]
rkazak has quit [Ping timeout: 276 seconds]
treflip` has joined #commonlisp
treflip has quit [Ping timeout: 276 seconds]
rkazak has joined #commonlisp
divya- has quit [Ping timeout: 244 seconds]
rkazak has quit [Ping timeout: 272 seconds]
tasty has quit [Remote host closed the connection]
tasty has joined #commonlisp
ingeniot has joined #commonlisp
rkazak has joined #commonlisp
<nil>
I'm pretty sure initial implementation of values was a list wrapped in a type, so ideas of consuming and producing of values only came later when compilers try to make things faster.
chomwitt has quit [Ping timeout: 248 seconds]
<beach>
phil_bb: I would start by creating a recursive function to traverse the tree and generate the class names and slots. Then you can call that function from a macro.
<beach>
nil: What makes you think that, and what would the type be?
<nil>
What makes me think that is memories of older Lisps, and the type would be similar to (defstruct values values)
<beach>
nil: Do you remember the name of any of those older Lisps?
<nil>
Hmm, probably a PDP-10 Lisp, Maclisp, and maybe even Spice Lisp.
<nil>
At one time they didin't have multiple values, and then it was added.
<beach>
I see.
<phil_bb>
jackdaniel: trying to understand this... how even do you just pull these out of thin air
<jackdaniel>
practice I guess
<beach>
phil_bb: There are not many different solutions possible. It's all in the detail. But you do need a recursive function to traverse the tree as jackdaniel shows.
<jackdaniel>
just for the record, I abhor any use of llms for writing code
<phil_bb>
Changed progn to prog1, to inspect the created classes, looks pretty much like what I wanted, now I have to hack on this a little to get all the initforms/ initargs/ specific slots/ inheritance
<jackdaniel>
you don't need to change anything, just call the function tree-to-class-definition-forms and inspect the result
<jackdaniel>
it will return unevaluated definitions
<phil_bb>
I agree on code, but for writing documents and information retrieval they can be useful. I made a package for Emacs that lets me query my org-mode journal for weekly review, it's quite useful with the medgemma model, found it pretty helpful.
<jackdaniel>
I'll keep my opinion to myself as irrelevant to the channel topic :3
<phil_bb>
Of course, my health isn't very lisp lol
<phil_bb>
Do you think it's sane to try and make a macro that puts together a constructor function based on this?
<jackdaniel>
if that's your cup of tea then why not
<phil_bb>
It seems like the saner way to go since I already have 200+ items to account for, and if I can consolidate everything into a single list where I can control the properties for generation... that'd help a ton
rkazak has quit [Ping timeout: 244 seconds]
treflip` has quit [Ping timeout: 265 seconds]
divya has joined #commonlisp
<nil>
phil_bb: I think code writing macros are one of the joys (and potential pitfalls) of Lisp. I do have to sometimes ask myself if I'm just doing it for fun, or it's really better in long run. But like in jackdaniel's example, data driven code generation can pay off.
<phil_bb>
Yeah... I've been dabbling with Lisp for years now, but I mean really dabbling. Never really got around to putting in effort, and now that I've some kind of stability, it feels like it's time.
<phil_bb>
A major issue I have is making things much more complicated than they have to be. My previous attempts have been with a single macro that would process the entire tree *and* generate the defclass forms at the same time, with the slots being derived right in the `(defclass ...), which kept on failing
<phil_bb>
Seeing the way jackdaniel wrote it is enlightening lol
<beach>
phil_bb: It is often a good idea to write a macro as a combination of a simple DEFMACRO form that calls more complicated functions to do the expansion.
bpanthi977 has joined #commonlisp
<phil_bb>
I can sure see that here. What's the style convention for these helper functions? Does it matter if main/exportable functions are in the same naming scheme as helpers/utils?
<phil_bb>
In emacs I'd use my- or my/ but since CL has packages, don't know if it's necessary
<phil_bb>
Possibly controversial... loop vs iterate for personal projects like this? I'm thinking iterate is easier to wrap my head around, but then loop is built-in.
bpanthi977 has quit [Ping timeout: 276 seconds]
<beach>
jackdaniel: I have an ECL question relative to what you said before. Suppose you have something like https://plaster.tymoon.eu/v/7ADYWDIRU#4856 When aa is called, it must first call bb and if I understand things right, the values returned are stored in the thread object for later use. But then it must call dd next, so it needs to use that storage again. Where are the values returned by bb stored while this is happening?
<beach>
phil_bb: If you are writing code just for yourself, it doesn't matter.
<phil_bb>
Alright. I was concerned it may have impact on my long-term understanding since they're quite different.
chomwitt has joined #commonlisp
<beach>
phil_bb: I don't think there is an impact either way, provided ITERATE is correctly documented, of course.
<jackdaniel>
beach: as I've mentioned they are pushed onto a thread-specific stack for lisp objects. then we open a stack frame, call cc, close the stack frame and transfer values from the stack to the values vector
<beach>
jackdaniel: Oh, sorry, I missed that. So there is memory allocation involved, yes?
bpanthi977 has joined #commonlisp
<jackdaniel>
the lisp stack is allocated when the thread is started (on overflow it may be resized)
<jackdaniel>
pushing values onto the stack does not require additional allocations
<beach>
I'm lost. So what are the elements of that stack?
<jackdaniel>
lisp objects
<beach>
Does each element of the stack hold multiple values, or is there just one value per stack element?
<jackdaniel>
one value per stack element
treflip has joined #commonlisp
<beach>
So there is also an element that indicates how many values there are in each batch?
<jackdaniel>
i.e OP_PUSHVALUES for values [1 2 3] will push 1 2 3 3
<beach>
Got it. Thank you!
<jackdaniel>
and OP_PUSHMOREVALUES [5 6] will pop the last element and add them, so the end result will be 1 2 3 5 6 5
<beach>
Interesting.
<beach>
And since it is a stack, you clearly expect the elements to be used in a LIFO way.
<jackdaniel>
not necessarily, there are also stack frames involved, and if we call a function from the lisp stack, then we start at the frame beginning
bpanthi977 has quit [Ping timeout: 276 seconds]
<jackdaniel>
similar for storing locals
<beach>
I see. Thank you.
<jackdaniel>
but if we bar these cases, then yes, stack is usually accessed from the top
<jackdaniel>
sure
<jackdaniel>
(of course all these descriptions assume that no optimizations were applied whatsoever)
chkhd has quit [Quit: ZZZzzz…]
rkazak has joined #commonlisp
ingeniot has quit [Ping timeout: 276 seconds]
admich1 has quit [Ping timeout: 252 seconds]
admich1 has joined #commonlisp
yitzi has joined #commonlisp
admich1 has quit [Ping timeout: 265 seconds]
decweb has joined #commonlisp
rkazak has quit [Ping timeout: 248 seconds]
treflip` has joined #commonlisp
treflip has quit [Ping timeout: 276 seconds]
rkazak has joined #commonlisp
treflip`` has joined #commonlisp
treflip` has quit [Ping timeout: 252 seconds]
admich1 has joined #commonlisp
rkazak has quit [Ping timeout: 276 seconds]
FallenSky has joined #commonlisp
rkazak has joined #commonlisp
cage has joined #commonlisp
flip214 has quit [Ping timeout: 245 seconds]
ewig has joined #commonlisp
mange has quit [Quit: Zzz...]
rkazak has quit [Ping timeout: 268 seconds]
FallenSky has quit [Remote host closed the connection]
zacque has joined #commonlisp
flip214 has joined #commonlisp
gnoo has quit [Ping timeout: 248 seconds]
gnoo has joined #commonlisp
rkazak has joined #commonlisp
rkazak has quit [Ping timeout: 245 seconds]
flip214 has quit [Ping timeout: 245 seconds]
flip214 has joined #commonlisp
Gleefre has quit [Ping timeout: 272 seconds]
Gleefre has joined #commonlisp
rkazak has joined #commonlisp
Gleefre has quit [Ping timeout: 272 seconds]
Gleefre has joined #commonlisp
skin has joined #commonlisp
<yacin>
ah looks like my issue/package for quicklisp was fine. just got skipped by accident
Gleefre has quit [Remote host closed the connection]
Gleefre has joined #commonlisp
treflip`` has quit [Ping timeout: 265 seconds]
bpanthi977 has joined #commonlisp
treflip has joined #commonlisp
treflip has quit [Read error: Connection reset by peer]
rkazak has joined #commonlisp
treflip has joined #commonlisp
bpanthi977 has quit [Ping timeout: 276 seconds]
admich1 has quit [Ping timeout: 248 seconds]
admich1 has joined #commonlisp
King_julian has quit [Ping timeout: 252 seconds]
msv has joined #commonlisp
King_julian has joined #commonlisp
svm has quit [Ping timeout: 252 seconds]
apac has joined #commonlisp
bpanthi977 has joined #commonlisp
Gleefre has quit [Remote host closed the connection]
Gleefre has joined #commonlisp
Gleefre has quit [Remote host closed the connection]
bpanthi977 has quit [Ping timeout: 276 seconds]
Gleefre has joined #commonlisp
Gleefre has quit [Remote host closed the connection]
by9042 has joined #commonlisp
rkazak has quit [Ping timeout: 252 seconds]
rkazak has joined #commonlisp
rkazak has quit [Ping timeout: 248 seconds]
cage has quit [Quit: rcirc on GNU Emacs 30.1]
skin has quit [Ping timeout: 248 seconds]
skin has joined #commonlisp
zacque has quit [Quit: Goodbye :D]
rkazak has joined #commonlisp
ingeniot has joined #commonlisp
<jackdaniel>
good to know
Josh_2 has joined #commonlisp
<Josh_2>
Hi hi
<voidness>
:shake
Josh_2 has quit [Ping timeout: 252 seconds]
Josh_2 has joined #commonlisp
bpanthi977 has joined #commonlisp
Josh_2 has quit [Remote host closed the connection]
treflip` has joined #commonlisp
rkazak has quit [Ping timeout: 265 seconds]
treflip has quit [Ping timeout: 248 seconds]
rkazak has joined #commonlisp
Josh_2 has joined #commonlisp
rkazak has quit [Ping timeout: 248 seconds]
<beach>
voidness: Are you new here? I don't recognize your nick.
voidness has quit [Read error: Connection reset by peer]
treflip` has quit [Ping timeout: 248 seconds]
Josh_2 has quit [Quit: Gotta go fast!]
skin has quit [Ping timeout: 276 seconds]
bpanthi977 has quit [Remote host closed the connection]
bpanthi977 has joined #commonlisp
ingeniot has quit [Ping timeout: 252 seconds]
rkazak has joined #commonlisp
rkazak has quit [Ping timeout: 252 seconds]
ewig has quit [Read error: Connection reset by peer]
deriamis has quit [Ping timeout: 252 seconds]
deriamis has joined #commonlisp
ingeniot has joined #commonlisp
Josh_2 has joined #commonlisp
by9042 has quit [Quit: Konversation terminated!]
rkazak has joined #commonlisp
Noisytoot has quit [Excess Flood]
Josh_2 has quit [Remote host closed the connection]
Noisytoot has joined #commonlisp
Noisytoot has quit [Remote host closed the connection]
Noisytoot has joined #commonlisp
rkazak has quit [Ping timeout: 265 seconds]
bpanthi977 has quit [Ping timeout: 260 seconds]
semz has quit [Quit: ZNC 1.9.0+deb2build3 - https://znc.in]
bpanthi977 has joined #commonlisp
bpanthi977 has quit [Remote host closed the connection]
bpanthi977 has joined #commonlisp
ingeniot has quit [Ping timeout: 260 seconds]
semz has joined #commonlisp
bpanthi977 has quit [Ping timeout: 276 seconds]
rkazak has joined #commonlisp
<phil_bb>
In CLOS, is it possible to set a class slot value to be a function, in such a way that a method can iterate over every instance of that class and execute that function to update other slots in that class instance? I feel like I'm going crazy trying to solve for this.
<phil_bb>
Problem: there's a bunch of systems in the human body that need to operate independently of external events.
<phil_bb>
My thinking is, I'd put a function into a :self-update slot in each of these, which would update the state of the object (and possibly related objects, side-effects aplenty). I'd keep a list of these objects, and mapcar funcall on the slot-value.
<phil_bb>
Oooooh, really cool. I'll need to test beforehand because I'm also feeding this into Lisa.
<phil_bb>
I can definitely see this creating a bunch of headaches, since the human body tends to create feedback loops.
<phil_bb>
c-stops seem like a major concern
attila_lendvai has joined #commonlisp
_cymew_ has quit [Ping timeout: 244 seconds]
<_death>
if you actually need to write a simulation, then you need to go a bit higher level than updating slots
pve has quit [Quit: leaving]
rkazak has quit [Ping timeout: 276 seconds]
akoana has joined #commonlisp
toadlicker has quit [Remote host closed the connection]
toadlicker has joined #commonlisp
<phil_bb>
Well "simulation" as a side-project to get my mind off of work.
<phil_bb>
Think of it like one of those survival games where you have to track hunger, warmth, hydration, etc, just a bit more on the "single character" side
<phil_bb>
I just want to have a simulated human, and then have it respond to pre-defined events I trigger
rkazak has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
rkazak has joined #commonlisp
<aeth>
so... The Sims
<aeth>
kind of
<phil_bb>
Kinda sorta, but with actual working (simplified, but working) organs.
<phil_bb>
I want to have a reasonable approximation of a person being electrocuted, as an ideal goal, with all the side-effects.
<aeth>
if you want an iterate-optimized data structure, look into entity component systems, which are a trendy thing for games
<aeth>
there are probably at least 3 libraries for that
<aeth>
usually just "ECS"
<aeth>
You have a fixed simulation tick rate, say, 10 Hz (common candidates are 10, 30, 32, 50, 60, 64, 100, 128... doesn't really matter... just keep it fixed). Otherwise it's nondeterministic to replay the simulation.
<phil_bb>
Nah, I'm looking at turns, 1s = 1 turn, like in roguelikes.
<aeth>
ticks, turns, same thing
<aeth>
I don't think there's really a standard term. Some people call it "frames", but now for a regular game with 3D graphics you have simulation frames and render frames at different rates
<aeth>
But with an ECS, they're basically array-component-first, so they're optimized for the regular updates on the arrays, at the cost of indirection when doing things directly by ID
<phil_bb>
I suppose so. Currently I just want to get my classes in order, because typing all the definitions and keeping mental track of them is genuinely hell
<aeth>
I personally do my own ECS (which was made before that one by a decade or so) instead of looking for libraries because it's not that hard, though. But I wouldn't recommend mine because it's going to change a lot and it's not very object oriented. That also says it's alpha and may change, though.
<aeth>
That does look fairly object-oriented, though. "defcomponent"
bpanthi977 has joined #commonlisp
<|3b|>
for the original question, you can put a closure in a slot, that closes over the instance, and call that...but if you have something iterating over instances, it might as well pass the instance to the function rather than use a closure, and at that point it might as well just be a normal function/method
<|3b|>
maybe if it depends on some other closed over per-instance state that for some reason isn't actually stored in the instance, you would still want to store closures in a slot
<phil_bb>
That's part of it, the other part is that I'll be having back-pointers from each object to the object it's nested in, which could create side-effects in the function if it finds slots to modify dynamically.
<phil_bb>
Undesirable side-effects*
<|3b|>
ECS was my first thought too, though
<|3b|>
they tend to focus on huge #s of entities and/or dynamically adding/removing behaviors frequently, which might not be what you are doing
<phil_bb>
Well I have no clue about gamedev, so... I'll have some big studying to do.
<|3b|>
not exactly gamedev specific, more about "dynamic simulation" of a sort that happens to be particularly common in games, mixed with a sort-of database-and-composition styled OO system
<aeth>
"game" is a bottomless pit because it can be anything from "just prototype with paper and dice, and then port it with calls to RANDOM" to "literally build The Matrix because some people really want realism"
<aeth>
it's thus basically unlimited scope (except it's generally real-time to some extent, but not always, e.g. chess)
rkazak has quit [Ping timeout: 268 seconds]
mauricioc has joined #commonlisp
<phil_bb>
Not going to lie, that's terrifying.
rkazak has joined #commonlisp
toadlicker has quit [Read error: Connection reset by peer]
toadlicker has joined #commonlisp
toadlicker has quit [Read error: Connection reset by peer]
toadlicker has joined #commonlisp
toadlicker has quit [Ping timeout: 252 seconds]
mauricioc has quit [Ping timeout: 260 seconds]
chomwitt has quit [Ping timeout: 248 seconds]
poselyqualityles has joined #commonlisp
akoana has quit [Quit: leaving]
toadlicker has joined #commonlisp
mauricioc has joined #commonlisp
dajole has joined #commonlisp
mauricioc has quit [Ping timeout: 265 seconds]
toadlicker has quit [Remote host closed the connection]
toadlicker has joined #commonlisp
mauricioc has joined #commonlisp
toadlicker has quit [Ping timeout: 252 seconds]
wbooze has quit [Remote host closed the connection]
attila_lendvai_ has joined #commonlisp
mauricioc has quit [Ping timeout: 272 seconds]
wbooze has joined #commonlisp
<dlowe>
phil_bb: it's okay that write code that works without trying to stuff it into an exotic self-modifying system
<dlowe>
*to write
attila_lendvai has quit [Ping timeout: 272 seconds]
rendar has quit [Ping timeout: 272 seconds]
mauricioc has joined #commonlisp
wbooze has quit [Ping timeout: 252 seconds]
rkazak has quit [Ping timeout: 260 seconds]
mauricioc has quit [Ping timeout: 245 seconds]
rkazak has joined #commonlisp
screwlisp has joined #commonlisp
mauricioc has joined #commonlisp
admich1 has quit [Remote host closed the connection]
admich1 has joined #commonlisp
poselyqualityles has quit [Ping timeout: 268 seconds]