gutter has quit [Remote host closed the connection]
gutter has joined #lisp
drot has joined #lisp
varjag has joined #lisp
<phoe>
because I was amused by one typo on the Internet, today I have peeked into dpANS3 with the intent of replacing the term "compilation" with "complication"
<phoe>
the first terms that come to mind are the optimization quality COMPLICATION-SPEED and the macro WITH-COMPLICATION-UNIT - both very useful
<phoe>
it is also good to know that dpANS discusses this topic in depth - it has a whole chapter dedicated to Evaluation and Complication, where complication semantics are precisely defined
<phoe>
among other things, it mentions e.g. that «The term "implicit complication" refers to complication performed during evaluation.»
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
imode has quit [Quit: Away from the sun.]
solideogloria[m] has quit [Ping timeout: 260 seconds]
hiroaki_ has quit [Ping timeout: 265 seconds]
luckless_ has quit [Ping timeout: 240 seconds]
gaqwas has quit [Remote host closed the connection]
<nij>
This makes me wonder if there are nicer alternatives (of unix utils) in lisp.
<phoe>
if that is what you're asking, you can do the above via #'compose, #'curry, and #'rcurry and other Lisp functions
<phoe>
Lisp is not a language where everything is a stream of text, though, so it would be more verbose than the shell script mentioned in the article
<nij>
I see.
<phoe>
but it's possible to produce such "pipes" via curry/rcurry/compose rather easily
<phoe>
you can also use an arrow macro as syntax sugar for your piping
<phoe>
like, a diamond arrow will make it unnecessary to use curry/rcurry/compose
liberliver has joined #lisp
<nij>
How about uniq, tr, sort..?
nij has quit [Remote host closed the connection]
<phoe>
lisp functions for those
cosimone has joined #lisp
nij has joined #lisp
<phoe>
#'remove-duplicates, #'sort, etc..
<phoe>
I don't think there's a built-in replacement for tr
<phoe>
oh wait
<nij>
Pattern match + transform
<phoe>
you replace stuff with newlines... you can use split-sequence:split-sequence-if-not #'alpha-char-p for that
surabax has joined #lisp
<edgar-rft>
has anybody noticed that the shell script traverses the entire list 5 times in only 6 lines of code? nobody would pay you anything for such a shitty performance
<phoe>
of course they would pay you
<phoe>
it's called unix system administration
<edgar-rft>
run that script on the oxford dictionary and see how long it takes
vegansbane6 has joined #lisp
kaftejiman has joined #lisp
<nij>
edgar-rft: good point xD
<nij>
edgar-rft: That could be a reason why I'm looking for a lisp variant..
<Alfr_>
edgar-rft, tr linear, sort n log n, uniq linear, sed number of arguments. It'll likely take less than a minute on a ten year old machine.
andreyorst has quit [Ping timeout: 264 seconds]
luckless_ has quit [Ping timeout: 240 seconds]
oleo__ has quit [Remote host closed the connection]
luckless_ has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
nij has quit [Remote host closed the connection]
nij has joined #lisp
tychoish has quit [Ping timeout: 260 seconds]
kini has joined #lisp
contrapunctus has joined #lisp
tychoish has joined #lisp
nij has quit [Quit: ERC (IRC client for Emacs 27.1)]
nij has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
bacterio has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
luckless_ has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
luckless_ has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
bacterio has joined #lisp
<edgar-rft>
Alfr_: even if every traversal is linear it's minimum 5 times too slow because only 1 traversal is needed to get the desired result.
<ck_>
phoe already said it, but to expand, it's unix system administration /job security/ :)
amb007 has quit [Read error: Connection reset by peer]
<edgar-rft>
yes, but that answer misses the point of said article
pyc has joined #lisp
amb007 has joined #lisp
<ck_>
have you read the Unix Hater's Handbook?
random-nick has joined #lisp
<edgar-rft>
yes :-)
<ck_>
enough said then, I think ;)
<nij>
I didn't and I should.
skapata has joined #lisp
<beach>
I avoided reading it for the longest time, thinking it was written by disgruntled IBM mainframe users, but it is very good and it is written by people who know what they are talking about, because they saw the better systems that preceded Unix.
<nij>
Wow full of hate!
<beach>
And now it is freely available online, so there is no excuse not to read it.
<nij>
I'm thinking of avoiding reading it too.
<nij>
Is it just hate or is there any proposed solution?
<beach>
The solutions existed when Unix was created.
<nij>
?! which is?
<beach>
They describe those better ways.
<beach>
Twenex, ITS, Multics, Genera.
<lotuseater>
is the book enjoyable to read?
<beach>
Very much.
<lotuseater>
yes i found it via a simple search :)
<ck_>
It's deprecating but very humorous, I would call it realistic in the best way possible
<nij>
beach: should I go back and use those.. multics, genera..?
<ck_>
nij: you can go back in time? take me with you.
<beach>
nij: That would be hard (but not impossible). And no, they have not kept up with things like GUIs and such.
<nij>
:(
<nij>
So what's a practical solution if any?
<phoe>
solution for what exactly
<ck_>
please remind me, practical solution to what problem?
<lotuseater>
those headers for chapters in the table of contents are funny :D
<phoe>
lotuseater: they would have been funny if they weren't so sad
<lotuseater>
ok how do you mean exactly?
amb007 has quit [Read error: Connection reset by peer]
<nij>
I mean.. given that UNIX is so bad.. what should I do?
amb007 has joined #lisp
FennecCode has quit [Remote host closed the connection]
<ck_>
be glad, because it could be worse
<phoe>
lotuseater: the existence of these chapter names hints that there is a reason for their existence, which is that unix had and has its obvious issues that we keep on working around because we can't viably fix them
<beach>
nij: One necessary "solution" would be for universities to hire teachers who are qualified to know that they shouldn't teach the crap they are now teaching, as if it were the greatest possible stuff available.
<lotuseater>
use Linux?
<phoe>
nij: continue using it because all alternatives are worse
<lotuseater>
most people seem to value looks and quantity over usefulness and quality
amb007 has quit [Read error: Connection reset by peer]
<nij>
ck_: will do!
<nij>
Well.. if we have a sane Lisp shell.. we can interact with the computer however we like in Lisp.
<nij>
Wouldn't that solve the problems?
amb007 has joined #lisp
<phoe>
we already do, it's called the REPL :D
<phoe>
the unix shell is not a good generic programming interface though because it's not object-oriented
<phoe>
it has no way of representing complex structure othen than via text, a stream of bytes
<phoe>
even Windows PowerShell is more capable than that nowadays
<nij>
yeah! that's what I'm hoping for :D
<nij>
And I do remember your way, phoe
<nij>
aka to have a Lisp repl on all time. I hope I can master that soon in my life.
<ck_>
"master" and "soon" don't often occur in the same sentence. Good Luck!
<phoe>
it's not about mastering
<phoe>
just keep your emacs window always open and keep your slime repl buffer somewhere in there
<nij>
ck_: haha yeah
<lotuseater>
nij: even when you program stuff with McCLIM you have a REPL in default
<nij>
phoe: I need to get out of my comfort zone as the bashism has "worked" for me. I have to forget them and learn the alternatives.
<nij>
It'd be nice if some tutorial teaches how to use the Lisp way to talk to my machine.
<ck_>
nij: there's a section in the Unix Hater's Handbook about that, too. It features a story by Jamie Zawinski, on how he tried to perform a task with bash but then "came to his senses" (is I think the quote) and wrote some emacs lisp code to do it
leo_song_ has joined #lisp
leo_song has quit [Ping timeout: 240 seconds]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<nij>
ck_: still looking for that section @@
contrapunctus has joined #lisp
<beach>
nij: Unfortunately courses and text books on software-related subjects limit themselves to describing some technique without having an opinion as to whether it is good or bad, nor whether there are better alternatives. The reason for this dismal state of things is that authors and teachers are largely incompetent.
<nij>
In academics each judgement needs to be made inside a framework.
<beach>
nij: Take Tanenbaum and Bos "Modern Operating Systems" that claim that an OS can't be written in a language with automatic memory management. Or that has a description of "processes" without telling us why it was invented or what disadvantages processes have.
<nij>
In our case we need a framework/theory that helps judge which is good and which is bad.
<beach>
nij: Knowledge of the domain being taught or written about would be a good start.
contrapunctus has left #lisp [#lisp]
FennecCode has joined #lisp
<ck_>
nij: page 167.
CrazyEdd_ is now known as CrazEd
CrazEd is now known as Guest9673
random-nick has quit [Ping timeout: 260 seconds]
EvW has joined #lisp
luckless_ has joined #lisp
<nij>
I think I'm using a different version @@
<nij>
Haha I see. It doesn't say how the work is done in elisp.. just says it could be done.
<ck_>
well, the task in question is pretty trivial, how bash needs to spawn additional processes for each entry of some list of filenames is the point of the story
<nij>
How would you do this in lisp?
<beach>
You don't spawn a process for each function executed in Common Lisp.
leo_song_ has quit [Read error: Connection reset by peer]
<beach>
Luckily.
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
<nij>
Oh. You just spawn one process that reads a list of strings, and then start manipulating the strings?
leo_song has joined #lisp
<beach>
nij: Your entire session, from when you start your Lisp system to when you exit it, is one single process.
<beach>
Luckily.
jonatack has quit [Ping timeout: 264 seconds]
jonatack has joined #lisp
random-nick has joined #lisp
leo_song has quit [Read error: Connection reset by peer]
leo_song has joined #lisp
nij has quit [Ping timeout: 260 seconds]
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
Guest9673 is now known as CrazEd
CrazEd is now known as Guest11553
kam1 has quit [Ping timeout: 240 seconds]
kam1 has joined #lisp
lowryder has quit [Ping timeout: 260 seconds]
lowryder has joined #lisp
EvW has quit [Ping timeout: 268 seconds]
luckless_ has quit [Ping timeout: 240 seconds]
luckless_ has joined #lisp
waleee-cl has joined #lisp
luckless_ has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
bgardner has quit [Quit: leaving]
luckless_ has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
dmc00 has quit [Remote host closed the connection]
dmc00 has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
luckless_ has quit [Ping timeout: 240 seconds]
amb007 has joined #lisp
dmc00 has quit [Remote host closed the connection]
dmc00 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
vutral has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
UM-Li has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
aeth has quit [Ping timeout: 264 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
aeth has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
luni has joined #lisp
amb007 has joined #lisp
kam1 has joined #lisp
thmprover has joined #lisp
tich has joined #lisp
tich has quit [Client Quit]
tich has joined #lisp
tich has quit [Client Quit]
galex-713 has quit [Ping timeout: 268 seconds]
galex-713 has joined #lisp
iskander has joined #lisp
kam1 has quit [Ping timeout: 272 seconds]
luckless_ has quit [Ping timeout: 240 seconds]
iskander- has quit [Ping timeout: 264 seconds]
luckless_ has joined #lisp
bmansurov_ has quit [Quit: 👋]
orivej has quit [Ping timeout: 246 seconds]
aartaka has joined #lisp
Oladon has joined #lisp
aartaka_d has quit [Ping timeout: 272 seconds]
kam1 has joined #lisp
jjong has joined #lisp
karlosz has joined #lisp
charles` has quit [Ping timeout: 260 seconds]
luckless_ has quit [Ping timeout: 240 seconds]
vutral has quit [Quit: Connection closed for inactivity]
liberliver has quit [Quit: liberliver]
bitmapper has quit [Quit: Connection closed for inactivity]
luckless_ has joined #lisp
contrapunctus has joined #lisp
<contrapunctus>
Has anyone tried setting "qq " as an Emacs abbrev for "(ql:quickload :|)"? (with | being the cursor) I got it to work in lisp-mode buffers, but not in slime-repl-mode.
UM-Li has quit [Remote host closed the connection]
oxum has quit [Ping timeout: 256 seconds]
Jeanne-Kamikaze has joined #lisp
rogersm has joined #lisp
paul0 has joined #lisp
perrier-jouet has quit [Quit: WeeChat 3.0]
perrier-jouet has joined #lisp
whoawhoawhoa has joined #lisp
notzmv has quit [Remote host closed the connection]
notzmv has joined #lisp
whoawhoawhoa is now known as egp8
kam1 has joined #lisp
<oni-on-ion>
slime has its own shortcut things, with ','
<oni-on-ion>
you may need to add it there ?
_atomik has joined #lisp
EvW has joined #lisp
atomik_dog has quit [Ping timeout: 260 seconds]
luni has quit [Quit: Connection closed]
rogersm has quit [Quit: Leaving...]
Jeanne-Kamikaze has quit [Ping timeout: 260 seconds]
<pve>
contrapunctus: All my slime-repl abbrevs have ended up in fundamental-mode-abbrev-table for some reason. Perhaps a better way would be to somehow enable the abbrevs in slime-repl-mode-hook...
<pve>
hm it looks like your code might be doing something like that already
bitmapper has joined #lisp
fanta1 has quit [Quit: fanta1]
andreyorst has quit [Ping timeout: 256 seconds]
galex-713 has quit [Ping timeout: 268 seconds]
nitrix-mas is now known as nitrix
birdwing has quit [Ping timeout: 260 seconds]
aeth has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
aeth has joined #lisp
iekfkk has joined #lisp
galex-713 has joined #lisp
bisickcor has quit [Ping timeout: 240 seconds]
kam1 has quit [Ping timeout: 260 seconds]
kam1 has joined #lisp
saganman has quit [Ping timeout: 246 seconds]
hnOsmium0001 has joined #lisp
jw4 has quit [Read error: Connection reset by peer]
jw4 has joined #lisp
iekfkk has quit [Read error: Connection reset by peer]
iekfkk has joined #lisp
alanz has quit [Ping timeout: 268 seconds]
kilimanjaro has quit [Ping timeout: 260 seconds]
kilimanjaro has joined #lisp
akoana has joined #lisp
alanz has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
narimiran has quit [Quit: leaving]
ebrasca has joined #lisp
kam1 has quit [Read error: Connection reset by peer]
kam1 has joined #lisp
Oladon has quit [Quit: Leaving.]
EvW has quit [Ping timeout: 258 seconds]
Oladon has joined #lisp
luckless_ has quit [Ping timeout: 240 seconds]
<phoe>
hmmm
<phoe>
I am trying to write down some practices when it comes to validating slot values for instances
gproto23 has joined #lisp
<phoe>
in face of multiple inheritance, too
<phoe>
and how to best minimize the amount of resulting code
gproto23 has quit [Client Quit]
<phoe>
option one is applying proper logic to writer methods and in the Four Horsemen of SHARED-INITIALIZE
<phoe>
option two is applying some validation logic in the slots themselves
luckless_ has joined #lisp
EvW has joined #lisp
<mseddon>
after personally failing with #2 forever, I'd pick #1, although that is naturally going to be a performance tank.
<phoe>
option one generates a lot of boilerplate code, but option two gives no easy way to perform cross-slot validation logic
<mseddon>
that's my issue with #2, you have this little sea of logic that can easily be made inconsistent
<mseddon>
I guess it's about how much and what you want to validate
<phoe>
my issue with #1 is that a lot of boilerplate is required to make e.g. MAKE-INSTANCE slot validation
<mseddon>
yeah, but there are many simple problems that fit trivially into #2, it's just that #1 can become arbitrarily complicated. You need to set yourself some upper bound I think.
<phoe>
basically, inside :AROUND or primary method, you need to manually reconstruct the keyword argument list and explicitly APPLY #'CALL-NEXT-METHOD on it to prevent the incorrect values from being propagated deeper into the instantiation
madage has quit [Read error: Connection reset by peer]
Aurora_v_kosmose has quit [Read error: Connection reset by peer]
<mseddon>
right. that's even scarier
<phoe>
:BEFORE breaks restarts and :AFTER is too late in the instantiation process
<mseddon>
ah whammers and whoppers. always a bit weird imo
Aurora_v_kosmose has joined #lisp
scymtym__ has joined #lisp
<mseddon>
imo, in lisp I'm less scared of boilerplate. since I can abstract it.
<mseddon>
but I'm guessing you've found some nasty edge cases that aren't easily defmacro'd away?
scymtym_ has quit [Ping timeout: 265 seconds]
<phoe>
I'm currently looking for the best ways to solve it before I write my macros
<mseddon>
ah right. yeah, that game is definitely harder.
Aurora_v_kosmose has quit [Remote host closed the connection]
<mseddon>
I mean, surely, validation is quite an open ended problem, both in solutions and your appetite for precision.
madage has joined #lisp
kam1 has quit [Remote host closed the connection]
Aurora_v_kosmose has joined #lisp
kam1 has joined #lisp
aartaka_d has joined #lisp
grobe0ba has quit [Client Quit]
<mseddon>
since I'm assuming you don't need to show that a given STRING can be eval'd and terminate.
grobe0ba has joined #lisp
aartaka has quit [Ping timeout: 260 seconds]
villanella has quit [Ping timeout: 265 seconds]
jonatack has quit [Quit: jonatack]
puchacz has joined #lisp
<puchacz>
hi, bt:condition-wait / bt:condition-notify question please. in Java the pattern is always to notifyAll() which wakes up all waiting threads. then they can check in unspecified order: is it for me?
<puchacz>
how do I do it in Lisp? there are threads waiting to run a lambda, and only one of them will have its lambda on the top of the queue.
<puchacz>
the bordeaux manual says it is guaranteed to wake up at least one thread
<puchacz>
in my case the thread may check - is it my lambda at the top of the queue? no, then I will keep waiting.
jonatack has joined #lisp
aeth_ has joined #lisp
imode has joined #lisp
cosimone has quit [Quit: cosimone]
<puchacz>
actually I know :)
<puchacz>
upon waking up, re-check the condition and if not fulfilled, wake up / notify another thread....
jonatack has quit [Ping timeout: 246 seconds]
<puchacz>
but - the thread I want to wake up may never be notified
jonatack has joined #lisp
aeth has quit [Ping timeout: 265 seconds]
<phoe>
wait a second
<phoe>
there is a specific thread that you want to wake up?
gaqwas has quit [Ping timeout: 240 seconds]
<phoe>
hmmmm, this doesn't look like the proper use of condition variables
<phoe>
like, if you have N threads waiting on a single condition variable, and one of these threads is somehow "special", then it should have its own condition variable
<phoe>
from the point of view of a single CV, all threads waiting on that CV are equivalent
<phoe>
if your thread architecture violates this assumption then your thread architecture might be in trouble
<puchacz>
phoe - I have 2 queues, :interactive and :background. when the lambda finishes, I want to notify thread that has its lambda on the top of the interactive queue, if none, then top of background queue
<puchacz>
it seems that every lambda I put on the queue must be paired with its own condition variable
<phoe>
you have queues of threads?
<phoe>
or rather, these functions are pre-assigned to threads?
<puchacz>
queues of lambdas, so threads that put these lambdas on the queue have to wait
<phoe>
okay - why not wake up a random thread and have that thread try-pop a function from the queue then?
<puchacz>
it is for sqlite access, which is capable of only one transaction that writes.
<phoe>
if any other threads wake up, then they'll find an empty queue and go back to sleep
<puchacz>
phoe - I think you are thinking of a pool of executors, where it does not matter which thread executes any given lambda
<phoe>
yes
<phoe>
if you have a single writer thread, and only it is allowed to execute writes, then it should be a single thread possibly waiting on a single CV
<puchacz>
any thread can write, but only one at a time
<phoe>
it seems you want no CV, you want a lock
<puchacz>
I have a lock so the 2 queues are protected
<phoe>
you want a lock for your sqlite
<puchacz>
not needed
<phoe>
so only at most one thread has the capability to write at a given time
<puchacz>
I also want first-in, first-out, and interactive threads to be served before background threads.
<puchacz>
so I have 2 queues
<phoe>
ohhh. yes, this complicates things - you have some kind of prioritization going on.
<puchacz>
a very simple prioritisation
<phoe>
anything with more than one priority won't be served well by a single lock
<puchacz>
the :background type thread puts itself into :background queue and executes WHILE loop that waits till (and (:interactive queue is empty) (:background queue has this thread's lambda at the top))
<puchacz>
whereas :interactive type thread has this WHILE loop that checks only if (:interactive queue has this thread's lambda) at the top
<puchacz>
so very simple prioritisation
<phoe>
hmmmm
<phoe>
why not actually have a single dedicated writer thread though?
<puchacz>
every time lambda finishes, I grab the queues guarding lock again, and I wanted to notifyAll() like in Java :)
aartaka has joined #lisp
<puchacz>
because I would still have to juggle priorities and do some sort of join
<phoe>
this writer thread can perform this logic
<puchacz>
you see these threads proceed when they are done with sqlite
<phoe>
oh! you need them to block until the given piece of work is done...
<puchacz>
yes
<phoe>
this does sound kinda like like per-thread condition variables
<puchacz>
so if I enqueue (cons threads-lambda threads-condition-variable) it may work
<phoe>
at least I cannot think of anything better
<phoe>
yes, something like that
<puchacz>
if I had Java's notifyAll(), I would be done by now :)
<puchacz>
just wake them all up, and the right one will continue
aartaka_d has quit [Ping timeout: 260 seconds]
<puchacz>
okay, I will try to create condition variables on demand and enqueue them. I take they will be garbage collected, nothing fancy like "reserving OS resource" happening behind the scene?
<puchacz>
ok, no worries - nothing like that in the manual
<puchacz>
so thanks for per thread CV suggestion :)
<phoe>
I guess they're normally collected
<fe[nl]ix>
puchacz: bordeaux-threads apiv2 has a condition-broadcast operation
imode has quit [Quit: Running away from things seems to make them chase you faster. Stupid rubberbanding.]
ajb` has joined #lisp
ajb` has left #lisp [#lisp]
<puchacz>
fe[nl]ix - thanks, checking that
PuercoPop has joined #lisp
<puchacz>
err, is it available?
<fe[nl]ix>
in git
<puchacz>
ok, thanks.
<puchacz>
saves me the trouble of creating condition variables and importantly, choosing the right one to notify :)
Aurora_v_kosmose has quit [Remote host closed the connection]
Aurora_v_kosmose has joined #lisp
gaqwas has joined #lisp
gaqwas has joined #lisp
nullman has quit [Ping timeout: 240 seconds]
nullman has joined #lisp
luckless_ has quit [Ping timeout: 240 seconds]
pve has quit [Quit: leaving]
egp8 has quit [Quit: EXIT]
puchacz has quit [Remote host closed the connection]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
emacs-dwim has quit [Ping timeout: 268 seconds]
luckless_ has joined #lisp
gaqwas has quit [Ping timeout: 246 seconds]
UM-Li has joined #lisp
Aurora_v_kosmose has quit [Remote host closed the connection]