<phoe>
"Several Lisp implementations already support custom TEST and HASH arguments for MAKE-HASH-TABLE. This library is a small wrapper around the vendor-specific extensions. (Allegro CL, CCL, CMUCL, LispWorks, SBCL)"
quazimodo has joined #lisp
<shrdlu68>
phoe: Thanks.
fouric has joined #lisp
makomo has quit [Ping timeout: 252 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
varjag has quit [Ping timeout: 268 seconds]
<ubermonk>
phoe: on sbcl default-initargs on class allocated slots works fine for defclass, but fails to set the slot for define-condition
<ubermonk>
though I can understand why this may have gone unnoticed, the only use for this feature I can think of is keeping track of the last subclass constructed
robotoad has joined #lisp
<Shinmera>
phoe: pfdietz: I'm assuming it requires an error be signalled on test failure.
frgo has quit [Ping timeout: 268 seconds]
<jackdaniel>
given cooperation from the test framework, it may be actually any signal, not necessarily error
<jackdaniel>
then you can handle it from test-op
<Shinmera>
Xach: Could you clear us up on this? How do you determine whether a run of asdf:test-op during the dist check to have been succuessful?
<Shinmera>
*whecher a run uf asdf:test-op during dist check has been successful
<Shinmera>
**whether
<Shinmera>
jesus I guess my language center hasn't fully woken up yet
kini has quit [Quit: No Ping reply in 180 seconds.]
<phoe>
Xach: yes please, I'd like that
kini has joined #lisp
orivej has joined #lisp
varjag has joined #lisp
scymtym has joined #lisp
frgo has joined #lisp
pjb has joined #lisp
<shka_>
good morning
<beach>
Hello shka_.
P1RATEZ has quit []
Arcaelyx_ has quit [Ping timeout: 260 seconds]
Arcaelyx has joined #lisp
zfree has quit [Quit: zfree]
aindilis has quit [Ping timeout: 252 seconds]
robotoad has quit [Quit: robotoad]
shka_ has quit [Quit: WeeChat 1.9.1]
pjb has quit [Ping timeout: 252 seconds]
shka_ has joined #lisp
asarch has quit [Quit: Leaving]
robotoad has joined #lisp
robotoad has quit [Quit: robotoad]
ggole has joined #lisp
zfree has joined #lisp
heisig has joined #lisp
domovod has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
quipa has joined #lisp
<phoe>
good morniiiing
<beach>
Hello phoe.
<phoe>
Hey beach .
marvin2 has quit [Ping timeout: 252 seconds]
slyrus1 has joined #lisp
<phoe>
I might consider creating a personal homepage that lists all the Lisp libraries I've created, in hope they're useful to someone.
reverse_light has joined #lisp
<heisig>
Good morning phoe! You could also just put that information on cliki.
FreeBirdLjj has joined #lisp
<shrdlu68>
What's the easiest way to trace how many times a function was called?
<shka_>
trace comes to mind
<shka_>
fancy-trace of slime
roshanavand has joined #lisp
roshanavand has quit [Ping timeout: 246 seconds]
roshanavand has joined #lisp
trittweiler has joined #lisp
khisanth_ has quit [Ping timeout: 272 seconds]
<phoe>
heisig: good idea! Thanks
quazimodo has quit [Ping timeout: 252 seconds]
quazimodo has joined #lisp
khisanth_ has joined #lisp
v0|d has joined #lisp
jgoss has joined #lisp
pjb has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
<Shinmera>
I used to put my projects on cliki but then got lazy
FreeBirdLjj has quit [Ping timeout: 260 seconds]
dddddd has joined #lisp
SlashLife has quit [Max SendQ exceeded]
DataLinkDroid has joined #lisp
SlashLife has joined #lisp
pjb has quit [Ping timeout: 252 seconds]
roshanavand has quit [Ping timeout: 252 seconds]
roshanavand has joined #lisp
esrse has quit [Ping timeout: 244 seconds]
v0|d has quit [Remote host closed the connection]
marvin2 has joined #lisp
m00natic has joined #lisp
<Xach>
Shinmera: I don't use asdf:test-op at all.
<Xach>
I build only.
troydm has quit [Ping timeout: 252 seconds]
<Shinmera>
Hmm. For some reason I remember talk about tests being run automatically too
nowolfer has quit [Read error: Connection reset by peer]
nowolfer has joined #lisp
scymtym has quit [Ping timeout: 240 seconds]
Josh_2 has joined #lisp
<Xach>
Shinmera: well, the qlt snippet could invoke the test suite?
Arcaelyx has joined #lisp
<phoe>
Xach: via invoking the ASDF test-op on the system?
<phoe>
that's the way I would suggest
<phoe>
I mean, we already have ASDF test-op; I can't yet see a reason for another test hook
heisig has quit [Ping timeout: 260 seconds]
<Shinmera>
Xach: sure, but still, I'd personally much prefer having code relating to my systems under my control so I can change them as needed
<Shinmera>
phoe: test-op has no way of specifying how failures are reported
scymtym has joined #lisp
<Shinmera>
often, for users, it's best to just print a report, whereas for completely automated systems like qlt an error is more appropriate, so that it can be caught and a notice can be sent
vtomole has joined #lisp
<phoe>
yes, I see.
<phoe>
"The results of this operation are not defined by ASDF. It has proven difficult to define how the test operation should signal its results to the user in a way that is compatible with all of the various test libraries and test techniques in use in the community, and given the fact that ASDF operations do not return a value indicating success or failure. For those willing to go to the effort, we suggest
<phoe>
defining conditions to signal when a test-op fails, and storing in those conditions information that describes which tests fail. "
<Shinmera>
One of the failures of ASDF in my view is that operations are singleton objects and there's no real way for the user to specify arguments to control the precise evaluation of the operation.
<phoe>
What do we decide on, then?
<phoe>
Do we patch ASDF with something that attempts to fix this situation?
<Shinmera>
I'd be fine with what I suggested; a qlt-specific file that ensures tests are run with an error in case of failures.
<Shinmera>
As I said, you can't really patch asdf to address this, it would be a fundamental change in how it works.
<phoe>
That would mean that we have an .ASD file and a .QLT file to fully define a system.
<phoe>
Which is one file too much.
<Shinmera>
People already write .travis.ymls and .circle-cis and whatever else
<Shinmera>
Another file for another kind of CI is no problem to me
<phoe>
Sure, no problem then.
frgo has joined #lisp
acolarh has quit [Ping timeout: 252 seconds]
<phoe>
Does QLT parse ASD files before reading the QLT-specific files?
frgo_ has joined #lisp
frgo has quit [Ping timeout: 252 seconds]
<phoe>
If yes, then a hack would be, to the end of foo.asd, add #+qlt (cl:in-package :qlt-user) #+qlt (qlt-specific-stuff-regarding-system #:foo ...)
ebzzry_ has joined #lisp
vtomole has quit [Quit: Page closed]
acolarh has joined #lisp
jkordani has joined #lisp
<Xach>
qlt does not do anything with asd files.
pjb has joined #lisp
nowhere_man has quit [Ping timeout: 252 seconds]
beach has quit [Ping timeout: 252 seconds]
beach has joined #lisp
ski has quit [Ping timeout: 245 seconds]
didi has joined #lisp
cage_ has joined #lisp
<didi>
If you would write a function `write-object', which writes a representation of an object to a stream, would you write it, regarding the STREAM, after WRITE-* or FORMAT? That is, would (null STREAM) mean you write to *STANDARD-OUTPUT* or you return a string?
ski has joined #lisp
<beach>
I would use the standard definition of stream designator.
<didi>
beach: Thank you.
heisig has joined #lisp
dyelar has quit [Quit: Leaving.]
heisig has quit [Remote host closed the connection]
heisig has joined #lisp
pjb has quit [Ping timeout: 252 seconds]
quipa has quit [Ping timeout: 250 seconds]
trittweiler has quit [Ping timeout: 245 seconds]
zfree has quit [Quit: zfree]
asarch has joined #lisp
dyelar has joined #lisp
dyelar has quit [Ping timeout: 252 seconds]
dyelar has joined #lisp
dyelar has quit [Client Quit]
dale_ has joined #lisp
dale_ is now known as dale
SaganMan has quit [Quit: WeeChat 1.6]
robotoad has joined #lisp
anewuser has joined #lisp
orivej has joined #lisp
ski has quit [Ping timeout: 252 seconds]
graphene has quit [Remote host closed the connection]
igemnace has joined #lisp
graphene has joined #lisp
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Fade>
with sbcl 1.4.12 on x86-64 ironclad is failing to compile on a package lock violation. should I report on sharplispers github?
<Fade>
ironclad-v0.40 from quicklisp.
<Xach>
Hmm, I thought this was all worked out already
<Fade>
I just updated my quicklisp and sbcl to check things out.
<Fade>
I could pull the master branch and try again.
<Xach>
Hmm, I think I screwed something up pretty well somehow.
Arcaelyx has joined #lisp
<Xach>
Things have regressed
<Xach>
yes indeed
<Xach>
argh
<Xach>
and of course i can't built old sbcl right now for an unknown reason
<Fade>
:(
* Xach
works it out slowly
trittweiler has joined #lisp
frgo_ has quit [Ping timeout: 252 seconds]
<Josh_2>
When I have a FLEXI-STREAMS:FLEXI-IO-STREAM, and I am using read-line on it, how can I reset back to the start, setting the file-position to 0, the same with flexi-stream-position, I want to be able to read-line from the start of the flexi-io-stream again
<Josh_2>
10/10 quality writing by me
<Xach>
So what happened is I uploaded an old dist instead of the correct one and now it is a matter of fixing it up
shka_ has quit [Quit: WeeChat 1.9.1]
nowhere_man has joined #lisp
roshanavand has quit [Ping timeout: 268 seconds]
roshanavand has joined #lisp
zxcvz has joined #lisp
graphene has quit [Read error: Connection reset by peer]
jurov has quit [Ping timeout: 246 seconds]
graphene has joined #lisp
jurov has joined #lisp
angavrilov has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 252 seconds]
angavrilov has joined #lisp
<pfdietz>
I am trying to get a system ready for inclusion in quicklisp. What needs to be done for test-op to return something that the quicklisp testing process would recognize?
<pfdietz>
(inclusion in a dist)
shrdlu68 has quit [Ping timeout: 252 seconds]
<Xach>
pfdietz: nothing is needed. only compilation is attempted.
<pfdietz>
Ok.
zxcvz has quit [Ping timeout: 268 seconds]
rozenglass has joined #lisp
roshanavand has quit [Ping timeout: 244 seconds]
roshanavand has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
SenasOzys has quit [Ping timeout: 260 seconds]
<Xach>
pfdietz: must be multi-implementation, too
nowolfer has quit [Ping timeout: 246 seconds]
pjb has joined #lisp
roshanavand has quit [Ping timeout: 252 seconds]
nowolfer has joined #lisp
<pfdietz>
This is Waters' old COVER package. Main issue is getting rid of some CLtL1-isms.
roshanavand has joined #lisp
domovod has quit [Quit: WeeChat 2.2]
anewuser has quit [Quit: anewuser]
igemnace has quit [Ping timeout: 268 seconds]
<Fade>
a package with CLtL1-isms is an odd choice to champion. :)
<pfdietz>
Hey, it's a cool package! And I have uses for extensions of it.
quipa has joined #lisp
frgo has joined #lisp
roshanavand has quit [Ping timeout: 260 seconds]
shka_ has joined #lisp
<shka_>
good evening!
roshanavand has joined #lisp
<shka_>
pjb: numenta stuff was intriguing enough for me to buy "on intelligence" book
<shka_>
i wonder if htms can be paired with boltzmann machines
<shka_>
anyway, thanks for something new to learn!
anunnaki has quit [Ping timeout: 252 seconds]
nowhere_man has quit [Ping timeout: 246 seconds]
kushal has quit [Remote host closed the connection]
roshanavand has quit [Ping timeout: 252 seconds]
m00natic has quit [Remote host closed the connection]
scymtym has quit [Ping timeout: 260 seconds]
vlatkoB has quit [Remote host closed the connection]
scymtym has joined #lisp
nowhere_man has joined #lisp
roshanavand has joined #lisp
roshanavand has quit [Ping timeout: 268 seconds]
roshanavand has joined #lisp
nowhere_man has quit [Ping timeout: 252 seconds]
<jeosol>
morning guys
sauvin has quit [Read error: Connection reset by peer]
<jeosol>
anyone has a working websockets (any lib) example they can share with me. I tried to load fukamachi's websocket-driver example on his github, but getting some weird errors.
<jeosol>
one of the errors is "No Sec-WebSocket-Version header"
angavrilov has quit [Remote host closed the connection]
jxy has quit [Remote host closed the connection]
<jeosol>
what I am trying to do is this: I have an application that writes output when running, I will like to send this to a browser window. The output from the program is supposed to show status report, e.g., like log output
<jeosol>
maybe there is a better way to achieve this. Also, the messages can be fast or slow, depending on problem.
<oni-on-ion>
try hunchensocket
heisig has quit [Remote host closed the connection]
SaganMan has joined #lisp
<jeosol>
oni-on-ion: thanks for that. I guess websockets is the approach I should be looking at?
<whartung>
you don’t necessarily need websockets for that, folks have been doing long-polling to do that forever.
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
jxy has joined #lisp
dueyfinster has joined #lisp
<jeosol>
whartung: ok, I am not a web expert but I am just looking for away to send my print statements to the repl to some text box (div, textarea, etc) on a page.
<whartung>
if you’re trying to simulate a repl, then you may be happier with websockets.
RedNifre has joined #lisp
<RedNifre>
Greetings.
cage_ has quit [Remote host closed the connection]
<jeosol>
not simulate, just send read-only print statements to a page.
<oni-on-ion>
can use hunchentoot etc. basic HTTP requests for that
frgo has quit [Read error: Connection reset by peer]
shka_ has quit [Remote host closed the connection]
roshanavand has quit [Ping timeout: 244 seconds]
roshanavand has joined #lisp
roshanavand has quit [Client Quit]
<whartung>
well that’s the problem jeosol — web pages out of the box simply aren’t set up for that, trickling in content.
<whartung>
it takes a bit of plumbing to get that two work.
<whartung>
*to work
<whartung>
two too many to’s in english...
<jeosol>
i agree. I tried the ajax approach, the pages don't update as fast I wanted, some kind of lag.
<whartung>
long polling is a normal http request that’s reading the response, and acting on it as it’s read (vs caching it all up and then acting on the finished payload). Meanwhile, the server never closes the response/socket, so it remains open. Something on the server is polling or waiting for new data to push down the opened response to the client.
<jeosol>
probably didn't implement it correctly
<whartung>
it’s not web 101, that’s for sure
<whartung>
you could have the web page just repeatedly poll the server for updates.
<whartung>
and send fine grained responses
<whartung>
that has inefficiencies of its own, but it’s likely easier ti implement.
makomo has joined #lisp
eminhi has quit [Ping timeout: 252 seconds]
emaczen has joined #lisp
dueyfinster has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
emaczen has quit [Client Quit]
jruchti has quit [Ping timeout: 250 seconds]
emaczen has joined #lisp
nowhere_man has joined #lisp
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
jruchti has joined #lisp
robotoad has quit [Quit: robotoad]
quazimodo has quit [Ping timeout: 252 seconds]
Copenhagen_Bram has quit [Read error: Connection reset by peer]
orivej has joined #lisp
Copenhagen_Bram has joined #lisp
Arcaelyx has joined #lisp
Arcaelyx has quit [Client Quit]
<jasom>
If you don't care about IE/Edge you can use server-sent events
<jasom>
but websockets have better support
slyrus1 has quit [Ping timeout: 240 seconds]
RedNifre has quit [Read error: Connection reset by peer]
<emaczen>
Is there a CL or a common CL implementation function that will convert an integer to and from big and little endian?
<|3b|>
nothing directly in spec
ggole has quit [Quit: ggole]
<dlowe>
you sure you want that, or do you want a byte vector
<dlowe>
because it's a lot nicer to think of byte order as being an encoding of an integer
<dlowe>
I thought alexandria had something, but it doesn't
<jasom>
emaczen: consider fastio?
<jasom>
emaczen: it doesn't have conversion, but it lets you read from a byte-stream as a particular endianness
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
longshi has joined #lisp
RedNifre has joined #lisp
slyrus1 has joined #lisp
jkordani_ has joined #lisp
warweasle has quit [Quit: later]
dented42 has joined #lisp
jkordani has quit [Ping timeout: 264 seconds]
<RedNifre>
Hey there, I discovered this ancient C64 Lisp and I'm trying to write a macro that turns (-> 4 (+ 3) (* 5)), but I'm afraid I'm too clueless about lisp to do that. Conceptually speaking, how would you solve it?
<dlowe>
well, I'd start by figuring out my inputs and output code
<Bike>
did you forget to type the end of the second clause?
<RedNifre>
So far I have a FEXRP function like (df tf2 (a b) (cons (car b) (cons a (cdr b] which does the job for two elements, i.e. it turns (tf2 5 (+ 2)) into (+ 5 2)
<dlowe>
but this channel is just for common lisp
<dlowe>
the any-lisp channel is ##lisp
<RedNifre>
ah, my bad, i thought this would be any lisp.
npr-work has joined #lisp
pierpal has joined #lisp
nowhere_man has quit [Ping timeout: 268 seconds]
Bike has quit [Ping timeout: 256 seconds]
<phoe>
I actually have a question about ANSI CL naming conventions
<phoe>
"how can it be variable if it must be constant": why are constant variables named like that?
<oni-on-ion>
i always get warnings with defconst
<Shinmera>
phoe: what?
<phoe>
constant variable
<phoe>
that's an oxymoron
<Shinmera>
Ah, because
<_death>
it varies when the programmer decides to change it
<phoe>
I guess this translates to a constant binding in the namespace of variables
<Shinmera>
variable n. a binding in the ``variable'' namespace.
<phoe>
which makes more sense when expanded like that
<phoe>
oh right, exactly this
<phoe>
the naming "constant variable" reminds me of that Ford quotation where you could have any color of your model T as long as that color is EQL to :BLACK
<phoe>
geez, even the name's lispy: model T
<oni-on-ion>
model Ethh
trittweiler has quit [Ping timeout: 252 seconds]
hiroaki has joined #lisp
robotoad has joined #lisp
warweasle has joined #lisp
Roy_Fokker has joined #lisp
<aeth>
well, a vector isn't a vector so it doesn't surprise me that a variable isn't necessarily variable
<aeth>
and a function doesn't have to be a function, either :-)
<aeth>
programming does stuff like that all of the time
<aeth>
(a vector isn't a vector because you can't do (+ (vector 1 2) (vector 3 4)) or (* 42 (vector 1 2)))
<oni-on-ion>
except in hooolia
<aeth>
Using the name "vector" for "1D array" means that when people actually implement vectors they're usually called "vec"s in CL
<oni-on-ion>
agh naming stuff is important =(
fortitude has joined #lisp
<aeth>
oni-on-ion: I'm not really familiar with Julia, but you probably don't actually want (+ (vector 1 2) (vector 3 4)) to work, even with real vectors. You probably want a #'vec+ and a #'scalar*vec instead. And then, on top of that, you probably *actually* want #'vec+-into or #'scalar*vec-into most of the time
<aeth>
Being too generic can be problematic, and with vectors you don't want to overallocate.
<aeth>
I don't think the combination of a very generic #'+ (to the point where it would work with vectors and maybe even matrices) and a dynamically typed language is a good combination.
didi has left #lisp ["O bella ciao bella ciao bella ciao, ciao, ciao."]
<aeth>
#'* is even harder. #'* can have any number of scalars, but only one vector (unless you arbitrarily want to pick which vector multiplication to use), but if you also have it with matrices, there's only one matrix multiplication, so suddenly you can use it for any arbitrary combination of foos and scalars again.
parjanya has joined #lisp
<oni-on-ion>
the combination is clearly defined because of typing
<oni-on-ion>
(on julia side. its really smart with it)
<oni-on-ion>
i wouldnt imagine doing mathematical on anything else. i think it gets those nice properties from MATLAB or R but im not sure.
<aeth>
Personally, I prefer doing mathematics on something that is explicit rather than magic.
<aeth>
I'd rather try to work in a middle level between the machine and the math theory than just type the math and hope the language is sufficiently smart.
<oni-on-ion>
i suppose you feel that julia is magic? not sure what to say after that.
<oni-on-ion>
doesnt feel like a conversation i am part of, or that i agree with any role that is assumed of me within it
<aeth>
*Something* has to be sacrificed to get efficient(ish) dynamically typed generics for mathematics.
<oni-on-ion>
yeah, the compiler's effort.
<oni-on-ion>
and the available packages and frameworks as extension to that; i've never seen an ecosystem nearly as complete and perfect for graphics/audio science and gamedev as i seen for julia
<oni-on-ion>
the sacrifice is having to Type out your code, i guess. but it works out, theres almost no undefined behavior, its quite a tight and robust and well thought-out platform.
<oni-on-ion>
but i'm using CL
<aeth>
wait, you do have to add types? :-)
razzy has quit [Remote host closed the connection]
<aeth>
Now *that* matches my CL experience.
razzy has joined #lisp
<oni-on-ion>
no, types are optional
<oni-on-ion>
it helps when designing stuff but yes also very important for optimisation =)
<aeth>
It's a bait and switch. SBCL does the same thing. "$foo is dynamically typed. $foo is almost as fast as C for mathematics." Well, yeah. When you add the optional type declarations.
longshi has quit [Quit: WeeChat 2.2]
<aeth>
I mean, obviously I think that's good in a language, to have the types be optional, but it's misleading to imply that the dynamic typing is the fast part when you have to help the language out to match C.
<oni-on-ion>
with julia i find it is easier to line up big abstract ideas into little detailed implementations. like a good micro/macroscopre
rumbler31 has joined #lisp
<oni-on-ion>
oh. yeah julia doesnt claim that. i suppose that is another inaccurate assumption i cannot be a part of =)
<oni-on-ion>
anything as we know has sacrifices for performance
<oni-on-ion>
nothing is really that different than anything else
<oni-on-ion>
but i wanted to say, that julia vector/matrix ops are superb, best-in-class, grade A top shelf delicioso
<oni-on-ion>
but thats half a macro away in CL anyway eh =)
<aeth>
Ime you can have generics or you can have fast dynamic typing but not both. Scheme usually cheats by having you write foo-bar-baz-ref instead of aref (now the compiler/interpreter knows what type it has to be!) just so it can keep its purity in dynamic typing some more. But even Scheme had to give into having a generic +, *, etc.
<aeth>
(I guess you can also do generics with a JIT by assuming that the type won't change and running something for long enough? I'm not that familiar with JITs)
rumbler31 has quit [Remote host closed the connection]
<aeth>
Lisp machines might have had another approach, I'm not sure. I think they ignored type declarations entirely. But no one uses specialized hardware like that anymore.
<no-defun-allowed>
Lisp machines do the type checking using hardware in parallel.
<oni-on-ion>
hehe @ scheme. and yeah about balancing dynamic vs. static. its good for when systems have a nice pleasant natural harmonious mix of both - like CL and like julia
<aeth>
Oh, and just to be clear again, I'd much rather declare types in a few places where necessary for performance than everywhere.
<oni-on-ion>
this is what i recent-learned about CL, that its both high and low. much from our discussions aeth i thank you for that and also many others here. but julia helps me understand CL more, anyway =)
<aeth>
But optional typing where it matters is almost as fast as C, not dynamic typing.
<aeth>
(What you can learn from CL is most of the time types don't matter! For performance, anyway.)
<oni-on-ion>
not sure how CL is about declaring types everywhere, but julia is good with type inferencing, mostly just a few places needed. a bit like ocaml i guess. not like haskell where its requires everywhere
<oni-on-ion>
*required
<oni-on-ion>
hm=) types help me design. not sure where to go with just defparameter/defun
<aeth>
oni-on-ion: CL is not about declaring types everywhere, but CL being competitive with Fortran/C/C++ for math computations (which is also what Julia tries to do) *is* about declaring types everywhere.
<aeth>
As a rule of thumb, arrays and numbers (and arrays of numbers) seem to be where it matters in CL.
<oni-on-ion>
julia is 10 years old. it doesnt "try" to accomplish that. but i appreciate your opinion.
<aeth>
oni-on-ion: If there's one thing I've learned about competing with C++ is everyone tries to, but there's just so much momentum behind it :-p
<oni-on-ion>
julia's main ting is to provide performant numeric and math stuff to replace C++, matlab, R, numpy/python. its doing really well for that.
<oni-on-ion>
sure aeth. theres a reason i have a lot of respect for julia and talk about it often. just saying. im not blind by any means =) my standards are almost impossible to fulfill
<aeth>
oni-on-ion: definitely looks like it replaces matlab, which is a really good thing because matlab isn't FOSS and the compatible GNU octave is much slower than matlab iirc.
<oni-on-ion>
rust is not even close they went the wrong direction i think
<oni-on-ion>
yea, also lots of complains about python, but numpy done in C, but most of that stuff is ported to julia now
<no-defun-allowed>
Yeah it died of memory leaks.
<oni-on-ion>
story of my life
<no-defun-allowed>
"oh no memory leaks are safe though!" says the rust book
<aeth>
oni-on-ion: the thing about C++ is that (almost) everyone who could leave C++ has already left C++ so if you want to compete with C++ you probably need something like Rust
<aeth>
You're, unfortunately, probably not going to replace C++ with something with a GC.
<pjb>
aeth: you can see GC, if you say you're doing it at compilation time.
<aeth>
no-defun-allowed: yeah, but it competes with Java
<oni-on-ion>
i cant represent all those language designers and whatever hangups are going on here. i just mention casual random fact info and hope its useful. not tryint to sell anything or get into comparisons or distract anyone from working etc
<pjb>
aeth: cf. ARC in Objective-C or Swift.
<no-defun-allowed>
It's certainly a higher level language but it seems quite fast.
<no-defun-allowed>
I see.
<oni-on-ion>
programming is not a pvp competition fight battle royale to me, thats all. its a practical healthy creative persuit.
<aeth>
pjb: I think anti-GC is a very overrated approach and GCs work in a lot more places than people think they work, but the people who stayed on C++ are people who disagree.
<pjb>
aeth: foremost, almost no program should be written in C or C++…
<aeth>
pjb: What reference counting does is make people think it's not a GC, though.
<pjb>
Almost all unix user-space programs should be written in higher level programming languages.
<no-defun-allowed>
People seem scared of GCs today.
<no-defun-allowed>
Even McCarthy's LISP didn't take long to garbage collect.
<oni-on-ion>
its the "magic" they dont understand which scares them.
<oni-on-ion>
like fancy other new languages
<oni-on-ion>
tsk tsk
<foom2>
no-defun-allowed: that's not a useful argument. memory was a lot faster relative to CPU speed back then than it is now.
<no-defun-allowed>
That's true.
<aeth>
no-defun-allowed: Pauses can be bad if your program is real-time. That's imo the main valid argument against most (but not all!) GCs.
<no-defun-allowed>
There are realtime GCs, right? I remember one for Java.
<aeth>
And there's the problem. Java.
<pjb>
There are real time GCs, and there are GC working in parallel, in background threads, and even in hardware!
<no-defun-allowed>
(If there aren't any libre ones, it means nothing though.)
<aeth>
You don't need maximum performance for real-time, you need predictable performance. GC is just one of the ways it can be unpredictable. JITs are afaik another.
durn has joined #lisp
<aeth>
I guess if it runs long enough it becomes predictable enough.
<durn>
I have my .stumpwmrc set to create a Swank server on port 4004 so I can update it while running. How can I change out Swank for Slynk or otherwise connect to the Swank server with Sly?
<aeth>
pjb: All of the nice GCs seem to be JVM
<pjb>
aeth: that's only because they have powerful backers: Sun, Oracle. Anytime, you win the lotto, and get bought out, become milliardaire, and finance the implementation of those GC in free CL implementations.
<pjb>
aeth: perhaps now that Elon Musk doesn't have Tesla on his plate anymore, you could interest him into some Common Lisp Venture?
<aeth>
pjb: A GC like that is much more complicated than a GC like what current CLs (obviously excluding ABCL) have because afaik it's more like having multiple GCs than one.
Copenhagen_Bram has quit [Ping timeout: 252 seconds]
xuxuru has quit [Quit: xuxuru]
<aeth>
Different GCs offer different drawbacks and advantages. The JVM afaik wants to be able to offer everything for everyone. Looks like Wikipedia describes it as "several garbage collectors". https://en.wikipedia.org/wiki/HotSpot
PuercoPop has quit [Quit: ZNC 1.6.3 - http://znc.in]
Copenhagen_Bram has joined #lisp
Essadon has joined #lisp
LiamH has quit [Quit: Leaving.]
orivej has quit [Ping timeout: 252 seconds]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Younder has quit [Ping timeout: 260 seconds]
ym has joined #lisp
serichsen has joined #lisp
<serichsen>
Moin!
<no-defun-allowed>
Hi serichsen
<serichsen>
To whom it may concern: the twitter bot @planet_lisp seems not to be working since May, assuming that it should tweet about anything new on planet.lisp.org
<no-defun-allowed>
If the JVM garbage collectors are so good, hour come they haven't removed Java yet?
<serichsen>
I guess someone still holds a reverence.
nirved has quit [Quit: Leaving]
Younder has joined #lisp
RedNifre has quit [Quit: (dm >>= (n f l) (mapcan f l))]
dented42 has joined #lisp
<serichsen>
Xach: sorry, you seem to be involved in Planet Lisp. See above.
Copenhagen_Bram has quit [Read error: Connection reset by peer]