Arcsech has left #commonlisp [ERC (IRC client for Emacs 28.0.50)]
dstein64- has joined #commonlisp
dstein64 has quit [Ping timeout: 260 seconds]
dstein64- is now known as dstein64
jeosol has quit [Ping timeout: 252 seconds]
CrashTestDummy has joined #commonlisp
CrashTestDummy3 has quit [Ping timeout: 252 seconds]
kakuhen has joined #commonlisp
karlosz has quit [Quit: karlosz]
<hayley>
FWIW Bike's definition of parallel (w.r.t parallel assignment) is the undisputed definition of concurrent at least, that there are no happens-before relations that would order one before the other.
<hayley>
Good to see that the bridge works again.
gxt has quit [Remote host closed the connection]
gxt has joined #commonlisp
Qwnavery has joined #commonlisp
<hayley>
Can I do anything to make the SBCL compiler do less optimization somehow? It doesn't appear that the code I generate would benefit from much more type inference, for example.
tyson2 has quit [Remote host closed the connection]
<hayley>
Huh, optimizing for (speed 0) actually affected compile time (which went from 450ms to 250ms), and the drop in execution performance isn't that bad. Somehow I don't seem to write code where it usually does much.
jeosol has joined #commonlisp
sander has joined #commonlisp
CrashTestDummy2 has joined #commonlisp
Psybur has quit [Remote host closed the connection]
CrashTestDummy has quit [Ping timeout: 252 seconds]
karlosz has joined #commonlisp
Everything has joined #commonlisp
waleee has quit [Ping timeout: 260 seconds]
hendursaga has quit [Quit: hendursaga]
hendursaga has joined #commonlisp
<beach`>
Good morning everyone!
beach` is now known as beach
nature is now known as nature2
<lotuseater>
Good morning beach :)
Bike has quit [Quit: Lost terminal]
jealousmonk has quit [Remote host closed the connection]
taiju has quit [Ping timeout: 265 seconds]
pranavats has left #commonlisp [Disconnected: Replaced by new connection]
pranavats has joined #commonlisp
semz has quit [Ping timeout: 246 seconds]
taiju has joined #commonlisp
semz has joined #commonlisp
lisp123 has joined #commonlisp
nature2 has quit [Ping timeout: 265 seconds]
lisp123 has quit [Ping timeout: 260 seconds]
Inline has quit [Quit: Leaving]
lisp123 has joined #commonlisp
Oddity has quit [Remote host closed the connection]
karlosz has quit [Ping timeout: 265 seconds]
<lisp123>
Is there a solution to long (character count) expressions?
<hayley>
Don't write them?
<lisp123>
Usually its a trade-off between abbreviations vs. longer names, e.g. ((find (cadr function-definition) *cl-symbols* :test #'symbol-name-equalp)
<lisp123>
I put that into a COND as a test and now its hard to indent the body of the form since its already so long
<moon-child>
I tend to use short names. But lisp does not favour them
<flip214>
lisp123: or make it a new function
<lisp123>
moon-child: Hmm that might be the best way
<lisp123>
It leads to a lot of whitespace, but I'll experiment to see how it reads
<lisp123>
flip214: Yes, perhaps I should use anaphoric macros (seems a bit too much to define a wrapper around find)
<lisp123>
moon-child: Thanks, so what seems to look good is (find ....
<lisp123>
\n :test ) --> Since the test is optional, it flows better having that on a new line
<beach>
lisp123: Please don't use anaphoric macros. They tend to violate the rules of page 13 of the LUV slides.
<lisp123>
beach: Got it. Thanks
<beach>
The best solution is to have lots of small functions, and occasional macros, so that the total code size is still limited.
<lisp123>
The trade off I am having with small functions is that one has to make an extra step to read what they do, whereas writing in terms of the standard function "inlines" it
CrashTestDummy3 has joined #commonlisp
<lisp123>
In this case, I think it might be a good idea, (defun IS-CL-SYMBOL (sym)), so I will do that -> But I used to have a lot of smaller functions and it felt like I was going through 5 functions to get to the final code
CrashTestDummy2 has quit [Ping timeout: 252 seconds]
<flip214>
lisp123: right. but these additional small functions are a kind of documentation - one that (hopefully) better reflects what happens than comments that are outdated
<lisp123>
As in adding doc strings to these functions vs. writing comments? That sounds interesting
<lisp123>
(have to go afk for bit - thanks all)
<flip214>
lisp123: yes. Small function tend to not change so much, so the docstrings stay current... they might not be used anymore, but that you can find out via xrefs and then delete them.
Cymew has joined #commonlisp
pranavats has left #commonlisp [#commonlisp]
Nilby has quit [Ping timeout: 252 seconds]
CrashTestDummy has joined #commonlisp
CrashTestDummy3 has quit [Ping timeout: 252 seconds]
<lisp123>
Thanks flip214 & beach, I will try that approach now
lisp123 has quit [Quit: Leaving...]
lisp123 has joined #commonlisp
kakuhen_ has quit [Quit: Leaving...]
amb007 has quit [Ping timeout: 265 seconds]
amb007 has joined #commonlisp
john__ has quit [Ping timeout: 252 seconds]
<pjb>
saturn2: strings in python are actuall utf-8 octet sequences…
Lord_Nightmare has joined #commonlisp
<pjb>
saturn2: strings in CL are real vectors of characters.
amb007 has quit [Ping timeout: 265 seconds]
<pjb>
saturn2: as I said, if you want the performance of C (or python), then do what C (or python) does. Don't parse and convert octet sequences into strings. Process the octets directly.
amb007 has joined #commonlisp
<saturn2>
i see
<lotuseater>
pjb: i hope you mean numpy ^^
<pjb>
or indeed, you may also just ffi out to the same libraries :-)
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
<jackdaniel>
and blank lines bring nothing except of noise
<jackdaniel>
if you have long blocks of code you want to "separate" you probably should think about defining a function (i.e in flet, or toplevel)
<lisp123>
jackdaniel: Thanks, the progn was a leftover from a previous code, so I will adjust that. Here I need to keep the parts together due to lexical scoping
<jackdaniel>
your indentation is all bad too
<lisp123>
That was plaster
* jackdaniel
shrugs and gets back to other things
<lisp123>
Ok, looks like the consensus is no line breaks
X-Scale` has joined #commonlisp
<moon-child>
lisp123: (list ',name is not aligned with (vector-to-list
<jackdaniel>
using spaces instead of tabs seems to be a consensus since 2010 or so ,)
X-Scale has quit [Ping timeout: 265 seconds]
<lisp123>
moon-child: Yeah, ignore the indenting :) Question was on line breaks (obviously indenting I can do ;)
X-Scale` is now known as X-Scale
<pjb>
lisp123: you can factorize locally; using flet/labels and macrolet, you can design a local mini-dsl that allows you to express your function code more concisely.
<pjb>
lisp123: you can't deny that ((find-function-name function-definition) …) is clearer and shorter than (find (cadr function-definition) *cl-symbols* :test #'symbol-name-equalp)
<pjb>
lisp123: what's this meaningless cadr???
<pjb>
lisp123: have you seen my mention of defstruct :type list?
<lisp123>
pjb: I agree, so I am redoing that part
<lisp123>
Into smaller functions
<lisp123>
No I haven't
<pjb>
lisp123: similarly, you can use LET to give short aliases locally.
<lisp123>
Yes :)
<lotuseater>
or if needful with symbol-macrolet too
<lotuseater>
is this what others call "private state"? ^^
<pjb>
(let ((v (velocity thrown-weapon)) (dt (game-time-step game)) (x (player-position player))) (+ x (* v dt))) instead of (+ (player-position player) (* (velocity thrown-weapon) (game-time-step game)))
<pjb>
ie what you've been doing for more than ten years in your physics courses!!!
<pjb>
write down the formula (+ x (* v dt)), then assign the value (describe what each variable is), the compute the result.
<lotuseater>
oh pjb, so when you play DOOM or such you fight the demons by throwing the weapons rather than shooting? ^^
<pjb>
Note that there are with-slots and with-accessors to deal with length accessor names too.
<jackdaniel>
(setf v (/ d t)) ; oops, can't bind t :)
<pjb>
lotuseater: when you're out of munitions.
<moon-child>
some-random-package:t
treflip has joined #commonlisp
<lotuseater>
then the game provides me one free using the chainsaw :P
<jackdaniel>
(cl:setf v (/ d t))
<pjb>
jackdaniel: 𝗍 or 𝚝 for example.
<lotuseater>
(symbol-macrolet ((d/dt (/ d dt))) ...) okay not really :D
<pjb>
or (shadow t) (let ((t 24)) (cond ((< t 42) 'ok) (cl:t 'ko)))
<lotuseater>
oh I remember some funny situations when classmates had expressions like log(10)/log(2) and they "canceled" it to 10/2 = 5 ...
<hayley>
"Yeah, this is big brain time"
<jackdaniel>
sin x = n ;; six = 1 ;; math is incomplete
<pve>
lisp123: instead of using blank lines, why don't you separate stuff with cute comments instead ;)
<hayley>
where x ≠ 0
* hayley
docks marks from jackdaniel
<lotuseater>
pjb: most times when i translated some algorithm from TAoCP and Knuth uses t i used c for that instead if it was free. also when parameters are in small and big form like n and N, so I used %N for the big one
<moon-child>
;; this comment intentionally left blank
<lotuseater>
hayley: indeed very big
<lisp123>
pve & moon-child: Don't give me any ideas ;) :D
<lotuseater>
jackdaniel: okay that got me laughing now
<pve>
moon-child: not what I had in mind, but I'll allow it :)
<lotuseater>
pve: like "this is a really interesting comment"? lines that speak about themselves
<lotuseater>
it's the assembler for the guidance computer of apollo
<pjb>
the idea is to use a DSL that allows you to transcribe maths and physics formalae as-is to avoid errors, and let the DSL make the formula translation.
<pjb>
They did that with HAL/S for the Shuttle software.
<lotuseater>
some years ago NASA hired again people who have knowledge of special assemblers
<pjb>
lotuseater: if there's n and N, I'd use a reader macro to activate a case sensitive mode and write down the formula as-is.
<lotuseater>
that's very cool and interesting to me :) thanks
<pve>
lotuseater: Well, I was actually being half-serious. Like if you need to separate code blocks, at least explain why.
<lotuseater>
or some comment like "You seriously read our comments?"
<lotuseater>
pjb: with interesting I surely meant the HAL/S thing
<pjb>
lotuseater: a reader macros can also let you input 2D code like HAL/S
<pjb>
I don't remember, I may have done a POC a few decades ago…
<lotuseater>
yes I thought now from reading the examples that a programmable reader comes in well for that
<lotuseater>
i could set it on my list of my potential experimentation projects
<pjb>
another related funny thing, is that in early computer vision, they used a parser to analyse 2D pictures of 3D scenes, and construct the 3D objects seen.
<lotuseater>
and i bet you have :)
<lotuseater>
sounds exhausting
<pjb>
IIRC, there's an emacs equation editor that let you edit (or at least generate) an ASCII art representation of equations. We'd just need to be able to parse them back.
<pjb>
HAL/S is quite restricted, it just deals with exponents and subscripts (but with several levels, you can write x_k_i^a^b
<lotuseater>
stylewarn⍳ng has such a repo, i like what comes out
<pjb>
E b
<pjb>
S k
<pjb>
S i
<pjb>
E a
<pjb>
B x
<pjb>
would read as (expt (expt (aref x (aref k i)) a) b)
<lotuseater>
i think it must be restrictive, for safety is highest priority and efficiency hopefully the second. and ok, the guidance computer also had few resources
<lotuseater>
wouldn't also be trivial parsing 2D svg math expressions made by TeX
attila_lendvai has joined #commonlisp
pranavats has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
notzmv has joined #commonlisp
lisp123 has quit [Ping timeout: 252 seconds]
lisp123 has joined #commonlisp
cage has joined #commonlisp
moon-child has quit [Quit: !]
srhm has quit [Read error: Connection reset by peer]
srhm has joined #commonlisp
moon-child has joined #commonlisp
<mfiano>
Is the only difference between #'symbol-function and #'fdefinition that the latter is more general in that it also works with '(setf name)? If so, is there any use for the former?
* mfiano
has always used fdefinition. Not sure what symbol-function can do that it can't
rain3 has joined #commonlisp
<mfiano>
Ah I suppose symbol-function works for functions not bound in the global environment.
cosimone has joined #commonlisp
random-nick has joined #commonlisp
lisp123 has quit [Quit: Leaving...]
<Xach>
how could it?
<mfiano>
Yes, I was wrong. I would have to use FUNCTION for that
<mfiano>
So it seems fdefinition can be used in place of symbol-function everywhere
<pjb>
lotuseater: it would be dangerous to try to parse svg, if you expect a certain form of svg (eg. as generated by TeX), because other svg could be parsed giving one expression, but rendered showing another expression.
<pjb>
lotuseater: you'd want to analyze the pixel image instead.
<pjb>
(post-rendering)
selwyn has joined #commonlisp
selwyn has quit [Remote host closed the connection]
selwyn has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<lotuseater>
okay yes i wasn't explicit enough
amb007 has quit [Ping timeout: 252 seconds]
amb007 has joined #commonlisp
frgo has quit [Remote host closed the connection]
frgo has joined #commonlisp
selwyn has quit [Read error: Connection reset by peer]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
selwyn has joined #commonlisp
selwyn has quit [Remote host closed the connection]
selwyn has joined #commonlisp
<jackdaniel>
mfiano: basically fdefinition was introduced /after/ cltl2 to allow accessing functions like (setf foo), symbol-function was left for backward-compatibility
<jackdaniel>
(afair)
cosimone has quit [Ping timeout: 260 seconds]
Psybur has joined #commonlisp
rain3 has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
pve has quit [Ping timeout: 252 seconds]
pve has joined #commonlisp
Lycurgus has joined #commonlisp
treflip has quit [Quit: ERC (IRC client for Emacs 27.2)]
<mfiano>
Yes that is what I read. Voted and passed just before CLtL2
dre has quit [Remote host closed the connection]
Bike has joined #commonlisp
<jackdaniel>
indeed, it is already present in cltl2 (being nitpicky as I am - what I've _meant_ was CLtL2 because I've remembered wrong) ; thanks for correction
azimut has quit [Ping timeout: 276 seconds]
rain3 has joined #commonlisp
kevingal has joined #commonlisp
Josh_2 has joined #commonlisp
attila_lendvai has quit [Ping timeout: 260 seconds]
Devon has quit [Ping timeout: 252 seconds]
Devon has joined #commonlisp
Josh_2 has quit [Remote host closed the connection]
<pve>
I'm having great fun writing cute reader hacks with eclector, but are there any reader hacks that would be genuinely useful?
<pve>
I understand it's not the main point of eclector, but it just makes it so convenient.
Qwnavery has quit [Quit: WeeChat 3.3]
tyson2 has joined #commonlisp
elderK has quit [Quit: Connection closed for inactivity]
rain3 has quit [Ping timeout: 252 seconds]
jealousmonk has joined #commonlisp
cosimone has joined #commonlisp
gxt has quit [Remote host closed the connection]
gxt has joined #commonlisp
doyougnu has joined #commonlisp
Josh_2 has joined #commonlisp
<Josh_2>
Hey
<Josh_2>
If I want to catch all conditions should I use condition or error?
<jackdaniel>
Josh_2: all conditions including style-warning and such?
<Bike>
does that question not answer itself? what are you concerned about?
<Josh_2>
Well
<Josh_2>
I was originally using condition and then pjb mentioned something about how I should use error or serious-condition etc and so I swapped to error
<beach>
pve: We use it to read comments and other skipped material in the editor.
<Josh_2>
needless to say it doesn't work properly now
<jackdaniel>
serious-condition along with errors should catch as well timeouts and storage exhaustion conditions
<beach>
pve: And it is also used to avoid interning symbols arbitrarily, and to avoid errors due to package prefixes of packages that don't exist.
<jackdaniel>
(and other inheriting from it)
<Bike>
Josh_2: well, the question is what exactly you are doing
<Bike>
but most of the time you don't want to handle everything, like jackdaniel said
<Josh_2>
well currently I keep getting an problem where I'm running out of fd's because I have a background thread that is supposed to catch all errors
<beach>
Josh_2: But "all errors" is very different from "all conditions".
<Josh_2>
sure
<Josh_2>
WHy isn't storage condition a subclass of error :angry:
<Josh_2>
that is probably what is causing this, I'll just swap to serious-condition rather than error, that'll probably fix it
<hayley>
A storage-condition is also signalled when you run out of memory.
<Josh_2>
Sounds serious to me
<Josh_2>
I'll try it and see
<hayley>
Do you think any ole error handler will work if you run out of memory?
<Bike>
i don't understand how what fd exhaustion has to do with handling errors
<Bike>
do you open a new fd for everything you handle and then never close it?
<Josh_2>
Bike: What I assume is happening is a condition is sneaking passed my handler-case and causing and its being handled by a restart much higher up, this restart tries to get it to reconnect to the server, this is then done thousands of times and bang broke
<Josh_2>
or the restart isn't happening and its just trying to make thousands of connections which achieves the same thing
<Josh_2>
I've swapped to serious-condition now, hopefully that'll sort it out
<pve>
beach: thanks, those sound totally necessary, more than just useful
<pve>
or I mean nice to have
<beach>
pve: Absolutely. I designed the embryonic version (as the SICL reader) in order to use it to parse Common Lisp code in Second Climacs buffers, but then scymtym took over and made it as great as it is today.
waleee has joined #commonlisp
<Josh_2>
etimmons: I've been playing with 40ants/doc, its very nice.
<Josh_2>
Although I have found the (<name> (method ..)) form to be exceptionally annoying
<etimmons>
Josh_2: the method locative in particular? What about it?
terrorjack has joined #commonlisp
<Josh_2>
Yes the method locative, I just find it to be exceptionally finicky, although I should probably put that down to inexperience more than anything
<Josh_2>
I would copy the examples for say a method like (on-save (method () t)) and I would get an error saying that this method cannot be found
<Josh_2>
despite on-save taking a single argument and being exported
raeda has quit [Read error: Connection reset by peer]
raeda_ has joined #commonlisp
<etimmons>
Huh. It should be (t) instead of t, but maybe that's a transcription error
<etimmons>
And does on-save specialize on t? Or some class?
<etimmons>
Xach: I'd love to have a gray stream extension to salza2 that mirrors chipz's make-decompressing-stream. Is that something you'd like to see added to salza2 or should I make a new project to wrap it?
<Xach>
etimmons: hmm, i think that would be fine in salza2 - using trivial-gray-streams or similar?
<etimmons>
Exactly
<Xach>
if you update the code and docs i would merge something like that.
<etimmons>
salt rock lamp: The lispified wrappers are very much in the experimentation phase, so I can't really recommend using it.
<jcowan>
The modern view seems to mean that "parallel" does mean" "at the same time", in which case let-bindings are better described as concurrent. This view goes back to at least 1968.
<White_Flame>
I always think in terms of dataflow parallelism, not timing parallelism
<White_Flame>
I guess I'm not modern
<jcowan>
Throwing up and catching two balls with two hands is a parallel operation. Juggling three balls with two hands is a concurrent operation.
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
<jcowan>
s/"at the same time"/"using more than one execution unit simultaneously"/
<pjb>
Josh_2: if you get storage-condition, and know what to do about them (eg. free some memory), then catch it. Explicitely, and precisely it. But don't catch other non-error conditions that you don't know, and that other parts of the system may rely catching.
<pjb>
Josh_2: catch storage-condition with handler-bind, it makes no sense catching it with handler-case…
john__ is now known as gaqwas
Devon has quit [Ping timeout: 252 seconds]
Jach has quit [Remote host closed the connection]
Lord_of_Life has quit [Read error: Connection reset by peer]
Lord_of_Life has joined #commonlisp
eddof13 has joined #commonlisp
attila_lendvai has quit [Ping timeout: 260 seconds]
attila_lendvai has joined #commonlisp
selwyn has quit [Read error: Connection reset by peer]
attila_lendvai_ has joined #commonlisp
Spawns_Carpeting has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
attila_lendvai has quit [Remote host closed the connection]
alendvai__ has joined #commonlisp
Lord_of_Life_ has joined #commonlisp
Spawns_Carpeting has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 252 seconds]
rotateq has joined #commonlisp
Lord_of_Life_ is now known as Lord_of_Life
attila_lendvai_ has quit [Ping timeout: 260 seconds]
alendvai__ has quit [Ping timeout: 252 seconds]
akoana has quit [Quit: leaving]
jkordani has quit [Quit: Client closed]
eddof13 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
random-nick has quit [Quit: quit]
random-nick has joined #commonlisp
cosimone has joined #commonlisp
<phoe>
etimmons: :D
<phoe>
glad that I could be of (indirect) service
didi has left #commonlisp [O bella ciao bella ciao bella ciao, ciao, ciao.]
<lotuseater>
ohai phoe :)
Oladon has joined #commonlisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #commonlisp
terrorjack has joined #commonlisp
terrorjack has quit [Client Quit]
frgo has quit [Remote host closed the connection]
frgo has joined #commonlisp
cosimone has quit [Ping timeout: 252 seconds]
karlosz has joined #commonlisp
Nilby has joined #commonlisp
terrorjack has joined #commonlisp
pve has quit [Quit: leaving]
Devon has joined #commonlisp
nature_ has quit [Ping timeout: 252 seconds]
random-nick has quit [Ping timeout: 265 seconds]
tyson2 has joined #commonlisp
<Josh_2>
pjb: gonna catch it with handler-case and throw it straight in the trash
* semz
wonders how reliable the condition system could be in low memory situations
<semz>
Is it legal to preallocate a single storage-condition for this situation and just reuse it every time?
<White_Flame>
the system should at least leave space for creating/handling out of memory conditions, I don't think it's a problem for you to do the same
<White_Flame>
however, it's not just the condition object. Any consing, including during printing, can still be problematic