LainExperiments6 has quit [Ping timeout: 240 seconds]
skin has quit [Quit: Lost terminal]
Alfr has quit [Ping timeout: 260 seconds]
alternateved has quit [Ping timeout: 246 seconds]
chomwitt1 has quit [Ping timeout: 248 seconds]
mwnaylor has quit [Remote host closed the connection]
mwnaylor has joined #commonlisp
rkazak has quit [Ping timeout: 244 seconds]
amb007 has quit [Ping timeout: 248 seconds]
Inline has quit [Remote host closed the connection]
Inline has joined #commonlisp
decweb has joined #commonlisp
Alfr has joined #commonlisp
markb1 has joined #commonlisp
alfiee has joined #commonlisp
alfiee has quit [Ping timeout: 248 seconds]
amb007 has joined #commonlisp
rkazak has joined #commonlisp
waleee has quit [Remote host closed the connection]
waleee has joined #commonlisp
waleee has quit [Remote host closed the connection]
waleee has joined #commonlisp
waleee has quit [Remote host closed the connection]
screwlisp has quit [Ping timeout: 246 seconds]
rkazak has quit [Ping timeout: 248 seconds]
jonatack has quit [Ping timeout: 248 seconds]
mange has joined #commonlisp
ec has joined #commonlisp
alfiee has joined #commonlisp
dajole has quit [Quit: Connection closed for inactivity]
alfiee has quit [Ping timeout: 265 seconds]
rkazak has joined #commonlisp
decweb has quit [Ping timeout: 276 seconds]
jonatack has joined #commonlisp
rkazak has quit [Ping timeout: 272 seconds]
beagles has quit [Ping timeout: 276 seconds]
patrix has quit [Quit: gone]
patrix3 has joined #commonlisp
alfiee has joined #commonlisp
alfiee has quit [Ping timeout: 248 seconds]
rkazak has joined #commonlisp
random-nick has quit [Ping timeout: 265 seconds]
triffid has quit [Remote host closed the connection]
triffid has joined #commonlisp
ColinRobinson is now known as JuanDaugherty
semz has quit [Quit: ZNC 1.8.2+deb2ubuntu0.1 - https://znc.in]
JuanDaugherty is now known as ColinRobinson
rkazak has quit [Ping timeout: 248 seconds]
semz has joined #commonlisp
shmorg83 has joined #commonlisp
robin_ has joined #commonlisp
robin__ has quit [Ping timeout: 248 seconds]
alfiee has joined #commonlisp
Pixel_Outlaw has joined #commonlisp
alfiee has quit [Ping timeout: 248 seconds]
rkazak has joined #commonlisp
shmorg83 has quit [Ping timeout: 245 seconds]
jonatack has quit [Read error: Connection reset by peer]
jonatack has joined #commonlisp
jonatack has quit [Ping timeout: 272 seconds]
rkazak has quit [Ping timeout: 265 seconds]
shmorg83 has joined #commonlisp
jonatack has joined #commonlisp
alfiee has joined #commonlisp
alfiee has quit [Ping timeout: 248 seconds]
rkazak has joined #commonlisp
surabax has quit [Quit: Leaving]
shmorg83 has quit [Ping timeout: 252 seconds]
rkazak has quit [Ping timeout: 248 seconds]
decweb has joined #commonlisp
ebrasca has quit [Remote host closed the connection]
jonatack has quit [Ping timeout: 248 seconds]
bpanthi977 has quit [Ping timeout: 248 seconds]
alfiee has joined #commonlisp
decweb has quit [Ping timeout: 265 seconds]
alfiee has quit [Ping timeout: 252 seconds]
rkazak has joined #commonlisp
thonkpod has quit [Quit: thonkpod]
thonkpod has joined #commonlisp
rkazak has quit [Ping timeout: 252 seconds]
edgar-rft` has joined #commonlisp
edgar-rft_ has quit [Ping timeout: 264 seconds]
rkazak has joined #commonlisp
ColinRobinson has quit [Ping timeout: 252 seconds]
zwr has quit [Read error: Connection reset by peer]
zwr has joined #commonlisp
alfiee has joined #commonlisp
rkazak has quit [Ping timeout: 248 seconds]
alfiee has quit [Ping timeout: 276 seconds]
basicnpc has joined #commonlisp
basicnpc has quit [Changing host]
basicnpc has joined #commonlisp
<basicnpc>
How do I use handler-bind to count errors in a body, and proceed evaluating that body after each error? Something like.. except that 'ignore is note eligible: https://pastebin.com/dut9fqsN
<mange>
You need the code that's raising the error to provide a restart for you. ERROR is intended to never return, you need some spot to continue from when you ignore it. CERROR sets up a CONTINUE restart.
jonatack has joined #commonlisp
<mange>
If the code you're running doesn't have its own restarts then you'll need to wrap parts of it with restarts that allow you to continue execution. Each chunk will short-circuit the code within it, but the outer chunk can count the number of times that happened.
jonatack has quit [Excess Flood]
<basicnpc>
I see.. lemme try it out. Thanks!
cqst has joined #commonlisp
basicnpc has quit [Ping timeout: 248 seconds]
jonatack has joined #commonlisp
rkazak has joined #commonlisp
alfiee has joined #commonlisp
rkazak has quit [Ping timeout: 246 seconds]
wobbol has quit [Ping timeout: 245 seconds]
alfiee has quit [Ping timeout: 248 seconds]
chomwitt1 has joined #commonlisp
pve has joined #commonlisp
bpanthi977 has joined #commonlisp
mishoo has joined #commonlisp
bpanthi977 has quit [Ping timeout: 260 seconds]
alternateved has joined #commonlisp
rkazak has joined #commonlisp
amb007 has quit [Ping timeout: 265 seconds]
UncleRRR has joined #commonlisp
rkazak has quit [Ping timeout: 264 seconds]
Th30n has joined #commonlisp
Inline has quit [Quit: Leaving]
amb007 has joined #commonlisp
alfiee has joined #commonlisp
alfiee has quit [Ping timeout: 246 seconds]
rkazak has joined #commonlisp
jonatack has quit [Quit: WeeChat 4.5.1]
Inline has joined #commonlisp
Pixel_Outlaw has quit [Remote host closed the connection]
igemnace_ is now known as igemnace
bendersteed has joined #commonlisp
rkazak has quit [Ping timeout: 248 seconds]
varjag has joined #commonlisp
jrx has joined #commonlisp
dtman34 has quit [Quit: ZNC 1.8.2+deb3.1 - https://znc.in]
dtman34 has joined #commonlisp
alfiee has joined #commonlisp
tasty has quit [Remote host closed the connection]
<beach>
I mean, why would RATIONALIZE not return the exact rational for a floating-point number?
<beach>
Or, am I missing something?
vardhan has joined #commonlisp
vardhan__ has quit [Ping timeout: 248 seconds]
rkazak has quit [Ping timeout: 248 seconds]
<beach>
Same issue (but different values) in SBCL
<UncleRRR>
Because there are actually no such "exact"?
<beach>
Oh?
<UncleRRR>
it outputs the rational by some kind of calculation instead of internal represantation, where floating numbers are by no way "exact".
<beach>
Every float can be expressed as x * 2^y where x and y are integers, so this is obviously a rational.
<beach>
Floating-point numbers are totally exact. They are a subset of the rationals.
<UncleRRR>
Really? I don't know how can a CL impletation tackles floating point numbers. But there is an old story about 0.1+0.2 not equal to 0.3.
<beach>
That's because there are no exact representations as floats for decimal numbers. It's a totally different issue.
<UncleRRR>
OK, why is 2^(-149) a different issue?
<beach>
When you convert a decimal number to a binary float, you get an approximation of that decimal number. But I am not interested in decimal numbers, nor of conversions.
<beach>
Because that's 1/2^149 which is obviously a rational.
<UncleRRR>
Then more research is required for the possibility of such conversion being performed under the hook.
Inline has quit [Quit: Leaving]
<beach>
I am not interested in conversions between decimal numbers and floats.
<UncleRRR>
If it is not conversed, how could the answer be different:(
<beach>
Decimal numbers are not involved here. Only integers and ratios.
<UncleRRR>
Does smaller numbers show the same "paradox"
<beach>
The conversion from a float to a rational should be a simple matter of multiplying the mantissa (represented as an integer) by 2^e where e is an integer.
<beach>
Not much work required, and the result should be exact.
<ixelp>
CLHS: Function DECODE-FLOAT, SCALE-FLOAT...
Inline has joined #commonlisp
<UncleRRR>
I know it is easy for many machines to * or / 2^? stuff, but it might not be the case for such a large ?. I would like to have a try in sbcl now, lending your code.
<beach>
I really hadn't expected this conversation.
<beach>
What? Rational arithmetic is exact in Common Lisp.
<UncleRRR>
just checking CLHS, you are right. rationalize treats the number only to float point precision.
alfiee has joined #commonlisp
rkazak has joined #commonlisp
<beach>
So that was the real answer to my question: Use RATIONAL and not RATIONALIZE.
alfiee has quit [Ping timeout: 245 seconds]
<beach>
I am also a bit curious as to why CCL does not allow a mantissa of all zeros for LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT, but that's a totally different issue.
<UncleRRR>
Curiousity is awesome, however, it might just not make sence to wonder such implementation detail unless you would like to step in.
<beach>
UncleRRR: So at least I hope you learned something from this conversation.
<beach>
Yeah, that detail is not important to me.
<UncleRRR>
beach: Yes, I learnt that next time something strange happen, I should first check the document for the procedures included instead of guessing aimlessly.
<beach>
And I also hope you learned something about floating-point numbers. Very important!
<UncleRRR>
Thanks, that's indeed useful for anyone interested in computer related stuff!
bpanthi977 has joined #commonlisp
bpanthi977 has quit [Ping timeout: 246 seconds]
chkhd has joined #commonlisp
rkazak has quit [Ping timeout: 245 seconds]
JuanDaugherty has joined #commonlisp
JuanDaugherty is now known as ColinRobinson
rkazak has joined #commonlisp
alfiee has joined #commonlisp
alfiee has quit [Ping timeout: 252 seconds]
chkhd has quit [Quit: Poof...]
tasty_ has joined #commonlisp
tasty has quit [Ping timeout: 252 seconds]
rkazak has quit [Ping timeout: 252 seconds]
chomwitt1 has quit [Ping timeout: 248 seconds]
alfiee has joined #commonlisp
pranav has quit [Remote host closed the connection]
yaneko has quit [Quit: parting]
bpanthi977 has joined #commonlisp
alfiee has quit [Ping timeout: 245 seconds]
bpanthi977 has quit [Ping timeout: 260 seconds]
rainthree has joined #commonlisp
ingeniot has joined #commonlisp
ingeniot has quit [Quit: Client closed]
ingeniot has joined #commonlisp
rkazak has joined #commonlisp
yitzi has joined #commonlisp
<beach>
Sure. And, yes, very useful.
yitzi has quit [Ping timeout: 246 seconds]
rkazak has quit [Ping timeout: 252 seconds]
rainthree has quit [Ping timeout: 246 seconds]
yitzi has joined #commonlisp
alfiee has joined #commonlisp
alfiee has quit [Ping timeout: 252 seconds]
yaneko has joined #commonlisp
yaneko has quit [Client Quit]
yaneko has joined #commonlisp
younder has quit [Ping timeout: 252 seconds]
yaneko has quit [Client Quit]
amb007 has quit [Ping timeout: 265 seconds]
amb007 has joined #commonlisp
m5zs7k has quit [Ping timeout: 244 seconds]
yaneko has joined #commonlisp
random-nick has joined #commonlisp
m5zs7k has joined #commonlisp
rkazak has joined #commonlisp
ingeniot has quit [Ping timeout: 240 seconds]
pranav has joined #commonlisp
yaneko has quit [Quit: parting]
yaneko has joined #commonlisp
waleee has joined #commonlisp
ColinRobinson has quit [Ping timeout: 265 seconds]
<basicnpc>
Is it possible to define something like IGNORE-ERRORS-RECURSIVELY, which collects all errors into a list, and makes each call which signals the error returns NIL, and move on?
bpanthi977 has joined #commonlisp
shmorg83 has quit [Ping timeout: 252 seconds]
<basicnpc>
IGNORE-ERRORS only pick up the first error signaled in the form, but all of the following code after that error is simply ignored. I want the rest to be executed too.
<bike>
you can't resume from all errors. an error that isn't continuable indicates that things are too broken to progress further.
bpanthi977 has quit [Ping timeout: 252 seconds]
decweb has joined #commonlisp
<basicnpc>
I understand. I'd like this only for debugging purposes.
<jackdaniel>
you may define your own condition that does not subclass serious-condition
<jackdaniel>
then, provide a handler above your program that handles this condition by either resignaling an error, saving the condition, reporting it or ignoring (or whatever you want)
<basicnpc>
jackdaniel I don't see how this would let the rest of the code be executed too.
cage has joined #commonlisp
cage has quit [Excess Flood]
<jackdaniel>
or, instead of ERROR, call SIGNAL; that should honor handlers but skip the debugger
<jackdaniel>
wel, if the condition is not a serious condition, then handlers that try to handle ERROR or SERIOUS-CONDITION won't transfer the control after handling them
<jackdaniel>
well*
josrr has quit [Remote host closed the connection]
<jackdaniel>
calling SIGNAL with an error condition on the other hand will invoke matching conditions and possibly transfer the program control, but won't invoke the debugger
rkazak has quit [Ping timeout: 252 seconds]
<bike>
if this is code you control you can use cerror instead of error, and it will return nil if you use the continue restart
<basicnpc>
bike It's not the code I control.
<basicnpc>
EDIT: I don't control the code.
<bike>
you're out of luck then.
rkazak has joined #commonlisp
<basicnpc>
I cannot add an ad hoc restart (that simply records it, forces return NIL, and transfers control back) for each condition that is unhandled and thus bubbled to the top?
<phoe>
basicnpc: how do you want your code to continue after (+ 2 nil)?
rkazak has quit [Ping timeout: 276 seconds]
<jackdaniel>
I'd be more interested for them to elaborate: what is the underlying purpose?
<phoe>
in code like (defun bar () (+ 2 nil) (foo)), FOO is never going to execute, no matter what you do
<phoe>
the error is exactly for you to not be able to continue execution
<phoe>
that's like "how can I make my C program continue after a segfault"
<basicnpc>
phoe In that case, (+ 2 nil) would return nil, and (foo) is executed after that.
cage has joined #commonlisp
<phoe>
basicnpc: that's not how CL works.
<basicnpc>
Yeah, the purpose is to see all errors all at the same time, instead of going through each of them one-by-one.
<phoe>
you can't compute all errors ahead of time
<basicnpc>
This could be useful for writing tests, where I can specify a series of errors for a piece of code that is destined to fail in a series of ways.
<phoe>
you can do it in tests though
<phoe>
you can expect (+ 2 nil) to signal a type-error, for instance
<phoe>
but you can't expect that function to continue afterwards
<basicnpc>
phoe Kind of, but it's not that bad, for my purpose.
<phoe>
so in (progn (+ 2 nil) (foo)), a TYPE-ERROR will be signaled, but FOO will never get called
<basicnpc>
I also understand that such practice should be discouraged in normal usage.
<basicnpc>
But really, my purpose now is to write more succinct tests.
<jackdaniel>
basicnpc: I think that this will be hard to do, but trust me, you are trying to solve the wrong problem with an impossible solution
<jackdaniel>
(and even if it were possible, the result would be useless)
<phoe>
"error cannot directly return; the only exit from error can come by non-local transfer of control in a handler or by use of an interactive debugging command."
josrr has joined #commonlisp
<phoe>
so in (progn (+ 2 nil) (foo),, the moment (+ 2 nil) calls ERROR, there is no way for ERROR to return, which means that control can never reach (foo).
rainthree has joined #commonlisp
<phoe>
unless there's a handler bound somewhere, but that handler will unwind past (foo) anyway
<jackdaniel>
so, if I were deadset on doing something awful, I'd unlock the CL package and redefine ERROR to SIGNAL; but as said earlier that's a wrong solution for an even worse problem
<phoe>
jackdaniel: might even not work because cl:error could be open-coded everywhere
<jackdaniel>
or, I'd modify the source code of the implementation and build it from scratch
<basicnpc>
Or... just out of curiosity, would it work if I redefined make-instance (method for errors) so that it always adds a CONTINUE-WITH-NIL restart?
<jackdaniel>
that should give you enough rope to hang yourself :3
<phoe>
basicnpc: you're well in the undefined behavior zone by that point, and also misunderstand how restarts work
<jackdaniel>
I think that you are severely confused about what are errors and restarts in common lisp
<phoe>
you'd need a way for the debugger to normally return, tbh
<phoe>
and that's already more than enough rope to do bad things with, as jackdaniel said
alfiee has joined #commonlisp
<basicnpc>
I see. Thanks for finding that line from the SPEC!
<phoe>
no problem, I kinda grew to like the condition system
Thermoriax has quit [Ping timeout: 246 seconds]
<jackdaniel>
(defun invoke-debugger (condition) (format *Debug-io* "YOLO~%")) ; now ignore the package lock, and (???) profit
<basicnpc>
phone It's awesome. I ask this question also to test its boundary :-)
<phoe>
the boundary of the condition system is the same as the boundary of the CL package
<basicnpc>
I suspect that redefining make-instance for errors would work though. But as you said it may lead to UB and is thus dangerous.
<phoe>
redefining methods like that falls under point 19
<basicnpc>
I see :-)
alfiee has quit [Ping timeout: 252 seconds]
<bike>
restarts are a property of how the error is signaled, not of the error object itself. if the code around the (error ...) call isn't prepared for it to return (which it isn't, since error never returns) that's that.
<bike>
so messing with make-instance is irrelevant on top of dangerous.
basicnpc has quit [Ping timeout: 248 seconds]
rkazak has joined #commonlisp
jonatack has joined #commonlisp
yitzi has quit [Ping timeout: 252 seconds]
Thermoriax has joined #commonlisp
ingeniot has joined #commonlisp
rkazak has quit [Ping timeout: 264 seconds]
yitzi has joined #commonlisp
jonatack has quit [Read error: Connection reset by peer]
jonatack has joined #commonlisp
bpanthi977 has joined #commonlisp
jonatack has quit [Ping timeout: 264 seconds]
jonatack has joined #commonlisp
rainthree has quit [Ping timeout: 252 seconds]
alfiee has joined #commonlisp
Th30n has quit [Quit: going off]
ingeniot has quit [Ping timeout: 240 seconds]
bpanthi977 has quit [Remote host closed the connection]
bpanthi977 has joined #commonlisp
varjag has quit [Quit: ERC 5.5.0.29.1 (IRC client for GNU Emacs 29.3)]
alfiee has quit [Ping timeout: 245 seconds]
rkazak has joined #commonlisp
bpanthi977 has quit [Ping timeout: 248 seconds]
surabax has joined #commonlisp
ebrasca has joined #commonlisp
UncleRRR has quit [Quit: Leaving]
rainthree has joined #commonlisp
JuanDaugherty has joined #commonlisp
rkazak has quit [Ping timeout: 248 seconds]
rainthree has quit [Read error: Connection reset by peer]
JuanDaugherty has quit [Ping timeout: 276 seconds]
jonatack has quit [Quit: WeeChat 4.5.1]
<yottabyte>
if I have some code that's taking a long time to run, but then I decided I should've had some incremental logging, can I modify the code while it's running and it could do that for me?
<beach>
You should be able to modify a global function and have the new version called next time a call is made, unless of course it is inlined. But if you are in a loop in a single function, then that loop is not going to be modified.
<yottabyte>
so if I have like (loop my-function) that's running indefinitely, I could modify my-function and then it'll be updated?
<beach>
That ought to work.
<beach>
There are restrictions, depending on the implementation.
<beach>
You meant (loop (my-function)) I suppose, yes?
<yottabyte>
yes, correct. sorry
ingeniot has joined #commonlisp
<beach>
Like, you may need to declare MY-FUNCTION NOTINLINE. Stuff like that.
alfiee has joined #commonlisp
wobbol has joined #commonlisp
alfiee has quit [Ping timeout: 248 seconds]
<beach>
yottabyte: There are some videos on YouTube about "live coding", and they depends on that mechanism working.
bpanthi977 has joined #commonlisp
<yottabyte>
yeah, I've seen some of that kind of stuff with game and graphics stuff
<yottabyte>
maybe pushing pixels with lisp was one of the series
rkazak has joined #commonlisp
<beach>
I remember the one about generating music, but yeah.
<yottabyte>
so Andy Gavin must've been the real deal, huh?
<beach>
I don't remember that name, but then I don't remember names very well.
<yottabyte>
he worked for the game studio Naughty Dog and made games like Crash Banditcoop and Jak and Daxter. they were written in lisp. he was interviewed relatively recently and talked about why he used lisp
bpanthi977 has quit [Ping timeout: 246 seconds]
<yottabyte>
and he said how he could just jump into the middle of any level and debug the code
<yottabyte>
but it's like he was writing games in lisp in the 90s... even now, 30 years later, it's hard for me to get a triangle up 😂
<beach>
I see. "Bandicoot" maybe?
<yottabyte>
hahaha, yes
<yottabyte>
I remember Carmack spoke about writing games in lisp too, he was like, it might be the better solution, but if someone is highly productive in another language, the time it would take for them to be productive in lisp is too long and in an industry of tight deadlines and stuff, infeasible
<beach>
The article by Hudak and Jones contradicts that conclusion.
<beach>
The article suggests that there might be as much as a factor 20 difference in productivity between different languages (it is probably somewhat lower) and that learning a new language well enough to become somewhat productive in it does not take very long.
<beach>
The article was written in order to push Haskell, but I think it should be read with a more general idea in mind. Plus that they ignored that some Lisp version beat Haskell in their experiment. :)
<disruptek>
i have a feeling carmack has a perspective of programmer productivity which may not hold across the entire industry. ;-)
<beach>
I see.
<beach>
disruptek: The industry being software development in general, or restricted to games?
<disruptek>
well, he has worked outside of strictly game development, and probably hired from outside, also. point being, he may be out of touch with median programmer talent.
<ixelp>
Lispings ala John McCarthy :: All Things Andy Gavin
<bjorkint0sh>
I wonder how he feels about ruby now.
skin has joined #commonlisp
bpanthi978 has joined #commonlisp
bpanthi977 has quit [Ping timeout: 252 seconds]
bpanthi978 is now known as bpanthi977
bpanthi977 has quit [Ping timeout: 248 seconds]
alfiee has joined #commonlisp
JuanDaugherty has joined #commonlisp
<yottabyte>
that's kind of like what Carmack was saying, you have these massive game engines written in C++ or whatever, things like Unity and Unreal Engine, to compete with them is like impossible, so everyone just uses them
alfiee has quit [Ping timeout: 248 seconds]
NotThatRPG has quit [Ping timeout: 252 seconds]
<craigbro>
Interesting that Gavin's comment on libraries and momentum rhymes with Sussman's comment on the changes to programming as a practice, from one of writing code to solve problems and building your tools, to assembling tools from the community/vendors, doing science on them to figure out how they work, and assembling them.
<bjorkint0sh>
momentum is a thing, but at the time he switched to Ruby, which from what I can tell, has lost a lot of that same momentum.
<bjorkint0sh>
it's rather faddy.
Everything has quit [Ping timeout: 252 seconds]
<craigbro>
I also don't think it was that scathing a critique, just reflects the state of the ecosystem at the turn of the century.
<bjorkint0sh>
it's enough to discourage a new comer at that time you see?
<bjorkint0sh>
if I'd read that then, I'd have concluded (logically) that Ruby was the better of the two, which is not the case at all.
<craigbro>
I can't comment on a new comers reading at that time, I was 15 years into my career, and the majority of that writing lisp
<craigbro>
But I did alot of Ruby as well, and I have the same appreciation for it that he describes there
<craigbro>
the lisp community was small, and rather toxic, especially the CL community, around that time
<beach>
"toxic"?
<craigbro>
full of assholes, and repeated fights, and absolutely discouraging to newcomers, moreso than any McCarthy obit. article could ever be
<beach>
I see.
<craigbro>
a small world of precious geniuses was the dominant vibe
<bjorkint0sh>
that was a long time ago indeed.
<craigbro>
it's improved quite a bit, and even then there were good folks
<bjorkint0sh>
these days it's a little like riding a bike on a beach
<bjorkint0sh>
:-D
bpanthi977 has joined #commonlisp
JuanDaugherty is now known as ColinRobinson
rkazak has joined #commonlisp
bpanthi977 has quit [Ping timeout: 272 seconds]
bpanthi977 has joined #commonlisp
<yottabyte>
haha, nice
bpanthi977 has quit [Ping timeout: 252 seconds]
<jackdaniel>
some folk avoid irc and use discord for that teason I think
<jackdaniel>
despite discord being superawful
<bjorkint0sh>
it's just ptsd.
<bjorkint0sh>
folks on irc used to be incredibly meaaaaan.
aadcg has joined #commonlisp
<bjorkint0sh>
then again, there were a lot of idio... inexperienced nagging childlike irc-ers.
skin has quit [Quit: Lost terminal]
LainExperiments has quit [Quit: Client closed]
<aadcg>
I feel this is a really basic question, but I'm missing something:
<jackdaniel>
call invoke-restart to transfer control
<jackdaniel>
returned value from handler-bind handler is simply ignored
<jackdaniel>
and you proceed to the next handler
<aadcg>
jackdaniel: I see now, thanks!
NotThatRPG has joined #commonlisp
rkazak has quit [Ping timeout: 272 seconds]
alfiee has joined #commonlisp
alfiee has quit [Ping timeout: 252 seconds]
amb007 has quit [Ping timeout: 252 seconds]
amb007 has joined #commonlisp
<jackdaniel>
sure
LainExperiments has joined #commonlisp
Thermoriax has quit [Remote host closed the connection]
<yitzi>
bjorkint0sh: I think the splitting of #lisp and #commonlisp has helped. Along with gentle encouragement to use #lispcafe and #clsschool when appropriate.
<bjorkint0sh>
yitzi: I think it's discord. it's drawn people away from irc.
<bjorkint0sh>
which has reduced a LOT of the noise.
rkazak has joined #commonlisp
<yitzi>
Probably true.
dtman34 has quit [Ping timeout: 246 seconds]
rkazak has quit [Ping timeout: 248 seconds]
Thermoriax has joined #commonlisp
wobbol has quit [Ping timeout: 252 seconds]
ingeniot has quit [Ping timeout: 240 seconds]
ColinRobinson has quit [Ping timeout: 276 seconds]
rkazak has joined #commonlisp
<craigbro>
I would note that the whole anger about not being popular, and sense of superiority to non-lispers has reduced quite a bit
<craigbro>
it happens from time to time, but it's not the dominant feel like it was in early 00s for example
LainExperiments has quit [Ping timeout: 240 seconds]
alfiee has joined #commonlisp
alfiee has quit [Ping timeout: 272 seconds]
FragmentedCurve has joined #commonlisp
gorignak has quit [Quit: quit]
gorignak has joined #commonlisp
amb007 has quit [Ping timeout: 244 seconds]
amb007 has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
rkazak has joined #commonlisp
triffid has quit [Quit: triffid]
JuanDaugherty has joined #commonlisp
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 246 seconds]
cage has quit [Remote host closed the connection]
cage has joined #commonlisp
cage has quit [Excess Flood]
cage has joined #commonlisp
Lord_of_Life_ is now known as Lord_of_Life
LainExperiments has joined #commonlisp
rkazak has quit [Ping timeout: 246 seconds]
<phoe>
yitzi: yes
Everything has joined #commonlisp
LainExperiments has quit [Client Quit]
JuanDaugherty is now known as ColinRobinson
<jackdaniel>
from one channel with angry mob now we have two 'not deader than usual' ones ;)
alfiee has joined #commonlisp
bpanthi977 has joined #commonlisp
aadcg has quit [Ping timeout: 265 seconds]
<aeth>
beach, yottabyte, disruptek: I think the problem as implied by Carmack here is that in his domain (especially 20+ years ago), performance matters a ton, and there's nothing stopping any language from having matching performance (except now you might have to also write a compiler!), but the performance tricks will vary. And this is usually deeper expertise than most programming, to know the fast/slow
<aeth>
paths and how to debug/optimize (and, again, you may have to end up writing a compiler)
<aeth>
Some things are largely the same between languages and some things take years to pick up
<aeth>
Also, some of the massive productivity difference could be that certain languages (like C!) tend to make you care about performance-related things even when you don't need to care, but if performance actually does matter, you're not going to see a huge boost (however, performance isn't going to matter everywhere, even in an application where performance absolutely does matter, so you should still see an
<aeth>
improvement).
alfiee has quit [Ping timeout: 276 seconds]
<aeth>
However, C and C++ culture is "cryptically crash, sometimes very far from where the error is" so you can probably still see a considerable long run productivity benefit even in high-performance code.
bpanthi977 has quit [Remote host closed the connection]
bpanthi977 has joined #commonlisp
skin has joined #commonlisp
akoana has joined #commonlisp
mishoo has quit [Ping timeout: 272 seconds]
bendersteed has quit [Quit: bendersteed]
mulk has quit [Ping timeout: 248 seconds]
Guest6413 has quit [Quit: WeeChat 4.5.1]
Kyuvi has joined #commonlisp
mulk has joined #commonlisp
mwnaylor has quit [Ping timeout: 248 seconds]
rkazak has joined #commonlisp
rkazak has quit [Ping timeout: 264 seconds]
triffid has joined #commonlisp
NotThatRPG has quit [Remote host closed the connection]
NotThatRPG has joined #commonlisp
NotThatRPG has quit [Ping timeout: 246 seconds]
zxcvz has joined #commonlisp
alfiee has joined #commonlisp
younder has joined #commonlisp
alfiee has quit [Ping timeout: 244 seconds]
josrr has quit [Ping timeout: 260 seconds]
bpanthi977 has quit [Ping timeout: 260 seconds]
ColinRobinson is now known as JuanDaugherty
GalaxyNova has joined #commonlisp
JuanDaugherty is now known as ColinRobinson
rkazak has joined #commonlisp
zxcvz has quit [Quit: zxcvz]
rkazak has quit [Ping timeout: 248 seconds]
dtman34 has joined #commonlisp
notzmv has joined #commonlisp
dtman34 has quit [Ping timeout: 276 seconds]
dtman34 has joined #commonlisp
gorignak has quit [Quit: quit]
gorignak has joined #commonlisp
mwnaylor has joined #commonlisp
rkazak has joined #commonlisp
cercopith has joined #commonlisp
Thermoriax has quit [Quit: brb]
rkazak has quit [Ping timeout: 272 seconds]
shawnw has quit [Ping timeout: 246 seconds]
rkazak has joined #commonlisp
rkazak has quit [Ping timeout: 260 seconds]
alfiee has joined #commonlisp
NotThatRPG has joined #commonlisp
alfiee has quit [Ping timeout: 252 seconds]
bpanthi977 has joined #commonlisp
mwnaylor has quit [Remote host closed the connection]