<whartung>
The only time I upgraded a machine for a better game performance (among other things) was way back when I went from 133 to 400 for Total Annihilation. So it coul dhandle more units. But even that would be difficult to paralleize because of the dependencies on each other (notably in traffic jams)
* whartung
<3’d Total Annihilation
<aeth>
Even without htop up, I can tell when my desktop's fully using the CPU in a multithreaded way because I can hear the CPU fan when that happens.
<whartung>
most of that cpu went to pathfinding
Pixel_Outlaw has quit [Quit: Leaving]
<whartung>
is that CPU heat or GPU heat?
<aeth>
Definitely CPU. I hear my GPU when playing AAA games. Different sound.
<whartung>
my friends laptop turned in to an air hockey table when compiling Swift. You’d think it would float off the desk...
<whartung>
ok
<whartung>
my mac only has one fan, so I cant say what drives it
<aeth>
In general, simulation(ish) strategy games seem to max out the CPU and recent AAA games tend to max out the GPU
<aeth>
at least ime
<whartung>
yea
<aeth>
(I don't think both would be possible, unless you wrote specifically to the hardware combination and optimized heavily.)
<whartung>
just need 100FPS renderig of your strategy game shooter! :)
orivej has joined #lisp
<whartung>
eye level camera with your foot soldiers attacking Rome!
<no-defun-allowed>
whartung: 144hz or gtfo
<no-defun-allowed>
;; closes (with-sarcasm
* whartung
is happy with 30FPS
<aeth>
no-defun-allowed: 100 FPS logic whether your monitor is 30 Hz or 200 Hz imo.
<aeth>
Don't tie the logic to the rendering rate.
<no-defun-allowed>
fair, no one has reaction times or can process lower than 10ms.
<whartung>
The Starcraft Bots can!
<no-defun-allowed>
#.(joke-about 16-tick-demos)
<jasom>
aeth: do you sometimes render inconsistent state when you do that (i.e. some objects 10ms behind others)?
<jasom>
aeth: or do you double-buffer your state?
<whartung>
I’d think you’d have to snapshot the state, right?
<aeth>
I save the old location and interpolate
<aeth>
iirc
mange has joined #lisp
<aeth>
Oh and 100 fps for logic because its inverse is 10 ms and what you want is (integerp (* 1000 (/ n))) so both measurements are integers imo.
<no-defun-allowed>
nice
<no-defun-allowed>
i have an idea for doing fast bsp visibility but i'm not sure if it'd work
<whartung>
unrelated, are they any good examples of network servers in CL floating around on the net? I’ve seen the http server (Hunchenroot? Is that right?) Just curious if there are others of that ilk I could look at.
<aeth>
In case anyone's wondering about the other numbers... (loop for i from 1 to 2000 when (integerp (* 1000 (/ i))) collect i) => (1 2 4 5 8 10 20 25 40 50 100 125 200 250 500 1000)
<no-defun-allowed>
1 it is.
Kundry_Wag has joined #lisp
<aeth>
Looks like it's 1 and numbers whose only prime factors are 5 and 2. (I ran my factoring function on that list to verify)
<aeth>
Makes sense in base 2 * 5, I guess.
fikka has joined #lisp
impulse has quit [Ping timeout: 244 seconds]
impulse has joined #lisp
<Bike>
1000 = 2^3*5^3, so
<aeth>
1000 is the limit here.
<aeth>
You're absolutely correct, the limit is 2^3 and 5^3, e.g. no 2^4
<Bike>
you can make the fundamental theorem of arithmetic work for you!
<aeth>
(limit in the sense that you can't get better than 1000, not in the calculus sense of the word "limit")
Kundry_Wag has quit [Ping timeout: 245 seconds]
fikka has quit [Ping timeout: 246 seconds]
Kundry_Wag has joined #lisp
<jasom>
whartung: there are several http servers, woo and wookie both come to mind
dmiles has joined #lisp
<aeth>
Bike: I didn't expect the fundamental theorem of arithmetic but I guess I should have expected it as soon as INTEGERP entered
<Bike>
as soon as you try to divide integers it's primality city
<whartung>
thx jasom
<aeth>
Here I was working with periods and frequencies in a real world problem and then suddenly PRIMES
<jasom>
whartung: swank also can listen on a socket
lavaflow_ has quit [Ping timeout: 246 seconds]
Kundry_Wag has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
hypnon has quit [Ping timeout: 244 seconds]
Oddity has quit [Ping timeout: 252 seconds]
<Bike>
usually to get integer crap with frequencies it's harmonics
<Bike>
people are all like one plus one is two, well in my opinion it makes more sense to define two as the octave
energizer has quit [Quit: ZNC 1.7.0+deb0+xenial1 - https://znc.in]
energizer has joined #lisp
<aeth>
Bike: But this is sort of the same problem. With the logic running at 100 ticks a second, some parts might actually only need to run at 50 or 25 or even 1. And this can be determined with a simple MOD
fikka has quit [Ping timeout: 246 seconds]
Oddity has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
orivej has quit [Ping timeout: 246 seconds]
fikka has joined #lisp
saturn2 has quit [Quit: WeeChat 1.0.1]
clone_of_saturn has joined #lisp
clone_of_saturn is now known as saturn2
fikka has quit [Ping timeout: 246 seconds]
fikka has joined #lisp
Jesin has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 252 seconds]
makomo has quit [Ping timeout: 272 seconds]
fikka has joined #lisp
Kundry_Wag has joined #lisp
impulse has quit [Ping timeout: 245 seconds]
fikka has quit [Ping timeout: 245 seconds]
dented42 has joined #lisp
Jesin has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
cross_ has quit [*.net *.split]
funnel has quit [*.net *.split]
phadthai has quit [*.net *.split]
kqr has quit [*.net *.split]
spacepluk has quit [*.net *.split]
rgrau has quit [*.net *.split]
ccl-logbot has quit [*.net *.split]
_death has quit [*.net *.split]
sbryant has quit [*.net *.split]
GGMethos has quit [*.net *.split]
sshirokov has quit [*.net *.split]
pankracy has quit [*.net *.split]
AdmiralBumbleBee has quit [*.net *.split]
lowryder has quit [*.net *.split]
aindilis has joined #lisp
AdmiralBumbleBee has joined #lisp
sbryant has joined #lisp
sshirokov has joined #lisp
spacepluk has joined #lisp
dmiles has quit [Ping timeout: 246 seconds]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
it3ration has joined #lisp
shifty has quit [Ping timeout: 272 seconds]
fikka has joined #lisp
vydd has quit [Ping timeout: 244 seconds]
jinkies has quit [Remote host closed the connection]
dented42 has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
lavaflow_ has joined #lisp
fikka has joined #lisp
lavaflow_ has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 250 seconds]
lavaflow_ has joined #lisp
anewuser has quit [Ping timeout: 244 seconds]
regreg has joined #lisp
aindilis has quit [Remote host closed the connection]
Hu0p has quit [Quit: See You Space Cowboy. . .]
atgreen has joined #lisp
aindilis has joined #lisp
dddddd has quit [Remote host closed the connection]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
ebrasca has quit [Read error: No route to host]
lnostdal has quit [Ping timeout: 272 seconds]
PuercoPop has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
lnostdal has joined #lisp
<stacksmith>
Is there a foreign pointer validation function in CFFI? To check if dereferencing would crash...
esrse has joined #lisp
fikka has joined #lisp
<Bike>
cffi with valgrind sounds pretty exciting.
<Bike>
which is to say, no.
<Bike>
it's C. you'll have to arrange things to not crash.
Kundry_Wag has joined #lisp
<stacksmith>
I was hoping for a less-than-perfect validation - like check if it's in-range for any areas allocated with CFFI. But yeah, that was wishful thinking.
lnostdal has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 252 seconds]
oni-on-ion has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
atgreen has quit [Ping timeout: 244 seconds]
equwal has joined #lisp
Roy_Fokker has quit [Quit: Leaving]
fikka has joined #lisp
dented42 has joined #lisp
shifty has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
lnostdal has joined #lisp
asarch has joined #lisp
fikka has joined #lisp
lnostdal has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 252 seconds]
pierpa has quit [Quit: Page closed]
eschulte has quit [Ping timeout: 240 seconds]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
pierpal has joined #lisp
fikka has joined #lisp
dale has joined #lisp
impulse has joined #lisp
atgreen has joined #lisp
<aeth>
it would exist if there was enough people using it.
<Bike>
not really
<Bike>
you wanna pass around arrays with lengths on them? it's _C_
<no-defun-allowed>
no, this is the right channel, stacksmith was asking about bounds checking for cffi arrays
<beach>
Ah, so wrong channel. :)
<no-defun-allowed>
that's still the wrong channel?
<beach>
I should be quiet. Whenever I complain about the fact that half of the contents here is about other languages, I am told that I am wrong to complain.
<no-defun-allowed>
no, please don't, if that's off topic i'll stop
<beach>
People tell me it is on topic.
<no-defun-allowed>
i'm not even sure at this point
<beach>
I personally think we should talk about Common Lisp, but again, I should be quiet.
<no-defun-allowed>
that makes sense, this is #lisp
lavaflow_ has quit [Read error: No route to host]
lavaflow_ has joined #lisp
it3ration has quit [Ping timeout: 252 seconds]
<no-defun-allowed>
are there any good implementations of unordered sets that can be looked up in less than O(n) time?
pierpal has quit [Remote host closed the connection]
<beach>
no-defun-allowed: Sets are weird.
<beach>
no-defun-allowed: All discussions of sets in the CS literature are about special subclasses of sets.
<beach>
no-defun-allowed: And that's because there is nothing better than O(n) in the general case.
<beach>
It all depends on what your domain elements can handle.
<no-defun-allowed>
what about something like binary trees?
<beach>
That requires an order.
<beach>
It requires that your elements can handle <.
<no-defun-allowed>
sorry, less than O(n) on average
<no-defun-allowed>
what about using sxhash to hash the elements first?
<beach>
If your elements can be hashed, then you can use a hash table.
<no-defun-allowed>
are hash tables fast in CL? the clhs requirements aren't very strong
<no-defun-allowed>
can i be sure it's not just using an assoc list internally?
<beach>
If your keys are simple and you have a lot of elements, then they are typically better than lists.
<no-defun-allowed>
good good
<beach>
You can't be sure of anything because the standard doesn't say.
fikka has joined #lisp
<no-defun-allowed>
that's what i was thinking
dented42 has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
dented42 has quit [Client Quit]
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
APic has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
emaczen has quit [Remote host closed the connection]
APic has joined #lisp
Kundry_Wag has quit [Ping timeout: 272 seconds]
laqq3 has quit [Quit: Leaving]
fikka has joined #lisp
it3ration has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
Oddity has quit [Read error: Connection reset by peer]
dented42 has joined #lisp
it3ration has quit [Ping timeout: 244 seconds]
igemnace has joined #lisp
<White_Flame>
no-defun-allowed: a rule of thumb from other languages is that around 10 elements is where hash tables tend to get faster than iterating a list. I would suspect CL's tradeoff (again, for simple keys that dont' take forever to hash) would be in the same ballpark
Oddity has joined #lisp
<no-defun-allowed>
right
equwal has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
bradcomp has quit [Ping timeout: 245 seconds]
Kundry_Wag has quit [Ping timeout: 246 seconds]
sauvin has joined #lisp
fikka has joined #lisp
rozenglass has quit [Remote host closed the connection]
<aeth>
But don't micro-optimize
<aeth>
Feel free to have a 5 element hash table or a 20 element plist/alist
fikka has quit [Ping timeout: 252 seconds]
<aeth>
even if a plist is slightly faster at 3-5 elements, I didn't notice it last time I benchmarked it because both are just so fast.
anewuser has quit [Quit: anewuser]
<aeth>
I'd personally say hash-table vs. plist is whatever semantically seems to make more sense for a few elements. Above a few dozen, use a hash-table unless you're only sequentially iterating over it with something like alexandria:doplist or you're in a macro (where you're probably sequentially iterating over it anyway).
<LdBeth>
hello
<beach>
Hello LdBeth.
emaczen has joined #lisp
kushal has quit [Remote host closed the connection]
<cobax>
what is the most current orthogonal persistence library for CL?
<Shinmera>
depends on what you mean by "current"
<cobax>
I read that AllegroCache is the most advanced and reliable today?
<Shinmera>
Again, depends on what you need.
fikka has joined #lisp
<cobax>
I want something that will allow me to use it instead of an RDBMS
<cobax>
it seems that PLOB! is the GOODS of CL and AllegroCache is the Gemstone/S of CL?
<cobax>
Shinmera: any names you can throw at me would be appreciated, so I can read up some more on the alternatives
<Shinmera>
I'd just use Postgres, so I have no advice for pure-cl solutions
asarch has quit [Quit: Leaving]
<cobax>
Shinmera: ah, ok. I'll use Postgres when it's inside CL. :)
<White_Flame>
if by "orthogonal" you mean transparent, that model tends to be underrepresented because it's quite difficult and usually doesn't work well
<cobax>
That is what I mean, yes. Difficult to whom, is the question. Postgres is quite easy for its programmers but hard for whomever needs to install and maintain and deploy it. On the other hand...
<White_Flame>
if the object model is integrated with the OS itself in a fully persistent address space like some mainframe & experimental OSes, then it would work better. But application-level, not really
fikka has quit [Ping timeout: 252 seconds]
<cobax>
White_Flame: I'm not sure all that is needed. Ruby doesn't have that and there is Maglev for it.
<aeth>
Lispers seem to prefer just representing SQL as s-expressions (nothing is stopping someone from writing an SQL database in CL, though)
<aeth>
(to all of the alternatives, not just the ones you're mentioning)
xrash has quit [Ping timeout: 244 seconds]
<cobax>
aeth: Like Picolisp, I like what it did with embedding a db
<Shinmera>
A good sql database is hard, so pg is really the easiest and best choice
quipa has quit [Ping timeout: 250 seconds]
<White_Flame>
cobax: well, if you just want persistence without performance, then it wouldn't be hard to pull off
<Shinmera>
persistence alone has lots of libraries already
<Shinmera>
though typically as an object-store, not an rdbms
<cobax>
So now you know I'll be abusing whatever persistence library as a replacement for an RDBMS (I don't care about performance and joins) then what are the current persistence libraries?
<White_Flame>
and glancing at maglev, it seems to be transactional, so not really transparent
philosau1 has quit [Ping timeout: 260 seconds]
<Shinmera>
I use ubiquituous for very simple persistence stuff
<cobax>
White_Flame: does that differentiation help in finding a CL equivalent?
<White_Flame>
well, honing into what you want changes what sort of equivalent to look for
<cobax>
White_Flame: the angle I'm coming from is, Lisp is image-based, but how can I take easy/comfortable advantage of this fact, to make small apps without a database, by persisting my environment, like Smalltalk does?
<White_Flame>
image-based means the RAM footprint
<White_Flame>
it's like suspending an OS
<White_Flame>
so certainly on exit of your application, you can have it save the image & exit, and your startup script would resume from that image
<White_Flame>
these are implementation-specific, so it won't be in the CL spec
<White_Flame>
but if you crash, the saved image's heap wasn't constantly updated with your running heap or anything
<cobax>
Ok, so tell me where I'm wrong here, then an easy way to make a prototype website with db functionality but without postgres, instead relying on CL's image-based-ness, then I can deploy a CL app and take a snapshot every 24 hours for data backup?
<cobax>
and just keep data structures in memory?
<White_Flame>
CL's image-based-ness is nothing like a standard database
<White_Flame>
if you want DB-like functionality, then use a DB
<cobax>
I hope not!
<White_Flame>
if you want to use CL images, then that's taking manual snapshots of the entire CL runtime
<cobax>
I don't know what you mean by "DB-like functionality". an RDBMS has several aspects to it. For instance, I don't need the fact that it's relational.
<cobax>
nor that I can search in joins
<White_Flame>
images also won't help you with datasets that get larger than RAM
<cobax>
Well, the OS does that
<White_Flame>
(and/or your GC max heap size setting)
fikka has joined #lisp
<White_Flame>
SBCL, for instance, has SAVE-LISP-AND-DIE as its only image writing function (as far as I'm aware). I don't know how well other systems deal with saving an image but not exiting
<White_Flame>
because bundling that all up for a resumable disk state sometimes involves closing stuff out
<White_Flame>
most deployed Lisp images don't constantly re-save themselves; they're like standard deployed applications where the image on disk starts up adn then reads its application data from other files/DBs
<White_Flame>
but you can certainly try an image-based application persistence model. I don't think there's anything preventing it; it's just uncommon
<White_Flame>
especially if you're fine with it restarting every 24 hours for snapshotting & flushing purposes
<cobax>
White_Flame: I see... I would be, yes...
regreg has quit [Remote host closed the connection]
<cobax>
White_Flame: I have many books on Lisp and its implementations and it seems as if the "image-based" aspect is less explored than in smalltalk, would you agree?
<cobax>
for instance, even Picolisp seems to be ahead of Common-Lisp in terms of a rich image-based-ness?
<White_Flame>
it was more useful in ye olde days where reinitializing everything would take way too long
<White_Flame>
nowadays, you can cycle in a fresh Lisp image, load & initialize all your code in seconds
<aeth>
yeah
<aeth>
any time there's something complicated like with packages I'll just restart the image
<cobax>
White_Flame: I understand, but you see, then an advantage is lost, namely the ability to exploit the image-based-ness for purposes of long term storage
<aeth>
faster even if it's possible to work around
<White_Flame>
right, or when you rename a bunch of stuff in refactoring
<White_Flame>
cobax: most people store long term data as data, not all wound up as artifacts inside a runnable Lisp heap
<White_Flame>
especially if you save non-executable images, the image format can change across minor versions
<White_Flame>
so that makes long term recovery difficult
<White_Flame>
the more plain data is, the more useful it will be long-term
<cobax>
White_Flame: I understand. But I am interested in exploring this road not taken.
<cobax>
I think it starts with good serialization. what is the best CL serializer, is what I should seek next.
<aeth>
You probably don't want to leave an image up too long in development because you can have bugs with "stale" functions. I think the most common one is when you rename foo to foobar, but don't change all calls to foo. (1) calls to foo will no longer get your updates to foobar and (2) your program will not start in a fresh image
<White_Flame>
cobax: I never use general serializers, because I always end up wanting to serialize closures
<cobax>
aeth: that's fine, as I said I am ok with restarting the image every 24 hours
<aeth>
Now embed a db in an image and this sort of thing becomes a lot more common, where you cannot get to where you are from a fresh start
<aeth>
well, in the most literal way. serialization is fine
<cobax>
for instance, think of cl-swap-file and clufs, if I store serialized lisp objects there, I pretty much have an object data base, no?
mange has quit [Remote host closed the connection]
frgo has quit [Ping timeout: 246 seconds]
<White_Flame>
reading their blurbs, it doesn't soudn like they serialize
<White_Flame>
but I haven't used them
scottj has quit [Quit: leaving]
* White_Flame
is afk
<cobax>
ok, so help me out, and I appreciate all this help so far, and understand you are away from keyboard now, but...
<cobax>
if I have serialization of the objects I'm interested in storing, and I have a pure common-lisp file system / swap thing like clufs, then I have an object database for the objects I care about?
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<cobax>
in other words, do I have orthogonal persistence for those objects I care about?
quipa has joined #lisp
vibs29 has quit [Ping timeout: 246 seconds]
vibs29 has joined #lisp
scymtym has quit [Ping timeout: 246 seconds]
igemnace has quit [Ping timeout: 240 seconds]
<MichaelRaskin>
I think you won't get true orthogonality, because long-term-compatible serialisation of functions is not always available.
fikka has quit [Ping timeout: 240 seconds]
zigpaw has joined #lisp
<zigpaw>
morning everyone :)
<cobax>
MichaelRaskin: I'm not sure I get it
orivej has joined #lisp
jlarocco has joined #lisp
<MichaelRaskin>
Well, if you ask for transparency and don't list any limitations, there is a question can a slot value be a function. Or maybe even a class reference
<cobax>
MichaelRaskin: Ah, yes I understand that difficulty, but yet the few orthogonal transparency (or near that) solution I've seen for Smalltalk all do that without problems
<cobax>
I believe because Smalltalk is somewhat continuation based, but I could be wrong
Kundry_Wag has joined #lisp
fikka has joined #lisp
mingus has quit [Read error: Connection reset by peer]
<cobax>
If I may paste this here for reference, this is how maglev / gemstone serializes things:
<cobax>
"Ruby classes are stored as bytecode in the stone server, which is transported via shared memory for local connections, and via optimized binary protocol for remote connections, to the local interpreter and then compiled down to native machine code."
mingus has joined #lisp
<cobax>
so if by serialization we mean down to bytecode, then serializing anything is suddenly doable, including functions but perhaps not class references?
Kundry_Wag has quit [Ping timeout: 244 seconds]
shrdlu68 has joined #lisp
heisig has joined #lisp
<MichaelRaskin>
I guess it all depends on design choices, especially when you take the optimiser into account
<White_Flame>
cobax: the portable way of shipping Lisp code is via source code systems
<White_Flame>
that would be comparable to ruby bytecode bundles
<White_Flame>
but serializing byte code compiled from source code is not equivalent to serializing runtime state
<White_Flame>
again, closure objects and such, not to mention the baseline issue of cross-module object references
<White_Flame>
I do think your problem is underspecified as well, at least from what has been said here
adam4567 has joined #lisp
schweers has joined #lisp
<White_Flame>
looking through the gemstone videos, it points back to what I said before about the object system being integrated all the way down to the running platform (not really OS in this case, but same idea) in order to implement it properly
xificurC has joined #lisp
<cobax>
White_Flame: is it really integration or is it reflection that affords them that?
<White_Flame>
it's right in the byte formatting of object headers and such
<White_Flame>
that's integrated at an incredibly low level
iomonad has quit [Ping timeout: 240 seconds]
<White_Flame>
there are also quite a number of limitations and inflexibilities compared to Lisp objects
<White_Flame>
obviously due to practicalities and speed tradeoffs
<cobax>
wait, but Gemstone allows serialization of objects etc, so they've solved the problem somehow, no?
<xificurC>
I put "yason" into :depends-on in my my-system.asd. Now when I try (asdf:load-system "my-system") it errors with "Component yason not found, required by ...". Obviously I'm doing things the wrong way? I thought depending on a system would make asdf call out quicklisp to fetch the system
<beach>
Nope.
<beach>
You either need to compile your system with quicklisp or call quicklisp manually to install the dependencies.
<beach>
Try (ql:quickload "my-system"). That may work.
<White_Flame>
cobax: they built a database system. They didn't bolt on serialization on top of an existing runtime
<cobax>
White_Flame: exactly!
<cobax>
I came to the same realization. I guess the solution is to start with a database, and put the language I want in control of it
<cobax>
in an integrated way
<White_Flame>
so if you want the same, then build up a Lisp enironment that is a database system
<xificurC>
beach: ql:quickload works, thanks
<White_Flame>
and I mean from scratch, including binary representations of everything
<White_Flame>
because that's what they did
<cobax>
White_Flame: I'm trying to understand, and I really appreciate all your help, but I'm not sure I understand if Picolisp is that or not
<beach>
xificurC: Anytime.
<White_Flame>
I don't know picolisp
<cobax>
oh so that's how they're not that...
<White_Flame>
but it's certainly not a distributed system, iirc
<cobax>
I'm pretty sure it is
<cobax>
does that make it more impressive?
<White_Flame>
gemstone also seems to have some centralized critical points of failure
Kundry_Wag has joined #lisp
<cobax>
"distributed ruby with the maglev vm" is the name of one article. maglev is gemstone. so it's distributed.
<xificurC>
picolisp's database can be distributed out of the box
<cobax>
xificurC: is that so? that is interesting, I have to read more about it
<White_Flame>
how does it distribute function objects?
<White_Flame>
and looking at the docs, "Whenever an external symbol's value or property list is accessed, it will be automatically fetched into memory, and can then be used like any other symbol." this is not library functionality. It's again wound right into the low-level definition of memory access
<White_Flame>
now, certainly this can be done with CLOS, but only with CLOS, not any general slot reference
it3ration has joined #lisp
<xificurC>
White_Flame: picolisp is dynamic, no lexical context to carry. A function is just a list. There's no lambda, just quote, so '((X Y) (+ X Y)) is really just a list, written with QUOTE directly (quote (X Y) (+ X Y))
<White_Flame>
and it's interpreted only, right?
<cobax>
I'm not quite sure I can appreciate, from what you're saying, what is it exactly that low-level integration can afford that very good serialization cannot. The problem is around references, it seems, but I don't get it.
Kundry_Wag has quit [Ping timeout: 240 seconds]
<White_Flame>
cobax: you can't really change how memory references are done in a library. It's part of the fundamental VM
<White_Flame>
that's the only way transparency will be possible
<xificurC>
White_Flame: correct
<White_Flame>
all these systems perform special things on memory reads, loading things transparently
<White_Flame>
as well as detecting whicih arbitrary writes might be part of a transaction
<cobax>
White_Flame: I understand now. So let's call that the last-mile of orthogonal persistency :)
<cobax>
xificurC: can you say a bit more about how being dynamic and not having to carry lexical context can afford Picolisp... what exactly? Distributability of serialized objects the way I am talking about?
iomonad has joined #lisp
it3ration has quit [Ping timeout: 264 seconds]
scymtym has joined #lisp
<White_Flame>
hmm, in picolisp, external symbol names are brace-surrounded disk locations where their data is stored
<White_Flame>
so there's quite a distinction between standard symbols and the persistent ones
<Demosthenex>
so in emacs slime, M-. is bound to slime-edit-definition which fails to jump to my function defs in the same file, but xref-find-definitions works. any suggestions for how to fix it, or shall i just override the keybindings?
<trittweiler>
Did you compile that function?
<cobax>
White_Flame: thank you for the conversation, it has been very useful to me
<White_Flame>
cobax: yeah, hopefully your takeaway is that this sort of thing is not really library functionality. It's fundamental language/runtime functionality
<trittweiler>
xref-find-definitions might just search for a regexp in the current buffer. slime-edit-definition works on source location information stored in your Lisp session
<trittweiler>
so you need to compile/load the function first
<cobax>
White_Flame: yes, and also that it starts from the database up :)
<White_Flame>
cobax: and that there are extreme design considerations for all of these sorts of systems; they're not as flexible as a Common Lisp environment, because they need to support that persistence
<Demosthenex>
trittweiler: i'm editing a buffer that's been completely eval'ed into the running slime session
<Demosthenex>
trittweiler: and the def is two pages back in my source, so a simple backward regexp find easily can find it
<cobax>
White_Flame: I understand the loss of flexibility, but I am fascinated by how we took this path of fragmented development instead of integrated programming systems which in my opinion are more productive
<White_Flame>
whatever you tightly integrate constrains your environemnt
esrse has quit [Ping timeout: 244 seconds]
<White_Flame>
if you integrate flexibility, that tends to constrain speed and vice versa, etc
<Demosthenex>
trittweiler: wait, i just had a thought. my source file is local and my sbcl process is on a remote host. though i did compile and execute the functions in emacs, is slime trying to use the filesystem maybe?
<White_Flame>
if you integrate persistence, that constrains your access & reference patterns
<cobax>
White_Flame: constraints help correctness if they still allow all the same programs to be made, so those are good things, or can be
<White_Flame>
I'm talking about feature & performance constraints, not towards-working-code constraints
<White_Flame>
sometimes when you're constrained you need to write spaghetti in order to implement something mor ecomlex, and that doesn't help correctness at all
<White_Flame>
*more complex
<cobax>
I understand, and to me the interesting aspect is precisely the productivity of integrated environments
<White_Flame>
"integrated" is very overloaded here
<cobax>
no yak shaving, no "outside the environment"
<cobax>
White_Flame: I agree with you regarding constraints and spaghetti
<White_Flame>
I've written OO systems in limited BASIC environments. The constraints of BASIC didn't help.
<cobax>
but I feel it's worth the trade off
<White_Flame>
and it was very much spaghetti underneath
<White_Flame>
so "integrated" here still doesn't necessarily mean any benefit
<White_Flame>
unless you mean what it's integrated with
<cobax>
White_Flame: the constraints of Gemstone seem to be helping lots of people who keep them employed, so there seems to be a market and people that agree with me that the trade offs are worth it
<xificurC>
cobax: White_Flame was asking how are functions serialized
<xificurC>
cobax: since functions don't carry a lexical context and are not compiled, they are just a list
<xificurC>
cobax: so serialization boils down to serializing numbers, symbols and cons cells
<White_Flame>
certainly Common Lisp meets this definition of "integrated" because it doesn't have modern OS interactions bult in the spec (no threading, networking, process spawn, etc). That means we have to jump through hoops & ad hoc systems to get things done
<cobax>
xificurC: I see, there is no meta information whatsoever. thank you.
<White_Flame>
it has a very inward-facing focus
<xificurC>
White_Flame: indeed persistent symbols are "special" in that regard. But you are able to work with them the same way as with any other symbol
<cobax>
hmm I don't want to talk about specs, I want to stay in the realm of practicality and productivity
<White_Flame>
cobax: right, but that, and "integrated" are very vague
<White_Flame>
specific features have benefits in specific contexts
<cobax>
not vague, I mean integrated like a smalltalk programming system like squeak or gemstone
<White_Flame>
are they more productive in doing mathematical analysis than matlab?
<cobax>
and I want to eliminate the hoops of having to keep maintaining separate things from one's programming language, such as postgres
<White_Flame>
are they better at runtime code generation and metaprogramming than Lisp?
<White_Flame>
s/better/more productive/
<cobax>
White_Flame: no, but they seem to be more productive for CRUD websites than most current development workflows
<White_Flame>
right, so you have a specific context there, of database systems. Many programs don't have databases and don't need those features; any productivity there is contextualized
<White_Flame>
so speaking in absolutes gets off track quickly
<cobax>
right. the context is making websites
<cobax>
that is why I want to focus on the practicalities of making websites for clients.
<White_Flame>
ok, I'm not sure you communicated that before ;)
<cobax>
I did not and I am to blame for that
<xificurC>
websites is vague too, you can have a static no-js website generated from code
<White_Flame>
thre are http servers for Lisp that certainly have a lot of integrated stuff
<cobax>
most clients' websites are not going to be the next Twitter
<xificurC>
no database etc
<White_Flame>
I host fully-JS single page apps that don't talk to the server
<cobax>
xificurC: well, usually clients need some sort of state to be kept
<xificurC>
cobax: depends on what you're building really. There's plenty of places to keep non-persistent state in a website
<cobax>
well, be that as it may, it is usual to have a database, and I think it is more productive to have the most things integrated possible
<xificurC>
if you're building a website that shows a company's portfolio or an association they might not have e-shops and forums and registrations etc. Just a plain old hyperlinked site with no fuss
<cobax>
xificurC: sure, but I don't want to have to switch technologies between clients that want a DB and those that don't... the point is to streamline production
* White_Flame
points back up to his "websites is vague too" quote
<xificurC>
cobax: I was just saying "the context is making website" is still not that clear. Different requirements ask for different solutions. If you need databases, sure.
<cobax>
xificurC: Picolisp seems to be right around what I am talking about
<cobax>
it may be vague but Picolisp seems to understand what I am saying
pjb has quit [Remote host closed the connection]
<Demosthenex>
cobax: don't most websites export state information to the database so the codebase can be considered stateless?
<shrdlu68>
Well well, since I can't define a subclass of a bit-vector, is there another way to create a thing that behaves like a bit vector?
<cobax>
Demosthenex: I wouldn't phrase it that way...
<cobax>
"so that the codebase can be stateless" I don't fully grasp what this means
<xificurC>
cobax: yes, picolisp is more like what you seem to be talking about
<cobax>
xificurC: :)
pjb has joined #lisp
<cobax>
sorry folks I'm just tired of having to fix postgres, redis, this that and the other, I just want to code in a productive environment that doesn't switch my attention off of programming
<cobax>
I don't know how best to phrase that
<Demosthenex>
cobax: your complaint is about integration and systems administration for dependencies then
<xificurC>
sounds like mongodb. /s
<cobax>
Demosthenex: yes and I feel Smalltalk solves this but is too heavy a hammer... and that there should be a lispy equivalent
<MichaelRaskin>
s/PostgreSQL administration/MongoDB data recovery/
DataLinkDroid has joined #lisp
<Demosthenex>
cobax: which is why cloud services are so popular now, you export the care, feeding, administration and ownership to a third party and pay for the priviledge of using it
<White_Flame>
and "it should just work!" for a plethora of use cases, each with their own individual complexities
<cobax>
Demosthenex: you phrased it very well
<cobax>
Demosthenex: nah, you still have to code to that third party API
<cobax>
Demosthenex: that is not what I am saying at all
<cobax>
Amazon's services is not helping me any
<xificurC>
White_Flame: that's the dream of everyone, the world for 2 cents
<Demosthenex>
cobax: you said you were tired of fixing dependent products. i said cloud services allow you to pay for a maintained product.
<White_Flame>
not until we have pretty strong AI will we be able to command machines easily
<Demosthenex>
cobax: instead of having the overhead yourself
<White_Flame>
so until then, it's programming
<cobax>
Demosthenex: well then it's broader than that. having to code against amazon's services doesn't contribute to orthogonal transparency
<Demosthenex>
i am mistaken that one of the advantages of exporting all application state to the DB means that you can use concurrent functional stateless code at the webserver layer?
<xificurC>
cobax: look into picolisp then if it suits your needs
<Demosthenex>
cobax: it's also harsh on the wallet and fosters dependency
<cobax>
xificurC: I am looking at it now thanks to you!
<White_Flame>
cobax: your problem isn't orthogonal transparency. It's something that you think would be a silver bullet to your problems, but I can assure you it isn't
<cobax>
Demosthenex: look at GOODS, it is open source. what I am saying is not Amazon Services, it is things in the direction of Gemstone and GOODS
Kundry_Wag has joined #lisp
<cobax>
maybe "integrated" is not the best word but I don't know what is
<cobax>
I have coded to amazon services, trust me, that is not what I mean
<Demosthenex>
cobax: have a link? ddg is failing
<cobax>
if Amazon had their own Ruby in which I can call an amazon lambda natively, then that is more what I mean
<cobax>
Demosthenex: give me a second
<Demosthenex>
so you want a programming language pre-integrated into a cloud environment where all teh dependencies are handled for you?
<Demosthenex>
cobax: you should compare that to 4gl solutions like openedge progress, ibm's rational 4gl, etc.
Kundry_Wag has quit [Ping timeout: 252 seconds]
<White_Flame>
right, they have a niche they're serving. If you want fully integrated, does-anything, no-config, no-admin general programming, well then wait for AI
<Demosthenex>
seriously, i think you're saying you want an application layer language.
<cobax>
White_Flame: it's interesting, when gemstone released maglev, most of the Ruby community didn't get it either. maybe we're stuck with clunky database code forever
<White_Flame>
not everybody is writing database code
<Demosthenex>
because that's a common thing. 4gl's were popular because appdevs wanted to work in an environment where presentation and storage were already solved. if you use a generic language (python, CL, java, etc) you have to do it all over again yourself, or use a framework
<White_Flame>
and for many, the database interfaces mesh with the transactional level and robustness considerations they need to manage
<cobax>
White_Flame: I understand that. not every language needs to be for everybody.
<Demosthenex>
frankly, i've been struggling to find a surviving 4gl for text apps ;]
<White_Flame>
all of the "hide the details" systems don't break in survivable ways as mature DBMSes. That's why the latter are still aroudn
<cobax>
Demosthenex: everyone that codes for the web should want to "work in an environment where presentation and storage are already solved" no? :)
<cobax>
am I the only one, hahah
<Demosthenex>
cobax: no, i get that. but isn't that why there are so many web frameworks? they are the new 4gl
<White_Flame>
I seriously doubt that any of these "solve" your problems for you
<cobax>
Demosthenex: but like White_Flame said, frameworks will never integrate at the binary level... hence they won't solve this problem
<White_Flame>
they focus on one particular facet of the tech; your engineering work is still to be done on top fo that
<Demosthenex>
cobax: binary level? i must have missed that part
<cobax>
White_Flame: I totally appreciate your point about survivability and breakage. I agree.
<Demosthenex>
my assertion was simply that 4GL's were "most batteries included"
<cobax>
it's another trade-off
<cobax>
Demosthenex: I had seen the term "4gl" but am not too familiar. perhaps there was some boat I missed.
<Demosthenex>
the tradeoff for 4gl style languages is you are bound by the limits the designers made for you
<cobax>
Demosthenex: are there any prominent 4gls for web dev nowadays?
<Demosthenex>
for instance, openedge progress is single threaded for apps and io
<Demosthenex>
cobax: ibm rational is all i can think of, it's really outside my area of expertise
it3ration has joined #lisp
<Demosthenex>
other than the fact i desire a 4gl for terminal apps
<Demosthenex>
but at this point i'd settle for a forms library ;]
<Demosthenex>
because i can't say with enough violent words how poorly i feel about webapps.
<Demosthenex>
the 4gl's i have been exposed to are things customer applications are written in that i've had to support.
<Demosthenex>
so i'm not familiar with their features, other than that they are a 4gl.
<cobax>
Demosthenex: too bad much material on openedge progress is behind a paywall, I'd love to see their REST example
<Demosthenex>
frankly, i haven't ever seen a OSS 4gl outside of the xclip/harbor project, which is a OSS implementation of CLIPPER, an 80's application language
<Demosthenex>
you tend to have to pay big bucks for preintegrated solutions
<Demosthenex>
i wonder what 4gl options lispworks has
<Demosthenex>
because your complaint is not uncommon
<cobax>
ah that's it then! yes, Clarion is there :) that's what I mean then, 4gl, it's a shame we don't do more 4gl...
<Demosthenex>
tada. problem solved.
<cobax>
Demosthenex: what would a 4gl for terminal apps look like? it would make curses first-class somehow?
<Demosthenex>
dbase IV.
<Demosthenex>
old old versions of oracle forms
<Demosthenex>
as/400 forms
it3ration has quit [Ping timeout: 240 seconds]
<cobax>
Demosthenex: oh wow, you've opened up a whole new world for me now
<cobax>
Demosthenex: I feel someone needs to do something about my complaint and currently I am researching solutions that I may bring to the market
<xificurC>
that wikipedia article says the unix shell is 4GL
<Demosthenex>
xificurC: pfft ;]
<xificurC>
let's edit that page :)
<Demosthenex>
i understood 4gl's to integrate common application requirements, db/object integration, reporting, forms interfaces, etc.
<xificurC>
the first fourth generation language was, forth :)
<cobax>
xificurC: I guess it is 4gl if the context is "operating system calls" but then we're stretching the meaning of the term beyond usefulness
<cobax>
xificurC: :))
<Demosthenex>
cobax: 4gl's are really good at making simple apps and for prototyping complex ones
<Demosthenex>
cobax: big apps often outgrow them because of the limitations that integration brings, however, that doesn't sound like your issue ;]
<cobax>
Demosthenex: thanks for the link, I have provided tech support for many dbase applications I suppose! also looks as/400-ish
<Demosthenex>
cobax: thats' definately DOS
<cobax>
that one definitely is, yes
<Demosthenex>
i grew up using Borland products that all had TurboVision for text user interfaces, and that's virtually vanished
<Demosthenex>
i absolutely hate user interface creation, or i'd have made my own curses lib by now.
<cobax>
Demosthenex: well, I just think that today with the processing power we have, we are wasting too much time on rails and jango and postgres when most clients needs would never surpass those integration limitations
<Demosthenex>
cobax: think with the processing power today how much time is wasted on the entire webstack, client and server.
vydd has joined #lisp
<Demosthenex>
mainframes provided a full 4gl experience in 16MB of ram total
<cobax>
Demosthenex: paint this picture for me so I can better understand it, what does Picolisp lack from your ideal dbase/4gl for terminal apps?
<Demosthenex>
i'll have to read up on pico, hold on
shka_ has joined #lisp
<cobax>
Demosthenex: lol that makes two of us tonight browsing their docs
<cobax>
for the first time
<cobax>
so I guess what Picolisp is missing for you is a nice curses wrapper
<Demosthenex>
cobax: their example app with their builtin html application stuff looks pretty simple
<cobax>
I've decided my next project will be in a language with an integrated database and picolisp seems like the suitor
<shka_>
cobax: have you seen manardb by any chance?
<Demosthenex>
cobax: i can't find screenshots for their example html application, link if you find anyone or see one running
<cobax>
shka_: I have seen it mentioned during my research but only in passing
<Demosthenex>
cobax: have you considered itemizing the features you want from a 4gl, and looking at what libraries CL has that can supply those? for instance, at https://cliki.net/web%20framework they discuss libs like bknr which do objects, template, and web presentation
<cobax>
Demosthenex: I haven't found a screenshot either but will let you know
<cobax>
Demosthenex: part of my having this conversation was realizing even which parts are there that I need but did not know about. it has helped me clarify a lot and I think as you said, I need to make a definite list
<shka_>
cobax: thanks
zfree has joined #lisp
<cobax>
I had never heard of bknr, it seems right in the ballpark
<cobax>
"BKNR was seen as not so much a web framework, more a persistent object framework with some web stuff wrapped around it." I love it!
<cobax>
it encapsulates nicely our conclusions here
<Demosthenex>
i think it's funny how the nosql crowd has screamed that SQL is too hard, why does it have to be so difficult to just store my data, without really understanding all the features a database actually offers ...
orivej has quit [Ping timeout: 244 seconds]
makomo has quit [Ping timeout: 252 seconds]
<xificurC>
yason docs say: "Interning strings coming from an external source is not recommended practice." . Is that from a security standpoint? Does INTERN allow arbitrary code execution or something?
Kundry_Wag has quit [Ping timeout: 252 seconds]
<Shinmera>
No, but interned symbols are typically not deallocated
<Shinmera>
so it can lead to heap exhaustion
<xificurC>
Demosthenex, cobax: this page describes a minimal complete application https://software-lab.de/doc/app.html and there's a live version of it for user's convenience here: https://7fach.de/app . un/pass is admin admin
<cobax>
xificurC: noice
<xificurC>
Shinmera: I see, thanks
<cobax>
Demosthenex: good link the first one, I'll pass on clack though
<Shinmera>
otherwise, please keep in mind that picolisp is off-topic
<Shinmera>
so you should move discussion thereof elsewhere
<xificurC>
maybe to #picolisp :)
<cobax>
Shinmera: fair enough. there is a picolisp channel
<Demosthenex>
i'd hate to recommend him to picolisp while in the cl channel ;]
<Shinmera>
I don't know what that is, so
<Shinmera>
There's plenty of web frameworks, dbs, and applications in CL
<Shinmera>
as has already been pointed out
<jackdaniel>
I think that the "plenty" part is a problem here
<Shinmera>
?
<jackdaniel>
i.e when I'm in a supermarket to pick up a toothbrush, I'm a subject of a choice terror
<Demosthenex>
yep. every first year compsci student learns to compose strings and immediately thinks they can make a web framework from templates ;]
<jackdaniel>
if there were only one model I'd be perfectly happy person
<Shinmera>
I wouldn't be
zfree has quit [Quit: zfree]
<Demosthenex>
which greatly pollutes the framework choices
<no-defun-allowed>
my favourite picolisp feature is ('0)
<Shinmera>
How am I supposed to know what you want?
<jackdaniel>
sure, but many people perceive this kind of choice and a necessity to compare things being a terror of choice, it is worth to keep that in mind if you try to figure out "what they want"
<Shinmera>
I could just tell you to use Radiance, but I'm not a salesman, so I won't just suggest it to people without knowing their needs
<Demosthenex>
cobax: picolisp might help, but it feels like a small solution. i've used many programming languages, and i find it difficult to beat CL's ability to hot-reload and debug code, ala SLIME/swank and the repl
<Demosthenex>
Shinmera: a little self promotion never hurts ;]
<Shinmera>
I typically don't do it because it makes me feel uncomfortable
<Demosthenex>
i'm still thrilled i added 3 lines to add lparallel into a slow process yesterday importing records, and was able to max my 8 cores and load in record time.
<Demosthenex>
Shinmera: hate to say it, but top software is often due to salesmanship more than technical quality. look at the whole windows ecosystem
<xificurC>
Demosthenex: why would it be bad to point him to another language *if* that's the correct thing to do? No point chatting with him here if he's not interested
<Demosthenex>
there's no harm in saying "hey, i maintain a web framework, would it help?"
<Shinmera>
"top" how?
<cobax>
Shinmera: if it helps I like these words: "easily and in such a way that they can be used on practically any setup without having to undergo special adaptations"
<Demosthenex>
xificurC: it may be, but it didn't sound like he wasn't interested, just frustrated with the features he needs.
<Demosthenex>
cobax: careful, that's awful close to the description of a "magic bullet" solution
<Shinmera>
I don't care about popularity. I care about solving problems adequately
zfree has joined #lisp
<Demosthenex>
Shinmera: and kudos to you for it. i'm reading your parachute docs atm ;]
<cobax>
Demosthenex: it is a spectrum, right? at one end, a totally integrated environment. at another end, config files and vim in a terminal, forever.
<Demosthenex>
professionally i'
<Demosthenex>
i;ve chaffed for years over popular tech overriding the correct tech
<Demosthenex>
cobax: i'll take config files and a terminal thanks ;]
<cobax>
Demosthenex: I don't think worse is better, as a lisper
<Demosthenex>
cobax: i'm an old fart. the number of "integrated" environments i've outgrown and broken is silly to the point i no longer use them
<shka_>
Demosthenex: that just says you are over 30
<shka_>
:P
<Demosthenex>
shka_: ;]
<cobax>
Demosthenex: I'm an old far who made money doing VB6 apps for clients and it felt good, and I long for that level of productivity
<cobax>
just with lisp :P
<Demosthenex>
cobax: actually... there's your metric for feature parity
<cobax>
Demosthenex: in a way, yes, mutatis mutandi for the web
<Demosthenex>
and my first impression is that you may need a commercial solution
<cobax>
Demosthenex: perhaps, but then that write up I linked, that team outgrew AllegroCache and went manardb
<cobax>
Demosthenex: so maybe, maybe not
<cobax>
I'm open to commercial solutions, definitely
<Demosthenex>
cobax: ok, that said they had to work on every item at once on every node all the time. surely that's not your standard OLTP system
<Demosthenex>
cobax: also, maybe you have a case of premature optimization?
<cobax>
Demosthenex: hah, that makes me laugh.
<Demosthenex>
cobax: you didn't say you wanted to make huge huge apps
<cobax>
If I am optimizing it is for development comfort
<Demosthenex>
cobax: seriously, the writeup's first paragraph says basically they need the whole db in memory at all times, not just accessing a server
<Demosthenex>
then allegrocache sounds very much like what you want
<cobax>
we're programmers, whatever work needs to be done to integrate these tools should be done only once and then spread wide. beautiful stuff.
<Shinmera>
I wouldn't call it beautiful, but it does the job (except when it doesn't)
Kundry_Wag has quit [Ping timeout: 252 seconds]
<cobax>
Shinmera: everything to me is "compared to what?". I think it's beautiful, compared to all the alternatives.
<jackdaniel>
it will be rainy today (unless it won't)
<Shinmera>
cobax: I mean that the way portacle is done is a collection of really gross hacks and kludges that I had to figure out.
<cobax>
Shinmera: as opposed to the collection of really gross hacks and kludges that I have to figure out when no one integrates stuff for me? ;)
<Shinmera>
When you set up an IDE for yourself you typically don't have the requirements that portacle has and which in turn necessitate said hacks
<Demosthenex>
oh, i just found a fields example buried in the croatoan tests
_death has joined #lisp
<cobax>
changing topics, I spent a long time studying Haskell only to now conclude that a good interactive debugger is many more times preferable than the paltry benefits derived from the type checker
<cobax>
does anyone here have a similar experience with being disappointed by types and coming back to Father Lisp?
<cobax>
Now I can finally understand Gilad Bracha.
nsrahmad has joined #lisp
graphene has quit [Read error: Connection reset by peer]
<no-defun-allowed>
yep
graphene has joined #lisp
<cobax>
I believe Erik Meijer also gave up on types? Certainly I've watched some of his presentations where he was openly mocking them
<cobax>
and Alan Kay spoke of the academization of programming, and how Biology does not have the word "Science" in it thew way Computer Science does
<_death>
it has "logy" in it
<no-defun-allowed>
the only real science is visual communication
<_death>
trying to evaluate fields by their names seems childish
Kundry_Wag has joined #lisp
<cobax>
_death: he made the point that Computer Science has "Science" in the name just like "Social Sciences" and some other dubious one that made the point clear
<Demosthenex>
cobax: end user apps rarely have any science, just bling.
<Shinmera>
I fail to see how this is on topic of CL
<cobax>
Demosthenex: I like how you say "end user apps". Do engineers speak of "end user skyscrapers" ? I imagine that is how Kay would answer
<cobax>
"end user bridges"
<cobax>
Shinmera: sorry, I will shut up
Kundry_Wag has quit [Ping timeout: 245 seconds]
steiner has quit [Read error: Connection reset by peer]
<_death>
I think the verisimilitudes guy made a good point.. and his acute-terminal-control library works OK, mostly.. I started using it for some project.. it would make sense to have a TUI library based on it
<Demosthenex>
_death: i think my issue is that while many low level terminal control libs exist, there are no tui environments. there were a few tries to make turbovision work, but they're all dead
<_death>
I know. thing is, it's not a big deal to come up with a basic TUI library.. in the DOS days, everyone wrote their own TUI/GUI libraries anyway
<White_Flame>
but there you had direct screen access, instead of sending terminal commands, too
<_death>
they even used linked lists for everything.. :)
<_death>
White_Flame: it's not very important.. you can easily come up with a "frame buffer" abstraction
<_death>
but it's not even clear that you'd want to do that.. back then you'd still have abstractions like gotoxy and friends
<shka_>
so there is no no-applicable-method-error in the standard?
<_death>
it signals an error of type ERROR
<shka_>
gosh, you are right
<shka_>
well, my question remains the same
<makomo_>
yeah, there's no dedicated condition for it it seems
<beach>
shka_: Correct. There is no such condition.
Kundry_Wag has quit [Ping timeout: 264 seconds]
<shka_>
ok, i think that there should be such error but i can manage
<makomo_>
shka_: you can add a method to that GF though
makomo_ is now known as makomo
<shka_>
yes, i can, but in this case i simply added default implementation that returns nil
<beach>
shka_: You have the right to define a subclass of error and signal that instead.
<makomo>
is one allowed to redefine the default methods provided by the standard?
<shka_>
beach: that's what sbcl does
<shka_>
and rightfully so
<beach>
No, it is still a condition of type ERROR, just a subclass.
<beach>
makomo: ↑
<beach>
makomo: Oh, I think I misunderstood.
<makomo>
yeah, that didn't answer my question :-)
<makomo>
i.e. can i replace the default method that signals an ERROR with my own?
<beach>
makomo: The standard rule is that you must subclass one of the arguments.
<beach>
So here, you must subclass GENERIC-FUNCTION and specialize your method to that new class.
<jackdaniel>
from other "the more you know" things if you create a handler-case you may want to handle serious-condition (which error inherits from), not error
<no-defun-allowed>
i had a need to make a readable signature generator kinda thing for hand checking diffie-hellman keys
<jackdaniel>
some conditions are not errors still you want to "catch" them (i.e timeout is not an error, same goes for out of memory)
<makomo>
beach: so it's forbidden by the standard to replace the default method, right?
<beach>
19. Defining a method for a standardized generic function which is applicable when all of the arguments are direct instances of standardized classes.
<_death>
Demosthenex: I think I already mentioned that some years ago I started writing bindings for it.. but my conclusion was that tvision's API was too convoluted because it adopted old C++ "OO" dogmas of the day (lots of inheritance and needless interaction within hierarchy levels) and a Lispy interface is too much work for too little
<_death>
Demosthenex: I think it's better to start afresh.. may have turbovision look and feel if you like
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
dddddd has joined #lisp
<Demosthenex>
_death: i could see that, but it's a shame to discard the architecture. i'd work on one, but i have so little experience with user interfaces that it'd come off shoddy
<_death>
well, I started a simple general purpose TUI thingy not long ago.. I touch it infrequently but at some point it will be good enough for Microsoft GitHub :)
<_death>
it's also based on that acute control library, so there's no need for FFI
<Demosthenex>
i don't care for github myself. i don't normally post code so i hadn't looked for an alternative, but i'm using hg and fossil
Misha_B has joined #lisp
steiner has quit [Read error: Connection reset by peer]
fikka has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
eschulte has joined #lisp
eschulte has quit [Client Quit]
eschulte has joined #lisp
heisig has quit [Ping timeout: 272 seconds]
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Lycurgus has joined #lisp
fikka has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
pjb has quit [Ping timeout: 252 seconds]
it3ration has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Essadon has joined #lisp
it3ration has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
atgreen has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
LiamH has joined #lisp
nsrahmad has quit [Remote host closed the connection]
lavaflow_ has quit [Ping timeout: 240 seconds]
suskeyhose has joined #lisp
Kundry_Wag has joined #lisp
zfree has quit [Quit: zfree]
Kundry_Wag has quit [Ping timeout: 272 seconds]
warweasle has joined #lisp
akovalenko has joined #lisp
cl-arthur has joined #lisp
arbv has joined #lisp
Kundry_Wag has joined #lisp
vtomole has quit [Ping timeout: 252 seconds]
Kundry_Wag has quit [Ping timeout: 240 seconds]
Bike has joined #lisp
warweasle is now known as warweasle_afk
fikka has quit [Ping timeout: 246 seconds]
steiner has joined #lisp
cage_ has joined #lisp
Xof has quit [Ping timeout: 272 seconds]
stux|RC-only has quit [Ping timeout: 240 seconds]
anunnaki has quit [Ping timeout: 272 seconds]
earl-ducaine has quit [Ping timeout: 272 seconds]
Xof has joined #lisp
anunnaki has joined #lisp
stux|RC-only has joined #lisp
pjb has joined #lisp
atgreen has joined #lisp
<xificurC>
I have malformed json, there's a \- sequence which falls through an ECASE in both cl-json and yason. The json output isn't mine and cannot change it. What would be the best aproach to combat this? There's no reasonable restarts provided since they are just an ECASE. Maybe I can wrap the stream in a stream that corrects this sequence?
fikka has joined #lisp
Kundry_Wag has joined #lisp
schweers has quit [Ping timeout: 250 seconds]
veinosaurus is now known as veinofhavit
Kundry_Wag has quit [Ping timeout: 240 seconds]
jlarocco has quit [Ping timeout: 252 seconds]
it3ration has joined #lisp
asarch has joined #lisp
dale has joined #lisp
<Shinmera>
Fix them to provide the necessary restarts
<dlowe>
xificurC: the usual thing is to use regexes to fix your crummy data to fit into the parser
cage_ has quit [Remote host closed the connection]
<dlowe>
usually the data is consistently bad in a way fixable by munging the text
it3ration has quit [Ping timeout: 244 seconds]
koenig has quit [Ping timeout: 276 seconds]
cage_ has joined #lisp
koenig has joined #lisp
jlarocco has joined #lisp
fluxit has quit [Quit: ...]
<Shinmera>
hacking in a restart to skip a char and continue seems easier and more robust to me
fluxit has joined #lisp
<Demosthenex>
i like that idea
<Demosthenex>
though i'm more likely to fix the data before it gets to the aprser
xrash has joined #lisp
jlarocco has quit [Ping timeout: 252 seconds]
eschulte has left #lisp [#lisp]
<dlowe>
Shinmera: there are likely more errors than that.
pjb has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
kuwze has joined #lisp
regreg has joined #lisp
scymtym has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 244 seconds]
nly has joined #lisp
<xificurC>
skipping that I still get an error (using yason now) later on parsing an object. This seems to be getting a bit weird, e.g. jq parses all lines fine and yason chokes on the first ones. I'm reading a stream with (loop for line = (read-line stream nil nil) ...), that shouldn't alter anything right? Running cmd |& while IFS= read -r line; do jq . <<<"
<xificurC>
$line"; done works on all inputs
warweasle_afk is now known as warweasle
ebzzry has quit [Ping timeout: 246 seconds]
scymtym has joined #lisp
jlarocco has joined #lisp
Kundry_Wag has joined #lisp
fikka has joined #lisp
Tristam has quit [Ping timeout: 245 seconds]
Tristam has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
shka_ has quit [Quit: WeeChat 1.9.1]
jlarocco has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
igemnace has joined #lisp
kuwze has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 244 seconds]
dented42 has joined #lisp
graphene has quit [Read error: Connection reset by peer]
fikka has joined #lisp
graphene has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has quit [Ping timeout: 244 seconds]
graphene has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
graphene has joined #lisp
fikka has joined #lisp
<makomo>
pfdietz: right that is clear -- and now that the body has been fully expanded and the results have been computed, how does the outer macro fetch the results? does this transfer happen via global state or in some other way? you mentioned the inner macros "stashing" the results away, how?
<makomo>
s/how/where/
Kundry_Wag has quit [Ping timeout: 272 seconds]
fikka has quit [Ping timeout: 252 seconds]
<pfdietz>
It has to walk over the expanded form and somehow retrieve it from there. The inner macro will have placed it there in some form the outer macro's function can recognize.
<pfdietz>
"walk" there just means traverse, not code-walker walk.
<makomo>
pfdietz: that's the "additional" walking i'm talking about.
<makomo>
quotes on "walking", not "additional". what the heck is it with the typos today
dyelar has quit [Remote host closed the connection]
<makomo>
pfdietz: i see, but i can't think of any way how it might do that, without affecting the code in the body.
<pfdietz>
Well, the outer macro function can always strip out that stuff once it finds it.
<makomo>
oh, true
<makomo>
so it could theoretically expand into something that's not even valid CL
<makomo>
and then the body fixes it up
<pfdietz>
Or into something that has useless but valid code. (progn (hey-look-at-this (quote ...)) <actual form>)
<pfdietz>
where hey-look-at-this has no side effects
<makomo>
mhm
igemnace has quit [Quit: WeeChat 2.2]
<makomo>
or perhaps a binding for a gensym that's never used
<makomo>
hm ok.
<makomo>
pfdietz: so when passing information top-down, it's possible to do it portably. when passing information bottom-up, i need MACROEXPAND-ALL to fully expand the body?
<pfdietz>
Not sure macroexpand-all isn't also portable.
<makomo>
portable in the sense that it's not within the CL spec
<makomo>
but it is de facto portable, since most implementations have it from what i've seen
<makomo>
yup, that's the library i'm looking at right now
<makomo>
pfdietz: ok, i'll try to apply the technique to my case. thanks for taking the time to explain
<pfdietz>
My pleasure
<MichaelRaskin>
You cannot do it in a fully portable way without at least one caveat
<Bike>
well this library is just a wrapper over implementations doing it
<pfdietz>
Yes
<MichaelRaskin>
That's why I said «fully portable»
<makomo>
MichaelRaskin: hello. this one should be fine since it's not a "user-level" implementation
<makomo>
ah, sure
<makomo>
MichaelRaskin: does the caveat concern the representation of environments? you mentioned it a few days ago but i didn't completely understand
<MichaelRaskin>
Not representation. but inspection
fikka has joined #lisp
<makomo>
MichaelRaskin: also, i wanted to give agnostic-lizard a go but i didn't find any comprehensive explanation of the whole thing. where should i start?
<makomo>
MichaelRaskin: i looked at both the talk and the slides :-)
fikka has quit [Ping timeout: 244 seconds]
housel has quit [Read error: Connection reset by peer]
<MichaelRaskin>
The same page (bottom) contains the proceedings link, there is a write-up there
housel has joined #lisp
<MichaelRaskin>
I do follow the most popular way of writing a code walker, just with a few heuristics to approximate a solution to the impossible problem.
rtypo has joined #lisp
<makomo>
MichaelRaskin: completely forgot to look at the proceedings from 2017, thanks
graphene has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<MichaelRaskin>
There is a brief explanation of the example of impossible problem
graphene has joined #lisp
<MichaelRaskin>
Hm, quite a lot of implementations where trivial-macroexpand-all just ignores the env parameter
<pfdietz>
Which is bad
<MichaelRaskin>
Allegro, LispWorks, CLISP…
<MichaelRaskin>
SBCL/CCL/ECL/ABCL do take the env parameter
shka_ has joined #lisp
<shka_>
good evening
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<pfdietz>
Allegro had really broken environment handling, some years ago.
Jesin has quit [Quit: Leaving]
it3ration has joined #lisp
graphene has quit [Remote host closed the connection]
fikka has joined #lisp
it3ration has quit [Ping timeout: 245 seconds]
akovalenko has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
graphene has joined #lisp
Fade has joined #lisp
shrdlu68 has quit [Ping timeout: 250 seconds]
fikka has quit [Ping timeout: 272 seconds]
akovalenko has joined #lisp
graphene has quit [Remote host closed the connection]
<Xach>
x2/win 6
<shka_>
?
graphene has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
maarhart has joined #lisp
jkordani_ has joined #lisp
<makomo>
hi shka_
maarhart has quit [Client Quit]
Lycurgus has quit [Quit: Exeunt]
jkordani has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
Jesin has joined #lisp
regreg has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 252 seconds]
Inline has joined #lisp
Inline has quit [Read error: Connection reset by peer]
graphene has quit [Remote host closed the connection]
Inline has joined #lisp
graphene has joined #lisp
aindilis has quit [Ping timeout: 240 seconds]
robotoad has joined #lisp
fikka has joined #lisp
regreg has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
<pfdietz>
Is there a way in ASDF to say "if systems FOO and BAR are both loaded, then also load system BAZ"?
<whartung>
why does that make any sense? are you looking for optional configurations?
<scymtym>
there is a system called asdf-system-connections but it caused many problems when i tried it
<pfdietz>
The use case for this is when FOO has some special case handling in case BAR is loaded (for example, defines some methods on classes defined in BAR), but doesn't otherwise require BAR to work.
<Bike>
there's weakly-depends-on, but the manual says not to use it
<pfdietz>
The specific use case was trying to use COVER and finding it didn't work on macros from ITERATE.
<Bike>
and it works a bit differently.
<pfdietz>
I'd want it to work if I loaded FOO before BAR, and also if I loaded BAR before FOO. When the second of the two loaded, BAZ would also be loaded.
fikka has joined #lisp
<Bike>
"We do NOT recommend you use this feature. If you are tempted to write a system foo that weakly-depends-on a system bar, we recommend that you should instead write system foo in a parametric way, and offer some special variable and/or some hook to specialize its behaviour; then you should write a system foo+bar that does the hooking of things together."
<Bike>
says the manual.
m00natic has quit [Remote host closed the connection]
<whartung>
but that sounds to me, pfdietz, that you’re trying to make some kind of “smart”, “universal” project. Why should the “project” figure out what your code needs. YOU know what it needs, and you know what you want it to do. So, do it. If you want BAZ loaded with FOO and BAR, then do that. Why have logic hanging around for BAZ if you’re not using BAR in the first place?
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
mindCrime_ has quit [Ping timeout: 246 seconds]
<pfdietz>
I want to be able to load COVER and have it work, without me (as the user) having to manually specify those dependencies.
<pfdietz>
And I want it to work if I load COVER first.
fikka has joined #lisp
<pfdietz>
And I don't want loading COVER to then cause all those other packages it has interactions with to also get loaded.
fikka has quit [Ping timeout: 245 seconds]
regreg has quit [Ping timeout: 272 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
rumbler31 has joined #lisp
fikka has joined #lisp
rumbler31 has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 272 seconds]
asarch has quit [Quit: Leaving]
<stylewarning>
I wonder if the ASDF folks would be open to having a :LICENSE-FILE option for system definitions
dented42 has joined #lisp
<stylewarning>
That would be monumentally more orderly and convenient---at least for commercial folks---than the paltry license description in the :LICENSE argument.
razzy` has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 272 seconds]
orivej has joined #lisp
nowhere_man has quit [Ping timeout: 252 seconds]
it3ration has joined #lisp
<_death>
the asdf manual gives an example with :license but it's not actually specified in the grammar.. so I guess you could have :license (:file "LICENSE" :executive-summary :MIT)
it3ration has quit [Ping timeout: 240 seconds]
<_death>
or you could have (defclass license-file (static-file) ()) I guess
papachan has joined #lisp
<oni-on-ion>
i do a similar thing to use .cl extension, (defclass cl-file (cl-source-file) ((type :initform "cl")))
<Xach>
oni-on-ion: that is built-in to asdf also.
<oni-on-ion>
yep.
<Xach>
asdf:cl-source-file.cl is the class
<oni-on-ion>
idk. this works for me, i was not sure of the expanded and fully resolved name. although naming the subclass cl-file does not clarify matters
<Xach>
there's also a .lsp version
<Xach>
most of the source i see uses ".lisp" and that's what i prefer, too
sauvin has quit [Remote host closed the connection]
<oni-on-ion>
ohhh i see what you are saying. it is already built in to asdf for .cl , sorry i did not see what you mean.
<oni-on-ion>
meant*
<aeth>
.lsp is because of DOS's limitation
<oni-on-ion>
i've developed a particular interest in ".?l" extensions as of late -- prolog .pl, elisp .el, julia .jl, ocaml .ml - and i did not want CL to be left out. also it is semantically more practical to me when extensions are acronyms rather than full words
<oni-on-ion>
yes. i remember DOS Abuse game, my first exposure to lisp i think. unless i used emacs before this i cant recally
<aeth>
Don't use .LSP on Unix or NT-based Windows because three character file names have a ton of collisions
<aeth>
*file extensions
aindilis has joined #lisp
NB0X-Matt-CA has quit [Excess Flood]
NB0X-Matt-CA has joined #lisp
<oni-on-ion>
yep. i dont think i would anyhow
ravndal has quit [Quit: WeeChat 2.2]
<oni-on-ion>
.pl is the same as perl, already github thinks some of my projects are not in prolog hehe.
ravndal has joined #lisp
<aeth>
It doesn't just go by extension. I've seen some 'Newlisp' and even some *Python* in CL projects as a false identification
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
razzy` has quit [Ping timeout: 240 seconds]
aindilis has quit [Remote host closed the connection]
aindilis has joined #lisp
kooga has quit [Quit: :]
FreeBirdLjj has joined #lisp
varjagg has joined #lisp
FreeBirdLjj has quit [Ping timeout: 252 seconds]
<pfdietz>
aeth: and pre-DOS OSes that also had a limit on the extension length.
<aeth>
Yes, like CP/M
rixard has joined #lisp
zooey has quit [Write error: Connection reset by peer]
kushal has quit [Write error: Connection reset by peer]
kushal has joined #lisp
<pfdietz>
Lots of old DEC OSes. TOPS-10, for example.
zooey has joined #lisp
<oni-on-ion>
aeth: "it" ?
<oni-on-ion>
aeth: ohh, github. yes i've seen that as well
<aeth>
oni-on-ion: Github's language misidentification system
<oni-on-ion>
^_^
rixard has quit [Quit: rixard]
steiner has quit [Remote host closed the connection]
Fare has joined #lisp
rixard has joined #lisp
warweasle has quit [Quit: later]
fikka has joined #lisp
asarch has joined #lisp
fikka has quit [Ping timeout: 272 seconds]
rixard has quit [Quit: rixard]
shka_ has quit [Ping timeout: 272 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
pierpa has joined #lisp
vlatkoB has quit [Remote host closed the connection]
scymtym has quit [Ping timeout: 250 seconds]
<Shinmera>
pfdietz: I added my own system to handle that ASDF case. Essetially it defers evaluation and compilation of specific forms until a specified system is loaded.
<Shinmera>
*my own mechanism
<Xach>
Shinmera: what's your hook into loading?
<Xach>
method? some other hijacking?
<Shinmera>
In radiance all systems that can make use of this deferral must be a subclass of a special system, for which theres an asdf:perform :after method that triggers evaluation
<Shinmera>
you could add a method on the standard asdf:system, but who knows how long that would work for (since upstream could add a method of its own)
nowhere_man has joined #lisp
<Xach>
right. i've pondered doing some straight-up redefinition to add my own hook system.
<Xach>
i don't care if it breaks, since it would be just for me.
<Shinmera>
Typically in radiance you use this optional mechanism to provide extra functionality if an implementation of a certain interface is loaded. Since the interface's symbols are always available even without an implementation, symbol resolution in the optional code is also no problem
kushal has quit [Remote host closed the connection]
kushal has joined #lisp
it3ration has joined #lisp
<pfdietz>
Cool
<Shinmera>
The lack of a proper optional dependency spec in ASDF has always bothered me though. Would make this problem much easier
<oni-on-ion>
can be augmented ?
<Xach>
Well, this does help me in the quicklisp world, because I can statically set the dependencies.
Bike has quit [Ping timeout: 252 seconds]
it3ration has quit [Ping timeout: 250 seconds]
<Shinmera>
Since then you could do something like: throw the optional code into an optional.lisp, then add (when (find "thing" (asdf:already-loaded-systems) :test #'string=) (load (merge-pathnames "optional.lisp" #.*compile-file-pathname*)))
<Shinmera>
or maybe even better in the asdf component o
<Shinmera>
spec something like :if-system :foo
asarch has quit [Quit: Leaving]
<Shinmera>
Xach: downloading the optional deps just in case would probably not be very bad
Chream has joined #lisp
<Xach>
Shinmera: the Old ways of doing it made it hard to discover optional dependencies. a new, explicit way would be ok though.
<Shinmera>
Right.
<Xach>
Like, you might not ever find out that system X required system Y because you never loaded X while Z was also loaded.
<Shinmera>
Well, in any case, I have a looong list of things I want from my own, future build system :)
graphene has quit [Remote host closed the connection]
<jasom>
fwiw quicklisp still has to dynamically resolve dependencies in many cases (one-package-per-file systems come to mind).
graphene has joined #lisp
<Xach>
It doesn't.
<Xach>
That's left up to asdf.
rumbler31 has joined #lisp
nowhere_man has quit [Ping timeout: 272 seconds]
LiamH has quit [Quit: Leaving.]
rumbler31 has quit [Remote host closed the connection]
itruslove has quit [Remote host closed the connection]
rumbler31 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
Lycurgus has joined #lisp
rumbler31 has joined #lisp
adam4567 has left #lisp ["ERC (IRC client for Emacs 24.5.1)"]
<Lycurgus>
slyrus1, in hunchentoot-cgi, how would I go about accessing those server variables that are being processed in lines 79-102 of hunchentoot-cgi.lisp?
<Lycurgus>
oh, I just realized they should be accessible from tbnl
jkordani has joined #lisp
it3ration has joined #lisp
jkordani_ has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
Good morning
it3ration has quit [Ping timeout: 244 seconds]
<Lycurgus>
moin no-defun-allowed
atgreen has joined #lisp
<makomo>
MichaelRaskin: i have a question regarding your 2017 ELS paper. i'm on section 5 which demonstrates the impossibility of a general solution
<makomo>
MichaelRaskin: hm actually, i'll get back to you. let me read the section to the end before asking anything
dented42 has joined #lisp
Fare has quit [Ping timeout: 246 seconds]
Bike has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has quit [Ping timeout: 252 seconds]
pierpa has quit [Ping timeout: 252 seconds]
nowhere_man has joined #lisp
<makomo>
MichaelRaskin: ok. i don't understand this part "We need the lexical environment to depend on the run-time input of the macroexpand-all function, so we need to use eval."
<makomo>
MichaelRaskin: it's not clear to me what it means for the lexical environment to depend on the run-time input of the macroexpand-all function
<pjb>
And you never need EVAL.
<pjb>
NEVER.
<makomo>
MichaelRaskin: when the compiler tries to expand EXPAND-VIA-FUNCTION, it passes it the current environment. this environment contains the 2 gensym-named MACROLETs set up with SET-X1 and SET-X2. then EXPAND-VIA-FUNCTION calls MACROEXPAND-ALL and passes it this environment (so it can clearly see the two MACROLETs)
lavaflow_ has joined #lisp
<makomo>
MichaelRaskin: when MACROEXPAND-ALL goes on to expand the given form, why can't it just augment the environment it got with the new MACROLET setup by the 2nd SET-X2 and pass *that* to READ-X1-X2?
<makomo>
Bike: while walking the form to expand, it starts from the given environment and augments it with any local stuff found within the form
<Bike>
how does it augment?
<Bike>
there's no augmentation in the standard
<makomo>
fug, good point
<makomo>
ok, but what about falling back to MACROEXPAND-1 and MACROEXPAND?
<pjb>
makomo: because in CL, eval doesn't take an environment parameter.
<makomo>
if we assume the implementation uses no non-standard special operators and such, what's the remaining problem
<Bike>
what do you mean falling back
<pjb>
makomo: notice how macroexpand and macros have environment parameters! They're needed and useful!
<Bike>
the problem here is that some lisp environment needs to be passed to read-x1-x2
<makomo>
Bike: wrong choice of words, i meant just using. i.e. our MACROEXPAND-ALL uses MACROEXPAND and MACROEXPAND-1 internally somehow
<Bike>
and that environment needs to have the environment set-x2 sets up and such
<makomo>
oh hm, but then again you have the same problem
<makomo>
right, macroexpand-1 and macroexpand are useless
<makomo>
Bike: so if only one had the ability to augment the environment, would it be possible?
<Bike>
it would be easier
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Bike>
i'm not sure if it would solve all problems
<makomo>
i guess you would still need to write the code walker manually, but that's about it
<makomo>
(let's assume no non-standard special operators :-D)
<makomo>
do any other problems remain?
<Bike>
well, you have to have macrolet bodies evaluated in the lexical environment to
dented42 has joined #lisp
<Bike>
too*
<Bike>
like if you have (macrolet ((a ...)) (macrolet ((b ... (a ...))) ...)) the a has to expand correctly
<makomo>
what's being passed to MACROEXPAND-ALL here? the inner MACROLET?
<Bike>
the whole thing
<Bike>
so macroexpand-all has to produce macroexpander functions for a and b
<Bike>
and the function for b is in an environment including a
<Bike>
i guess you can kind of manage it by eval-ing a macrolet form
<makomo>
oh i see, it needs to construct the macroexpansion functions at run-time
<makomo>
and if A's body uses something from the outer lexical scope (which is not part of the form that was passed to MACROEXPAND-ALL)
<makomo>
even if you had the environment, you wouldn't be able to EVAL the macrolet's body inside of it
<Bike>
well i assume that's the environment passed to macroexpand-all.
<Bike>
i guess that's the real issue, yeah.
<Bike>
i should mention that, as it happens, the old cltl2 had environment operators that could do this.
<Bike>
augment-environment, parse-macro, and enclose
<makomo>
so it's a combination of (1) not being able to augment the environment and (2) not being able to eval something within an environment
<makomo>
Bike: yeah, i read about those today, cool stuff
<Bike>
to get the macro function, you'd parse-macro to get the lambda expression, then enclose to get the function.
<makomo>
sigh, we were so close ;_;
<makomo>
pjb: well sure, but macroexpansion aside, it's still useful for other kinds of run-time evaluation
<Bike>
an implementation kind of has to have things like augment-environment, parse-macro, and enclose anyway, so it's a little weird
pierpal has joined #lisp
<makomo>
such an unfortunate omission imo. it would make CL much more fun
<makomo>
you wouldn't have to dread "the code walker problem" like we have to today
<Bike>
well you'd still have implementation specific special operators to deal with.
<makomo>
right, but those are non-conforming anyway, right?
<Bike>
What? No, they're fine
<makomo>
wasn't it the case that non-standard special operators can only be introduced as a replacement for standard macros, but that the macro's definition has to be kept as well
<Bike>
there's a rule that if an implementation implements a macro as a special operator it still has to provide a macro definition. I don't think there's anything ruling out other special operators.
<makomo>
so adding new special ops is fine? do you have a clhs page for that?
<Bike>
no. mainly i don't remember anything forbidding it.
<makomo>
Bike: yeah, but is there a rule explictily allowing them?
<makomo>
i see
<Bike>
doing so would be kind of annoying.
<makomo>
non-std special ops aside, what about that common FUNCTION extension with NAMED-LAMBDA?
<Bike>
what about it
<Bike>
i mean it's basically an extension to the FUNCTION syntax
<makomo>
is that conforming?
<Bike>
probably?
<Bike>
oh, hey "An implementation can have extensions, provided they do not alter the behavior of conforming code and provided they are not explicitly prohibited by this standard. "
<Bike>
isn't that nice
<makomo>
inb4 non-std special ops are explictily prohibited :-D
<Bike>
i guess it doesn't matter much since the question is whether a code walker is conforming
<Bike>
owell
<makomo>
damn, what a shame
lavaflow_ has quit [Ping timeout: 240 seconds]
<makomo>
MichaelRaskin: i think i understand now. if you will by any chance read the above discussion, feel free to let me know of any details i might have missed.
ealfonso has left #lisp ["ERC (IRC client for Emacs 26.1)"]
johnjay has joined #lisp
pierpal has quit [Ping timeout: 240 seconds]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]