jcowan_ has quit [Remote host closed the connection]
jcowan_ has joined #lisp
comborico1611 has quit [Quit: Konversation terminated!]
quazimodo has joined #lisp
fikka has joined #lisp
pfdietz has joined #lisp
smokeink has joined #lisp
ebzzry has joined #lisp
quazimodo has quit [Ping timeout: 240 seconds]
<pfdietz>
"Do you believe every library needs tests?" Well, duh!
fikka has quit [Ping timeout: 240 seconds]
quazimodo has joined #lisp
sjl has joined #lisp
sjl has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
damke_ has joined #lisp
palter has joined #lisp
palter has quit [Client Quit]
damke has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
BlueRavenGT has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
FreeBirdLjj has joined #lisp
Kundry_Wag has quit [Ping timeout: 268 seconds]
FreeBirdLjj has quit [Ping timeout: 256 seconds]
d4ryus1 has joined #lisp
fikka has joined #lisp
d4ryus has quit [Ping timeout: 276 seconds]
Fare has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
fikka has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 256 seconds]
rumbler31 has quit [Remote host closed the connection]
fikka has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
johnvonneumann has joined #lisp
johnvonneumann_ has joined #lisp
doesthiswork1 has joined #lisp
doesthiswork has quit [Read error: Connection reset by peer]
fisxoj has joined #lisp
dddddd has quit [Read error: Connection reset by peer]
fisxoj has quit [Client Quit]
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
<pierpa>
alternatively, do not do any documentation, so whatever it does is right.
verisimilitude has joined #lisp
<verisimilitude>
I still don't understand the obsession with tests.
<verisimilitude>
How is a test better than, say, ASSERT?
<verisimilitude>
The test is separate; sure, it only runs once, but then you're caught in the idea that you can write perfect tests to test imperfect code.
<pierpa>
a test can do an expensive computation. ASSERTs better be quick executing
<verisimilitude>
That recursion needs to be broken somewhere and the easiest place is before it starts.
<verisimilitude>
It seems strange to talk about performance like that for several reasons; firstly, it's clearly more important that the program is correct; secondly, this is Lisp and, if only performance mattered, Lisp wouldn't be chosen.
<verisimilitude>
With the ASSERT, you can even use restarts and continue; you can't do that with a test, but what if your test is wrong and fails to cover something that would only show up during actual execution over a long period of time?
fikka has joined #lisp
<pierpa>
then you would be no worse than if the there were no test
makomo has joined #lisp
<verisimilitude>
What I mean is a test only tests specific values likely to fail.
<verisimilitude>
The ASSERT wouldn't; it would be testing everything, constantly.
fikka has quit [Ping timeout: 264 seconds]
jlarocco has joined #lisp
damke has joined #lisp
rumbler31 has joined #lisp
<jjkola>
I think both have their uses
mathZ has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
damke_ has quit [Ping timeout: 264 seconds]
damke_ has joined #lisp
damke__ has joined #lisp
rumbler31 has quit [Ping timeout: 276 seconds]
damke has quit [Ping timeout: 264 seconds]
sjl has joined #lisp
Pixel_Outlaw has quit [Quit: Leaving]
damke_ has quit [Ping timeout: 264 seconds]
Josh_2 has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 260 seconds]
Patternmaster has joined #lisp
Mutex7 has quit [Quit: Leaving]
sjl has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
Fare has joined #lisp
damke has joined #lisp
Jen has quit [Read error: Connection reset by peer]
Jen has joined #lisp
damke__ has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 240 seconds]
Jen has quit [Read error: Connection reset by peer]
JenElizabeth has joined #lisp
zaquest has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
jeosol has joined #lisp
zaquest has joined #lisp
fikka has joined #lisp
shka_ has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 246 seconds]
<pfdietz>
Absent formal verification, testing is indispensible. And you might as well package up the tests so anyone can run them.
xaxaac has quit [Quit: Leaving]
<verisimilitude>
How are tests better than ASSERT; ASSERT is already present, as well.
fikka has joined #lisp
<pfdietz>
How does assert ensure you've delivered working code, if you haven't tested it?
<pfdietz>
The assert doesn't execute itself; test cases do.'
<pfdietz>
Delivering software of any complexity that works is very hard, and testing is not an optional part of that process.
<verisimilitude>
There's a difference between using a program to see if it works and writing however many test cases that check if something continues performing identically according to the test.
<verisimilitude>
Using a program to truly see if it works is necessary, but not this testing fad.
fikka has quit [Ping timeout: 264 seconds]
<pfdietz>
...
Fare has quit [Ping timeout: 265 seconds]
<pfdietz>
Dude.
<pfdietz>
Casual execution of a program to "see if it works" will do f-all in a program of any complexity.
<pfdietz>
I was being serious when I said testing is not optional.
<verisimilitude>
``Beware of bugs in the above code; I have only proved it correct, not tried it.''
Kundry_Wag has joined #lisp
<theemacsshibe[m]>
calm down Doctor Knuth
<verisimilitude>
Now, the funny aspect of all of these things that supposedly aren't optional is that they really are optional.
<pfdietz>
Here on Planet Earth, program verification is still largely an academic concept.
<verisimilitude>
Give a man a test and he'll know his program works. Give a man many tests and he'll never be quite certain.
<verisimilitude>
Now, joking aside, it's a fad and it's clearly not at all necessary.
<pfdietz>
Give me your code that you haven't tested, and I can be quite certain it will be shit.
<verisimilitude>
I don't understand why you think it's not.
<smokeink>
"The 50 years of research and development work on K made possible what many thought couldn't be done. We can automatically generate a correct-by-structure virtual machine from it's formal specification, which is fast enough to run real programs." this is the tool in action https://www.youtube.com/watch?v=eSaIKHQOo4c
Kundry_Wag has quit [Ping timeout: 276 seconds]
<verisimilitude>
That's interesting, smokeink; I'll watch this later.
schoppenhauer has quit [Ping timeout: 240 seconds]
<verisimilitude>
Also, pfdietz, if you actually are inspecting that code, even a tad, know that I purposefully wrote the macros to attempt to generate invalid lambda lists if my rules weren't followed.
SuperJen has quit [Ping timeout: 260 seconds]
sjl has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
igemnace has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
BlueRavenGT has joined #lisp
arescorpio has joined #lisp
al-damiri has quit [Quit: Connection closed for inactivity]
jlarocco has quit [Ping timeout: 256 seconds]
rumbler31 has joined #lisp
jlarocco has joined #lisp
Jen has quit [Read error: Connection reset by peer]
Jen has joined #lisp
JenElizabeth has joined #lisp
fikka has joined #lisp
Lord_Nightmare2 has joined #lisp
kajo has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Ping timeout: 256 seconds]
SuperJen has joined #lisp
jlarocco has quit [Ping timeout: 256 seconds]
kajo has joined #lisp
Jen has quit [Ping timeout: 256 seconds]
Lord_Nightmare has quit [Ping timeout: 264 seconds]
Lord_Nightmare2 is now known as Lord_Nightmare
Jen has joined #lisp
JenElizabeth has quit [Ping timeout: 256 seconds]
JenElizabeth has joined #lisp
SuperJen has quit [Ping timeout: 256 seconds]
Jen has quit [Ping timeout: 240 seconds]
damke_ has joined #lisp
damke has quit [Ping timeout: 264 seconds]
<White_Flame>
verisimilitude: yeah, it's great that we can use runtime checks at compiletime in lisp
<White_Flame>
as opposed to having the runtime burden, or running separate sanity testing code not included in the runtime
SuperJen has joined #lisp
<White_Flame>
of course, integration testing will always be the most meaningful
FreeBirdLjj has joined #lisp
Jen has joined #lisp
<pillton>
verisimilitude: The unit tests aren't for you today, they are for you in six to twelve months time and they are there for your contributors to ensure they don't make the same mistakes as you did.
<pillton>
verisimilitude: Unit tests are also valuable when you are developing across multiple lisp implementations and on different platforms.
<White_Flame>
the biggest problem with unit testing is that people have no idea what a "unit" should be, and end up meaninglessly fine-grained
<White_Flame>
that, and complected design makes separating out & configuring units for testing incredibly difficult
JenElizabeth has quit [Ping timeout: 260 seconds]
<aeth>
Writing unit tests are about as optional as wearing a seatbelt
FreeBirdLjj has quit [Ping timeout: 256 seconds]
<aeth>
You won't really notice their absence until you really notice their absence
SuperJen has quit [Ping timeout: 260 seconds]
ebzzry has quit [Ping timeout: 256 seconds]
<White_Flame>
I've always done coarser grained testing, and never once lamented not spending the time to meticulously unit test
<aeth>
Lisp is actually a good choice for if performance matters. It's not competing against fast languages like C or C++ or Java or C# (although it can be about as fast as the latter two)
<aeth>
It's competing against Ruby, Python, etc. Slow, interpreted languages for the most part.
<aeth>
White_Flame: I mostly REPL-test and run example programs. REPL-testing is perfectly fine... until you refactor. Oh well, I hope I don't introduce new bugs.
<White_Flame>
repl test -> copy -> (deftest name () ...paste...)
<aeth>
It's not that easy.
<aeth>
It's really hard to have a "unit" in a game engine.
<White_Flame>
yep, hence my complecting statement above
<aeth>
And this is in CL, with 0 non-constant globals.
<aeth>
Imagine C++
<White_Flame>
but even so, you choose when to call your testing functions. Startup your code environment, then call test functions
<aeth>
I'm definitely going to have tests
<White_Flame>
we are a dynamically runtime system after all
<aeth>
But I might have to do a lot of writing to get tests
<White_Flame>
no need to have tests locked up through their own main()
pierpa has quit [Quit: Page closed]
<aeth>
Not everything I do is currently dynamic. Some things were trivial, like for any higher ordered function using 'foo instead of #'foo
<aeth>
Some things will require some effort
<aeth>
The problem is mostly FFI
<aeth>
CL is a lot easier if you never have to touch C libraries.
damke_ has quit [Ping timeout: 264 seconds]
<aeth>
With the exception of an entirely CLX graphical application (which would be 2D-only?), that's basically impossible for graphical applications, although C can be minimized.
<aeth>
The C stuff is unreliable, hard to test, very stateful, etc.
rumbler31 has joined #lisp
BlueRavenGT has quit [Ping timeout: 264 seconds]
pierpal has joined #lisp
<aeth>
I don't think the actual renderer can be tested, which is a shame.
Fare has joined #lisp
rumbler31 has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 264 seconds]
<verisimilitude>
As you can imagine, I don't have any contributors, pillton; note that in CL-ECMA-48, there is a single check to determine if the Lisp implementation meets the one nonstandard quality needed (support for a seven-bit character set) and one additional check if ASCII is supported for optimizations. Asides from this, there's no nonstandard dependencies, but checking on multiple implementations is still valuable and what I do.
<verisimilitude>
While I can understand how tests are comparable to a seatbelt, I disagree with the analogy. A seatbelt isn't going to protect you if you drive recklessly into an eighteen wheeler; you will still be destroyed, with or without the seatbelt.
fikka has joined #lisp
<pfdietz>
The opposite of "perfect" is not "useless".
kerrhau has quit [Ping timeout: 240 seconds]
<verisimilitude>
I'd think tests, at least as commonly used, are more comparable to wearing a helmet constantly.
<verisimilitude>
A helmet will protect you from a subset of truly oblivious and stupid mistakes, such as walking near a building with debris falling, so long as the debris isn't so strong to break the neck or strikes a part of the body not protected by the helmet.
<pillton>
Please stop.
<verisimilitude>
Well, you have some people writing that tests are mandatory; I'm simply challenging such an assertion.
<verisimilitude>
I believe it's clearly incorrect.
<pillton>
You aren't challenging the assertion. You are challenging the analogy.
<verisimilitude>
In closing, wearing a helmet while wearing a seatbelt is an even safer way to drive, so people should clearly do that.
<verisimilitude>
If you're going to be a professional trucker, a helmet should be mandatory; I'd fire any truck driver of mine who refused to wear a helmet.
jibanes has quit [Ping timeout: 256 seconds]
rumbler31 has joined #lisp
jibanes has joined #lisp
Fare has quit [Ping timeout: 264 seconds]
<pfdietz>
V, out of curiosity: what's the size of the largest program you've been involved in the development and maintenance of?
<jcowan_>
I have a little plugin for the Chibi Scheme REPL; if you type @OK, it writes the previous expression and its result into a file of tests.
mflem has quit [Read error: Connection reset by peer]
<jcowan_>
Also, there is a counterexample to the correctness-ueber-alles assumption, I think due to Ken Thompson but I'm not sure.
<jcowan_>
See [a large, long-running program with many bugs]? Which would prefer, eliminating 100 bugs, or making it run 100 times as fast?
rumbler31 has quit [Ping timeout: 264 seconds]
<jcowan_>
The plugin unifies REPL-testing with repeatable unit testing.
<verisimilitude>
I take it ``V'' is me, pfdietz.
<pfdietz>
Yes.
<pfdietz>
The reason I ask is that a lesson you have taken from a toy example of a few hundred lines will not apply to development of a system of many thousands or millions of lines.
<verisimilitude>
Well, I try very hard to not let any of my programs get larger than one thousand lines, if I can help it; one way I do this is by looking for functionality I can split off.
<pfdietz>
In large systems, testing is vital to prevent the system from regressing as it evolves.
<verisimilitude>
I'd be inclined to believe a project encompassing millions of lines is already doomed, one way or the other.
<pfdietz>
So, testing is unnecessary, if we define away the places where it is?
<pfdietz>
(is necessary)
<verisimilitude>
That sentence reminds me of the ending to ``AKIRA'', pfdietz, the idea of a system so grossly large evolving without regressions.
<pfdietz>
"Programming in the Large" is not the same as "Programming in the Small".
jibanes has quit [Ping timeout: 256 seconds]
<verisimilitude>
While I'm not going to claim a single man couldn't understand in its entirety a program that is millions of lines long, or any length, I will write that a program that a single man doesn't understand is too big.
<pfdietz>
Your personal distaste doesn't mean anything, of course.
<verisimilitude>
If you're making changes to a program and need tests because it is so grossly large that you can't be certain you've not made bad changes, it's too large.
<aeth>
verisimilitude: well, race car drivers wear helmets and seatbelts.
<aeth>
so some subset of people who drive professionally do wear helmets
<verisimilitude>
I will gladly concede, pfdietz, that tests are, perhaps, necessary for development of a large program if the designers are determined that no single man should understand it in its entirety.
mlf|2 has joined #lisp
mflem has joined #lisp
jibanes has joined #lisp
mlf|2 has quit [Client Quit]
<verisimilitude>
Hey, that also helps make programmers fungible, which is even better.
<verisimilitude>
That is an interesting observation with my analogy, aeth.
Lord_Nightmare has quit [Ping timeout: 264 seconds]
<verisimilitude>
So, I suppose we can agree that any redundant measures are good when lives are truly going to be at stake and when things are unnecessarily complicated.
<aeth>
jcowan_: That probably explains why chibi has good tests
<verisimilitude>
However, the vast majority of drivers don't wear helmets and writing tests is a waste of time and effort for the vast majority of programmers.
<pfdietz>
"Unnecessarily complicated"? Large programmings systems do things that toy program can't. You can't just say the problems they solve shouldn't be solved.
<jcowan_>
aeth: Actually no, I haven't productized the plugin, so nobody uses it but me
<verisimilitude>
It is usually trivial to prove a program can be smaller and simpler than it currently is, pfdietz.
<aeth>
verisimilitude: 1 million lines is almost certainly bad engineering, with few exceptions. Especially in a language like Lisp. 100,000 is definitely something you might see, though. e.g. Compiler, OS, web browser, game engine.
Lord_Nightmare has joined #lisp
<aeth>
Some things just require complexity, like OS drivers or supporting media formats. Although you could probably move those all into libraries.
<aeth>
(It will hurt performance for drivers, though.)
<pfdietz>
The real world is a messy and complex place, and real programs in that world become messy and complex things as a result. Real programs aren't large just to spite you.
<verisimilitude>
My larger point was that you should section off programs and, when known to work, seal them off so they need not be worried about again.
<verisimilitude>
You don't need tests after that point and I'd argue you don't need them before in most cases.
<aeth>
If only everything was modular
<aeth>
Modularity is hard for a lot of things
<verisimilitude>
Many things can be made modular.
<pfdietz>
In large, real programs testing is absolutely necessary to keep entropy at bay.
<verisimilitude>
Again, I don't want to conflate ``unit testing'' with actual testing.
<aeth>
verisimilitude: Breaking certain things up into thousands of libraries actually makes the task harder because the library function has to support general use but the application function can be very specific.
<doesthiswork1>
pfdietz: I like that that statement remains true for several different definitions of entropy
<verisimilitude>
There's a world of difference from making a change to a program, compiling it, and then checking that the changes work properly and ``abs(1)=1'' or, for poor languages, ``abs(MAX_INT)=1''.
<aeth>
verisimilitude: (abs most-positive-fixnum)
<verisimilitude>
That's true, aeth, but human judgment is supposed to intervene with things become unreasonable, one way or the other.
oleo has quit [Quit: Leaving]
<verisimilitude>
BIGNUMs and the numerical tower are beautiful, aeth.
rumbler31 has joined #lisp
<pfdietz>
Integration testing is no substitute for unit testing (and vice versa).
<aeth>
verisimilitude: It depends on if you want performance or correctness. Fortunately, in CL, you can choose between the two instead of having one chosen for you.
arescorpio has quit [Excess Flood]
<aeth>
(Well, sort of. You'd have to convince the compiler it's really still a fixnum, which isn't always easy.)
<verisimilitude>
The easiest way to do this, aeth, would be to define ABS in terms of more fundamental operations, until any necessary checking is done in very few or a single place.
rumbler31 has quit [Ping timeout: 268 seconds]
sauvin has joined #lisp
Kundry_Wag has joined #lisp
iqubic` has joined #lisp
jlarocco has joined #lisp
iqubic has quit [Read error: Connection reset by peer]
<verisimilitude>
With other implementations, I'm writing the same thing, but tcgetattr, tcsetattr, the constants, and other tidbits are real Lisp functions.
<verisimilitude>
A really good implementation makes the functions accept actual Lisp streams, but only Allegro does this that I'm currently aware of.
nckx has joined #lisp
<verisimilitude>
Allegro also provides a function specifically for enabling or disabling system echoing, which is more pleasant to work with than this.
rumbler31 has joined #lisp
<verisimilitude>
Of course, the implementations that provide these functions that want a file descriptor instead make you get the file descriptor from the stream and they're very unreasonable about it.
<verisimilitude>
You can't get the file descriptor of a synonym stream, as an example; no, you must get the stream it uses and then get that file descriptor.
hhdave has quit [Ping timeout: 264 seconds]
<verisimilitude>
This is just one reason to avoid nonstandard Common Lisp, most of the implementations provide horrible nonstandard APIs.
eagleflo has joined #lisp
angavrilov has joined #lisp
rumbler31 has quit [Ping timeout: 264 seconds]
hhdave has joined #lisp
ruste has joined #lisp
smokeink has quit [Quit: Leaving]
<Xof>
morning
EvW has joined #lisp
smokeink has joined #lisp
beach has joined #lisp
u0_a183 has left #lisp ["WeeChat 2.1"]
<theemacsshibe[m]>
morning Xof
damke has quit [Ping timeout: 264 seconds]
<beach>
Hey Xof. Where are you?
damke has joined #lisp
EvW has quit [Quit: EvW]
<ioa>
good morning! :)
<rme>
good late morning for a change
<beach>
Heh.
<beach>
rme: Are you planning to work today, or just take advantage of Marbella?
<rme>
today I am going to do laundry and take advantage of the time to explore the town
<beach>
Good idea.
dmiles has quit [Ping timeout: 260 seconds]
<beach>
ELS is great in that there are so many great exchanges of ideas in such a short period of time.
gigetoo has quit [Ping timeout: 260 seconds]
gigetoo has joined #lisp
rumbler31 has joined #lisp
_cosmonaut_ has joined #lisp
rumbler31 has quit [Ping timeout: 256 seconds]
siraben has quit [Remote host closed the connection]
atdmpz has joined #lisp
sjl has joined #lisp
krasnal has quit [Ping timeout: 256 seconds]
energizer has quit [Ping timeout: 240 seconds]
heisig has joined #lisp
sjl has quit [Ping timeout: 240 seconds]
krasnal has joined #lisp
milanj_ has quit [Quit: This computer has gone to sleep]
dmiles has joined #lisp
Bronsa has quit [Remote host closed the connection]
rumbler31 has joined #lisp
<beach>
I am preparing a talk for industry called "choosing a programming language". I am not pushing explicitly for Common Lisp, but I am giving several characteristics of different programming languages, and obviously, the language for which most good qualities add up is Common Lisp.
doesthiswork has joined #lisp
<beach>
But currently, the talk does not mention many languages, and I would like to add a list of languages for each quality that I am discussing.
<beach>
For one thing, I need a list of "single-implementation languages".
<beach>
I guess Clojure is in that group, right?
doesthiswork has quit [Client Quit]
rumbler31 has quit [Ping timeout: 268 seconds]
dmiles has quit [Ping timeout: 260 seconds]
elderK has joined #lisp
elderK has quit [Changing host]
elderK has joined #lisp
trigen has quit [Ping timeout: 260 seconds]
trigen has joined #lisp
cezary has quit [Remote host closed the connection]
heisig has quit [Quit: Leaving]
verisimilitude has quit [Remote host closed the connection]
dmiles has joined #lisp
rumbler31 has joined #lisp
<Xof>
beach: at the airport, by my gate now
<beach>
Ah, OK. Have a good flight.
<Xof>
beach: not quite; I think there are variants that run on top of javascript and .net
<beach>
Good to know. I'll investigate that. Thanks.
<Xof>
even PHP isn't really a single-implementation language (there's a facebook variant). Perl5, maybe?
<beach>
I guess I need to distinguish between "single implementation" and "defined by a reference implementation".
<Xof>
R might be a single-implementation language
<beach>
Yeah.
pierpal has joined #lisp
<beach>
I need to investigate Ruby, Scala, etc. as well.
<Xof>
Scala I think might well be single-implementation
<beach>
I think what I'll do is I'll work on the "slides" for the talk, and then submit them here again for comments.
verisimilitude has joined #lisp
<verisimilitude>
Python is effectively a single implementation language, since so much Python only works properly under it.
<verisimilitude>
There's also Emacs Lisp.
pierpal has quit [Ping timeout: 256 seconds]
<verisimilitude>
I suppose TeX counts.
drastik has joined #lisp
varjag has joined #lisp
milanj_ has joined #lisp
abeaumont has joined #lisp
drastik_ has quit [Ping timeout: 264 seconds]
scymtym has quit [Ping timeout: 240 seconds]
drastik_ has joined #lisp
drastik__ has joined #lisp
beach has left #lisp ["ERC Version 5.3 (IRC client for Emacs)"]
schweers has joined #lisp
drastik has quit [Ping timeout: 276 seconds]
verisimilitude has quit [Quit: ERC Version 5.3 (IRC client for Emacs)]
drastik_ has quit [Ping timeout: 240 seconds]
markong has joined #lisp
nowhereman_ has quit [Ping timeout: 256 seconds]
<smokeink>
I wouldn't call python a single implementation language , because it's split into python2 versus python3 and python2 is split into Wide and Narrow , and they're incompatible when dealing with unicode
<smokeink>
i'd just call it a total mess
<capisce>
maybe the single implementation distinction doesn't make that much sense
drastik has joined #lisp
<capisce>
open vs closed language design evolution?
rumbler31 has quit [Remote host closed the connection]
<Xof>
Emacs lisp has an implementation in guile, I believe
<Xof>
("fully compatible")
TCZ has joined #lisp
drastik__ has quit [Ping timeout: 256 seconds]
drastik_ has joined #lisp
<Xof>
TeX has multiple implementations: luaTeX is written in C, whereas regular TeX is in WEB/Pascal
<Xof>
depends what you call an implementation, I guess; is OCaml its own language, or an implementation of ML?
TCZ has quit [Client Quit]
drastik has quit [Ping timeout: 276 seconds]
Guest53448 is now known as SAL9000
scymtym has joined #lisp
DataLinkDroid has quit [Ping timeout: 240 seconds]
sjl has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
drastik_ has quit [Quit: WeeChat 1.9.1]
drastik has joined #lisp
sjl has quit [Ping timeout: 240 seconds]
nsrahmad has joined #lisp
fourier has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
milanj_ has quit [Quit: This computer has gone to sleep]
milanj has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
kerrhau has joined #lisp
kerrhau has joined #lisp
kerrhau has quit [Changing host]
pierpal has joined #lisp
fikka has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
atdmpz has quit [Remote host closed the connection]
kerrhau has quit [Ping timeout: 276 seconds]
atdmpz has joined #lisp
rumbler31 has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
nsrahmad has quit [Quit: Leaving]
rumbler31 has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
deng_cn1 has joined #lisp
fikka has joined #lisp
deng_cn has quit [Ping timeout: 268 seconds]
deng_cn1 is now known as deng_cn
fourier has quit [Ping timeout: 240 seconds]
terpri has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 240 seconds]
makomo has joined #lisp
milanj_ has joined #lisp
wxie has joined #lisp
_cosmonaut_ has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
milanj has quit [Read error: No route to host]
orivej has joined #lisp
milanj__ has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
milanj_ has quit [Ping timeout: 264 seconds]
<drunk_foxx[m]>
Why do you consider Python a single-implementation language? It has at least 7 of them
smokeink has quit [Remote host closed the connection]
jcowan has joined #lisp
jcowan_ has quit [Ping timeout: 265 seconds]
smokeink has joined #lisp
_cosmonaut_ has joined #lisp
<makomo>
hello
<makomo>
oh man, today was great. first time that i showed my lisp code for a laboratory exercise to the TA :')
<makomo>
he couldn't believe it, he started laughing
<schweers>
why? because lisp is so obscure?
<makomo>
he liked it thought, he was pretty mindblown i think
<schweers>
btw: hi ;)
<makomo>
i guess. i don't know if anyone ever did anything in lisp for a lab at our uni
<makomo>
or lisp in general lol
<makomo>
apart from the older professors maybe
fikka has joined #lisp
<makomo>
though*
<schweers>
our simulation methods professor refused to grade anything that was not C, C++ or Java
<schweers>
I suspect those are the only languages she knows
jack_rabbit has quit [Read error: Connection reset by peer]
<makomo>
yeah, it's the usual state of affairs
<makomo>
this in particular was for a "design patterns" course :')
<schweers>
lol
<schweers>
i.e. how to be a human macro expander
<makomo>
LOL exactly
<makomo>
well said
<schweers>
I remember that course very well
<makomo>
yeah, it's such crap
TCZ has joined #lisp
<makomo>
i mean, it's ok to recognize patterns in what you do, etc., but courses like these are always do dumb and rigid somehow
fikka has quit [Ping timeout: 256 seconds]
<makomo>
it's ok to have a common language for stuff we do as programmers
<schweers>
our professor (different prof) showed us the strategy pattern (if I recall correctly) in Java and I asked him if he was serious, because it looked like Object Oriented programming in C.
<makomo>
but this is just java in disguise
<makomo>
hahaha, we just did the strategy pattern ourselves
<makomo>
that was what the lab was about btw
<schweers>
i.e. a function as an argument?
<makomo>
yeah lol, pretty much
<schweers>
I didn’t even use lisp to demonstrate how silly this all was, using ruby or haskell was sufficient
<makomo>
of course in java that translates to interfaces and classes
<schweers>
not the plural ;)
<schweers>
*note
<makomo>
:-)
<makomo>
this lab was particularly fun because one of the exercises was implementing simple spreadsheet functionality
<makomo>
i.e. cells with references to each others and formulas
<makomo>
once i realized i could just stuff lisp code for formulas, that was it
<makomo>
other*
<schweers>
I find it weird that I can too get excited about stuff like that. I somehow think that this should be the most normal thing in this line of work.
fikka has joined #lisp
<makomo>
yeah :^/, that's how it is
<makomo>
one of the things i'm trying to do is to just convince people by example, instead of just talking about lisp and how great it is
<schweers>
how is that going so far?
<makomo>
pretty good. one guy has started using emacs and learning lisp :-)
<makomo>
another has started to see the power of lisp
<makomo>
bit by bit
<schweers>
cool
<schweers>
emacs lisp was how I finally found my way to lisp.
<makomo>
pretty much same here, but it was only recently that i really got into lisp
<schweers>
it is a sad state of affairs that I prefer elisp to most mainstream languages out there
fikka has quit [Ping timeout: 256 seconds]
<makomo>
sadly
ineiros has quit [Ping timeout: 246 seconds]
ineiros has joined #lisp
fikka has joined #lisp
_cosmonaut_1 has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
_cosmonaut_ has quit [Ping timeout: 265 seconds]
Kaisyu has joined #lisp
<theemacsshibe[m]>
There's a very bad joke I have
<theemacsshibe[m]>
The anti-Rust is Steel Wool Common Lisp.
drastik_ has joined #lisp
<theemacsshibe[m]>
Steel wool is more useful than steel banks.
wxie has quit [Read error: Connection reset by peer]
drastik has quit [Ping timeout: 256 seconds]
<jcowan>
Lisp normalizes things that are otherwise arcane
<jcowan>
"The only design pattern is to use the language."
<jcowan>
Of course, then you fall into "Curse of Lisp" territory
<schweers>
jcowan: I’m not really sure what to make of this alledged curse
<jcowan>
Oh, I have seen far too much of it.
<schweers>
I’m not so sure it really is as big as a problem as it seems
<jcowan>
"This interface implements only 10% of <random foreign library> cuz that's all I needed. YMMV."
<schweers>
there is incomplete software written in any language
<jcowan>
Oh, of course
<schweers>
from the authors perspective, your example isn’t even incomplete
<schweers>
he/she/it didn’t necessarily have to release it
<schweers>
but did anyway
<schweers>
so that’s a plus
dddddd has joined #lisp
scymtym has quit [Ping timeout: 256 seconds]
sheepduke has joined #lisp
fourier has joined #lisp
<sheepduke>
Hey, does anyone know how does clack handle static files? (Like CSS file included in a HTML etc)
fourier` has joined #lisp
fourier has quit [Ping timeout: 265 seconds]
fourier` has quit [Ping timeout: 276 seconds]
rumbler31 has joined #lisp
<jcowan>
schweers: It's a plus only if the code has widespread value
<jcowan>
often it's subtly wrong, and so people either fork it or discard it, and pretty soon everyone is effectively using their own code again
<schweers>
the more it is spread, the more value, but I would not say that just because it is not particularly widespread, that this is in and of itself a bad thing
<schweers>
I do think I see what you mean, I don’t think it is no problem at all, but I think it is blown out of proportion
<schweers>
I also wonder how this would play out if a large portion of our industry were to use (and appreciate) lisp
beach has joined #lisp
rumbler31 has quit [Ping timeout: 276 seconds]
Kundry_Wag has joined #lisp
asarch has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
LiamH has joined #lisp
fisxoj has joined #lisp
pierpal has joined #lisp
elderK has quit [Ping timeout: 240 seconds]
sjl has joined #lisp
<makomo>
i also have a hard time believing the "curse of lisp" thing
<makomo>
jcowan: the problem you describe is something i would attribute to lack of manpower and the size of the community
<jcowan>
Adding more manpower would make it worse
<ebrasca>
I think it is more easy to start someting than to finish someting.
<makomo>
i'm not really sure. what other reason is there for not implementing 100% of the bindings?
<jcowan>
For sure
<makomo>
it takes dedicationa and time to produce something good
<jcowan>
That the individual doesn't need all of them
<makomo>
dedication*
fikka has quit [Ping timeout: 240 seconds]
<ebrasca>
It take time and some people like to start new projects.
<makomo>
jcowan: true i guess, but how is this connected to the fact that lisp normalizes arcane things, etc.?
doesthiswork has joined #lisp
<makomo>
schweers: i also wonder the same thing
terpri has joined #lisp
<jcowan>
one of the examples from the original paper is "make C object oriented". This is so hard that it has only been done twice, and standardization on C++ and Objective-C has been fairly easy
fisxoj has quit [Quit: fisxoj]
<jcowan>
whereas "make Scheme object oriented" is a semester project, and so no OO system for Scheme has ever caught on; everyone rolls their own or does without
SenasOzys has quit [Ping timeout: 268 seconds]
<jcowan>
as things stand, only half of CLOS was ever standardized
damke_ has joined #lisp
<makomo>
hm i see, it's not as easy to standardize on something as it is in other languages, when everyone can just invent their own
<beach>
jcowan: What is the lesson to be learned from "only half of CLOS was ever standardized"?
<jcowan>
Just so
<makomo>
on the other hand, here we are with ASDF, Quicklisp, Alexandria, etc.
damke has quit [Ping timeout: 245 seconds]
<makomo>
it takes time i would say
<jcowan>
lisp is the oldest language still in use, given that Fortran has changed almost beyond recognition
<jcowan>
it should have the largest library in existence, but it doesn't
<beach>
jcowan: You are confused.
fikka has joined #lisp
<makomo>
to me, those were very different times
<jcowan>
Okay, I am willing to be enlightened
<beach>
Common Lisp is not the oldest language. It was standardized in 1984.
<jcowan>
That's when it was standardized, not when it was invented.
Folkol has quit [Ping timeout: 240 seconds]
<beach>
Common Lisp was invented a few years before that, yes.
<beach>
But not in 1958.
<jcowan>
McCarthy's original theorem prover still runs perfectly in any modern Lisp.
<drunk_foxx[m]>
Common Lisp is not the only Lisp
<beach>
jcowan: You are reversing the implication arrows.
<jcowan>
How so?
<beach>
jcowan: Furthermore, there is absolutely not reason to believe that the size of a library is proportional to the age of a language.
<beach>
jcowan: Good Common Lisp libraries would not run on LISP1.5, so they could not have been invented back then.
terpri has quit [Ping timeout: 256 seconds]
<beach>
jcowan: Anyway, you should have listened to R Matthew Emerson's invited talk.
<makomo>
can't wait for ELS videos
<beach>
He addresses the kind of attitude you have in a very precise and funny way.
<jcowan>
If there's a transcript someday, I'll read it
Folkol has joined #lisp
<makomo>
does anyone know when the videos will be up?
fikka has quit [Ping timeout: 240 seconds]
<beach>
jcowan: Ultimately, though, what is your point?
<beach>
jcowan: Common Lisp is not good enough for you? Then go elsewhere.
<beach>
jcowan: You think the Common Lisp community is not doing enough? Then pitch in.
<jcowan>
It's not personal, and I would prefer that you not make it personal.
<beach>
jcowan: Oh, I have no reason to be personally targeted here.
<jcowan>
You are personally targeting me.
zbir has joined #lisp
<beach>
jcowan: I am trying to show you how wrong your attitude is.
Patzy has quit [Quit: leaving]
<beach>
jcowan: Plus, it is based on false logic.
<ebrasca>
jcowan: I am not going to #java to say bad think about java.
<jcowan>
I am not saying bad things about Lisp, and neither is Weinstock
<jcowan>
or Tarver for that matter
<ebrasca>
yea value of some language is measured by libraries done / years
phax has joined #lisp
<dim>
guys, you can't fight in here, it's the war room!
* jcowan
laughs
<ebrasca>
dim: Are you sure it is war?
<jcowan>
Certainly not on my part.
<makomo>
huh wow, i just connected that tarver is the same guy who made shen
fikka has joined #lisp
<makomo>
realized*
<makomo>
didn't make the connection before
<beach>
jcowan: So I ask you again, what is the lesson to be learned from the fact that only half of CLOS was ever standardized?
terpri has joined #lisp
<beach>
jcowan: Do you mean "all of it is so good that it should have been in the standard, but the people writing the standard for some reason did not do it"?
<makomo>
what would some significant stuff from "the other half" of CLOS be?
<beach>
jcowan: Or do you mean "one should never include half of ANYTHING in any standard".
<jcowan>
makomo: I'm referring to the MOP. beach: Yes, except that it isn't "for some reason"
<makomo>
jcowan: ah, i thought so
<beach>
jcowan: So you mean, anything invented by anybody should have been included in the standard, either fully or not at all?
<jcowan>
beach: Of course not. That's the strawman fallacy.
<beach>
jcowan: Explain what you mean the.
phax has quit [Ping timeout: 256 seconds]
<jcowan>
Why was the MOP excluded from the CL standard?
<beach>
jcowan: Is it that CLOS MOP is what YOU would like to see included in the standard, so you lament the fact that it didn't happen?
<jcowan>
No, but it was part of the design from the beginning. What kept it out of the standard?
<dim>
no ready, underspecified, IIUC
fikka has quit [Ping timeout: 256 seconds]
<schweers>
did MOP just come late to the party? The authors of The Art of the Metaobject Protocol seem to have CLOS sans MOP as a prerequisite
<beach>
jcowan: Oh, I can answer that. For good reasons, the committee did not find the MOP to be sufficiently well specified and the specification did not have good enough quality for the language specification.
<beach>
jcowan: You should read the AMOP.
<jcowan>
I have done so.
<beach>
jcowan: The authors say something like "yeah, we know, this document is not good enough for a standard".
raynold has quit [Quit: Connection closed for inactivity]
fisxoj has joined #lisp
<jcowan>
rpg's article strongly suggests that the motives for rejecting it were rather more political than that, which makes the authors' remark quite likely to be an attempt to paper over a significant split in the community (also described by rpg)
<beach>
jcowan: OK, I now understand. YOU would have wanted the MOP to be in the standard, It isn't so now there is something wrong with the way the standard was created.
<jcowan>
Again, you're making it personal (ad hominem fallacy).
<jcowan>
Also putting words in my mouth.
<dim>
svillemot: btw the SBCL stanza to add to ~/.sbclrc that we talked about looks like: (sb-ext:restrict-compiler-policy 'debug 3)
<beach>
jcowan: I apologize for that. I should have said something like "so the only way I can interpret your previous statement is as if YOU..."
fikka has joined #lisp
fisxoj has quit [Quit: fisxoj]
<beach>
Anyway, time to do something else.
beach has left #lisp ["ERC Version 5.3 (IRC client for Emacs)"]
Bindler has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
Kundry_Wag has joined #lisp
fikka has joined #lisp
<tfb>
jcowan: at the time CLOS was arriving in CL there were really serious worries that it could not be implemented efficiently on stock hardware. Those worries were even more serious if a MOP was added: it is a long time since I read AMOP but I am not sure it provides an answer as to how slot access can be made really fast, for instance.
sheepduk` has joined #lisp
<svillemot>
dim: thanks!
<jcowan>
In general I believe the strategy to be: optimize the common case (e.g. classes whose metaclass is standard-class)
sheepduk` has quit [Remote host closed the connection]
warweasle has joined #lisp
<jcowan>
Not different in principle from JIT compilation, or noticing that a generic-math procedure (like +, not in the sense of generic functions) is actually being used only to add fixnums and implementing it that way
sheepduke has quit [Ping timeout: 256 seconds]
TCZ has quit [Quit: Leaving]
<tfb>
Yes of course: the question is does the AMOP MOP (as it existed in 1989 or whenever the cutoff date was) let you do that portably (with the things people knew how to do in 1989 -- remember that lots of people still believed that the right answer was HW still).
SenasOzys has joined #lisp
<tfb>
I think the right answer was 'punt until the next standard because we need to get this thing out of the door': no-one knew there would not be a next standard for a quarter of a century!
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
<jcowan>
rpg says (again, I have no ax to grind here) that delaying the MOP was probably a good idea, as it was still too implementation-centric; of course, nobody foresaw the collapse of CL standardization.
<tfb>
yes, he's right (remember he was behind one of the stock-hardware lisps): it was a good idea as it was not ready (my opinion of course, but I didn't know anyone who thought it was ready in my corner of the community)
damke has joined #lisp
shrdlu68 has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
damke has quit [Ping timeout: 264 seconds]
jdz has quit [Ping timeout: 256 seconds]
mn3m has joined #lisp
<Xof>
howdy, tfb
<Xof>
wait, which tfb are you?
<Xof>
tfb or tfeb?
Patzy has joined #lisp
<tfb>
there was another tfb who was a cll person too (Thomas Burdick?) but I both tfb and when I can't get that tfeb
damke_ has joined #lisp
oleo has joined #lisp
jdz has joined #lisp
<Xof>
Yes, Thomas Burdick and Tim Bradshaw. Long time no see
<rme>
good old three-letter nicks
<tfb>
I hd to kill him as he kept getting my username. Sad, but it had to be done.
* rme
nods
<jcowan>
at one time on another freenode channel there was a huge fad for 3LNs; since I was the only one with a 6LN, my lines stood out like a sore thumb
<tfb>
Serious question though: are there any non-spammy Lisp fora now which are not this one or reddit (which I am in recovery from)
<jcowan>
if you mean completely spam-free, probably not, but c.l.l. is not very spammy except for MY USERNAME IS THE SAME AS MY SUBJECT LINE guy.
<sjl>
there's a discord that some folks use
makomo has quit [Ping timeout: 240 seconds]
damke has joined #lisp
<tfb>
jcowan: tha ks perhaps I will look at cll again if I can find a newsreader (or remember how gnus works)
<jcowan>
you can use an rss reader
<schweers>
do any of you folks employ any technique to remove string literals (or any larger literal values) from your source code? My main motivation is in order to avoid having to deal with linebreaks and indentation in the string literals. But I also like the idea of having all relevant strings in one place.
<rme>
Is that obsessive-compulsive poster still there posting his unasked-for solutions to various questions in whatever programming language he is interested in at the time?
<rme>
looks like he is
Satou has joined #lisp
<jcowan>
Gavino, you mean?
<loke>
rme: Yes
<loke>
jcowan: No. WJ
<loke>
ALthough he changed his name
damke has quit [Ping timeout: 264 seconds]
<jcowan>
yeah, Gavino just asks unanswerable questions
<loke>
I honestly have to admire, in some sick way, his ability to keep up that nonsense. He must spend a ridiculous amout of time doing this, and to do it for years.
Satou has left #lisp [#lisp]
<tfb>
loke: WJ is why I stopped reading CLL
<loke>
tfb: Indeed
<loke>
it's bizarre
<shrdlu68>
Bot, perhaps.
<tfb>
I think he must be ill sadly
<loke>
tfb: Very likely.
makomo has joined #lisp
<loke>
shrdlu68: If it's a bot, I'd be very surprised, and impressed. Also, I just decided to check the current state and one of his drecent posts is actually a correction for a bug in a previous post.
<loke>
Yes. Very, VERY bizarre
<tfb>
jcowan: thks for google groups URL
<jcowan>
Sure thing
<jcowan>
Newsreaders do have kill files, RSS readers not so much
<jcowan>
the trouble with CAPS GUY is that he keeps changing his identity
himmAllRight has joined #lisp
nowhereman_ has joined #lisp
damke has joined #lisp
atdmpz has quit [Remote host closed the connection]
Cymew has quit [Remote host closed the connection]
damke_ has joined #lisp
damke has quit [Ping timeout: 264 seconds]
BitPuffin has joined #lisp
atdmpz has joined #lisp
shrdlu68 has quit [Ping timeout: 268 seconds]
Cymew has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Remote host closed the connection]
damke_ has joined #lisp
Kundry_Wag has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
Bindler has quit [Read error: Connection reset by peer]
Cymew has joined #lisp
makomo has quit [Quit: WeeChat 2.0.1]
Fare has quit [Ping timeout: 268 seconds]
random-nick has joined #lisp
Cymew has quit [Ping timeout: 264 seconds]
jjkola_ has joined #lisp
Cymew has joined #lisp
jjkola has quit [Ping timeout: 240 seconds]
nowhere_man has joined #lisp
nowhereman_ has quit [Read error: Connection reset by peer]
FreeBirdLjj has joined #lisp
Cymew has quit [Ping timeout: 260 seconds]
makomo has joined #lisp
Cymew has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
blackwolf has joined #lisp
Cymew has quit [Ping timeout: 260 seconds]
Naergon has joined #lisp
Cymew has joined #lisp
<adlai>
tfb: wait, a quarter of a century has gone by. there's a new standard!?
Fare has joined #lisp
<tfb>
adlai: no, I suppose I meant >
smokeink has quit [Ping timeout: 260 seconds]
mflem has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
johnvonneumann_ has quit [Remote host closed the connection]
johnvonneumann has quit [Remote host closed the connection]
atdmpz has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 240 seconds]
gledos has joined #lisp
Cymew has joined #lisp
fikka has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
_cosmonaut_1 has quit [Ping timeout: 264 seconds]
LiamH has quit [Quit: Leaving.]
fikka has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Remote host closed the connection]
gledos has left #lisp ["Leaving"]
Fare has quit [Ping timeout: 268 seconds]
gigetoo has quit [Ping timeout: 256 seconds]
al-damiri has joined #lisp
gigetoo has joined #lisp
fikka has joined #lisp
quazimodo has quit [Ping timeout: 256 seconds]
scymtym has joined #lisp
quazimodo has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
igemnace has quit [Quit: WeeChat 2.1]
daniel-s has quit [Remote host closed the connection]
zbir has quit [Ping timeout: 256 seconds]
zbir has joined #lisp
fikka has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
pfdietz2 has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
<pfdietz2>
I gave up on cll and usenet in general years ago.
fourier` has joined #lisp
<jcowan>
adlai, tfb: Technically no, the ANSI standard wasn't published until 1994, so only 24 years ago
mn3m has quit [Ping timeout: 256 seconds]
varjag has joined #lisp
fikka has joined #lisp
damke has joined #lisp
fourier` has quit [Quit: ERC (IRC client for Emacs 25.3.50.3)]
<tfb>
jcowan: 24 is 25 to a very good approximation to a physicist
<jcowan>
True
fourier has joined #lisp
<tfb>
but yes, we have a year to make a new standard, we should all now go mad...
<jcowan>
3 is prime, 5 is prime, 7 is prime, 9 is experimental error, 11 is prime ...
* tfb
trying to think what the right term for 'actually laughs out loud' now is
beach has joined #lisp
<TMA>
we all know, that if log(x) = log(y) then x = y. logarithm of both is 1.4 therefore...
damke_ has quit [Ping timeout: 264 seconds]
<jcowan>
How about "/me lols irl"?
Fare has joined #lisp
SenasOzys has quit [Ping timeout: 276 seconds]
SenasOzys has joined #lisp
<adlai>
madness? standardization? i volunteer as tribute!
jlarocco has quit [Ping timeout: 256 seconds]
Fare has quit [Ping timeout: 240 seconds]
happy-dude has joined #lisp
cage_ has joined #lisp
surya has joined #lisp
damke has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
fourier has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
lnostdal has quit [Ping timeout: 256 seconds]
<ebrasca>
Is not cl21 this new standardization?
<beach>
I should hope not.
<Xof>
we're already ~20% of the way through the 21st century
<Xof>
better start working on cl22
Karl_Dscc has joined #lisp
beach has left #lisp ["ERC Version 5.3 (IRC client for Emacs)"]
margeas has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
Fare has joined #lisp
atdmpz has joined #lisp
damke_ has joined #lisp
markong has quit [Ping timeout: 256 seconds]
Kundry_Wag has quit [Remote host closed the connection]
margeas has quit [Ping timeout: 240 seconds]
damke has joined #lisp
Kundry_Wag has joined #lisp
atdmpz has quit [Ping timeout: 256 seconds]
hhdave has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
damke_ has quit [Ping timeout: 260 seconds]
Kundry_Wag has quit [Ping timeout: 256 seconds]
zbir has quit [Ping timeout: 268 seconds]
fikka has quit [Ping timeout: 240 seconds]
phoe has quit [Ping timeout: 265 seconds]
phoe has joined #lisp
<dim>
last I had a look at it, it seemed to me that cl21 was attempting to provide solutions to things that are not a problem...
Josh_2 has joined #lisp
fikka has joined #lisp
<tfb>
It seems to me that, if there were to be another standard, the things to concentrate on would be things that can't be simply done in portable CL
fikka has quit [Ping timeout: 256 seconds]
borei has joined #lisp
<borei>
hi all !
Kundry_Wag has joined #lisp
shka_ has joined #lisp
<ebrasca>
tfb: Can you give some example?
<tfb>
ebrasca: unicode...
<ebrasca>
But he make some good like change pi to +pi+ .
<tfb>
everyone needs it, everyone has it, all the implementations are different
energizer has joined #lisp
fikka has joined #lisp
hh48 has joined #lisp
hh48 is now known as hh47
<dim>
unicode, sockets/network, threading and dynamic environments and IPC, maybe some more advanced app building blocks such as a reference HTTP cient and server, and I would love to have a pure-CL secure socket (TLS?) but I wonder if that's material for a standard...
* dim
is afk now
<borei>
I have some generic question, not neccessary related directly to lisp, but rather to the programming overall. So i have program, there are several objects that are evolved based on program logic, actually there are a lot of object. I need to track object "version", so if one object is updated, objects related on it will be updated as well. Introducing "version" parameter for each object should solve propblem up to certain level, but i thin
<borei>
k if objects relation-shipt will be more complex it will be dead direction.
fikka has quit [Ping timeout: 264 seconds]
<borei>
need some heads-up from experienced programmers
<tfb>
borei: you probably want a dependency protocol such that objects know their dependents and updates get propagated through the graph
<borei>
so it's sort of sparce matrix where i can track "version" of the links between related objects ?
<nirved>
i remember cells had some dependency built-in
<tfb>
The CLOS MOP has an example of such a thing although it is slightly special-purpose (and I know there's a copy of the right chapter online but I can't find it now)
damke has quit [Read error: Connection reset by peer]
Fare has quit [Ping timeout: 240 seconds]
damke_ has joined #lisp
Fare has joined #lisp
zbir has joined #lisp
Selwyn has joined #lisp
hh47 has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
vtomole has joined #lisp
surya has quit [Ping timeout: 264 seconds]
ldb has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
drastik has joined #lisp
drastik_ has quit [Ping timeout: 264 seconds]
zbir has quit [Ping timeout: 240 seconds]
random-nick has quit [Ping timeout: 240 seconds]
zbir has joined #lisp
atdmpz has joined #lisp
<ldb>
just found '(#1=((1) a) #1#) is not literally equivalent to '(((1) a) ((1) a))
<drunk_foxx[m]>
Guys, is anyone here familiar with the University of Oslo course in Algorithms for AI and NLP, featuring Common Lisp? It's listed on Cliki, and I wonder is it worth taking, so asking for opinions
atdmpz has quit [Remote host closed the connection]
zbir has quit [Ping timeout: 240 seconds]
atdmpz has joined #lisp
<makomo>
ldb: in the sense that the first shares structure while the second doesn't?
schoppenhauer has quit [Ping timeout: 264 seconds]
atdmpz has quit [Remote host closed the connection]
<makomo>
drunk_foxx[m]: i've skimmed the 2 videos where they introduce common lisp but that's all
<makomo>
it's the basic introduction to CL. i'm not sure how they use CL later on in the course itself
jcowan has quit [Ping timeout: 256 seconds]
ldb has quit [Quit: Lost terminal]
SenasOzys has quit [Ping timeout: 240 seconds]
schoppenhauer has joined #lisp
sauvin has quit [Remote host closed the connection]
<LdBeth>
makomo: yes
jcowan has joined #lisp
Selwyn has quit [Remote host closed the connection]
hh47 has joined #lisp
raynold has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
nika has quit [Quit: Leaving...]
Kundry_Wag has joined #lisp
SenasOzys has joined #lisp
pierpal has quit [Ping timeout: 276 seconds]
vtomole has quit [Ping timeout: 260 seconds]
SenasOzys_ has joined #lisp
SenasOzys has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Ping timeout: 256 seconds]
damke has joined #lisp
zbir has joined #lisp
atdmpz has joined #lisp
pierpal has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
jjkola_ has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
zbir has quit [Ping timeout: 246 seconds]
pierpal has quit [Ping timeout: 246 seconds]
jjkola_ has joined #lisp
Kundry_Wag has joined #lisp
Cymew has quit [Ping timeout: 246 seconds]
fikka has joined #lisp
Cymew has joined #lisp
quazimodo has quit [Ping timeout: 256 seconds]
drastik_ has joined #lisp
zbir has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
drastik has quit [Read error: Connection reset by peer]
quazimodo has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
zbir has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
comborico1611 has joined #lisp
jjkola_ is now known as jjkola
fikka has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
zbir has joined #lisp
damke_ has joined #lisp
Cymew has joined #lisp
aeth has quit [Read error: Connection reset by peer]
aeth has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
damke has quit [Ping timeout: 264 seconds]
drastik has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
drastik_ has quit [Ping timeout: 240 seconds]
Kevslinger has joined #lisp
shka_ has quit [Ping timeout: 260 seconds]
<Xof>
tfb: "dependent maintenance protocol"
<phoe>
aaaah, I am in Poland
cage_ has quit [Quit: Leaving]
Cymew has joined #lisp
atdmpz has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 265 seconds]
drastik_ has joined #lisp
Cymew has joined #lisp
hh47 has quit [Quit: hh47]
drastik has quit [Ping timeout: 256 seconds]
damke has joined #lisp
PinealGlandOptic has joined #lisp
fourier has joined #lisp
Cymew has quit [Ping timeout: 276 seconds]
Cymew has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
stacksmith has joined #lisp
<stacksmith>
Good morning!
Cymew has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
<stacksmith>
Is there a way to query current ASDF system name, suitable for asdf:system-relative-pathname?
<Shinmera>
"current"?
<Shinmera>
Current during what
<stacksmith>
Hmm. Runtime. In initialization code.
<Shinmera>
Huh?
<phoe>
stacksmith: what do you mean, in initialization code?
<Shinmera>
If you mean the system of your own project, well, you better know the name yourself.
<phoe>
you got the dependencies wrong. your code *knows* what system it is in if it's ASDF-loaded.
<Shinmera>
If you mean the system that's being operated on during load, there's no way to get it outside of the individual perform calls, if I remember correctly.
<phoe>
because your ASD file explicitly declares to load that file. therefore there's a 1-to-N mapping between ASD system and a file.
Cymew has quit [Ping timeout: 240 seconds]
<Shinmera>
Eh, actually, I suppose you can traverse the component tree to the root to get the system from inner perform calls.
<stacksmith>
Agreed. However, I just spent 20 minutes tracking down a stupid bug after renaming a system - it loaded fonts from a wrong directory...
Cymew has joined #lisp
drastik has joined #lisp
<stacksmith>
So I am just trying to find the path to the system that was loaded, until I figure out a more rigorous way to maintain resources...
<Shinmera>
For paths relative to your sources I prefer to figure out the directory without ASDF by using something like: (defvar *here* #.(make-pathname :name NIL :type NIL :defaults (or *compile-file-pathname* *load-pathname* (error "Compile or load this file."))))
<stacksmith>
It seemed that declaring a global to hold the system name is more wrong than querying ASDF, - it obviously has it somewhere.
<stacksmith>
Unless I am misunderstanding the goals of ASDF, which is likely.
drastik_ has quit [Ping timeout: 265 seconds]
zbir has quit [Ping timeout: 268 seconds]
zbir has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
<stacksmith>
Is there some convention for keeping resources in a known place with ASDF?
<stacksmith>
By resources I mean things other than Lisp sources...
drastik_ has joined #lisp
smasta has joined #lisp
vlatkoB has quit [Remote host closed the connection]
drastik has quit [Ping timeout: 264 seconds]
wigust has quit [Ping timeout: 256 seconds]
anaumov has joined #lisp
Cymew has joined #lisp
drastik has joined #lisp
BlueRavenGT has joined #lisp
<phoe>
stacksmith: other than Lisp sources you mean
<phoe>
so not relative to asdf:system-relative-pathname?
<phoe>
and you mean for development, not for deployment?
<stacksmith>
I think my issue is this: If I want to change the system name, say because I have a few versions I need to keep around (during development), I have to change the .asd file, the contents of the .asd file, and the directory name. Going through source looking for symbols that match the name seems just wrong. Am I being foolish or grossly missing the point?
<phoe>
I remember that #lispgames had some resources for that, because they use external assets a lot and have to bundle them into an executable when they buildops
<phoe>
wait, symbols that match?
drastik_ has quit [Ping timeout: 246 seconds]
<phoe>
which symbols that match the name?
<phoe>
only ASD files need to be updated
<phoe>
if you have system FOO and systems BAR and BAZ that depend on FOO
<phoe>
then you change the name of FOO to FRED, and you need to update foo.asd (change system name and file name), and bar.asd and baz.asd (change dependency name)
<phoe>
that's all.
fikka has joined #lisp
frgo has quit [Ping timeout: 256 seconds]
Cymew has quit [Ping timeout: 264 seconds]
<stacksmith>
phoe: I don't even have dependent system - I am just trying to keep foo1 and foo2 around. However I was loading data from a path relative to where 'foo lived.
Cymew has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
BlueRavenGT has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Cymew has quit [Ping timeout: 256 seconds]
fourier has quit [Ping timeout: 256 seconds]
Anthaas_ has joined #lisp
frgo has joined #lisp
milanj__ has quit [Quit: This computer has gone to sleep]
Cymew has joined #lisp
drastik_ has joined #lisp
drastik has quit [Ping timeout: 264 seconds]
Cymew has quit [Ping timeout: 256 seconds]
<stacksmith>
OK, thanks. I just need to grow a brain and learn to think with it.
<phoe>
stacksmith: wait, you change ASD files for some kind of versioning?
Cymew has joined #lisp
<phoe>
if anything, define a system called FOO.RESOURCES or something and use that
lnostdal has joined #lisp
<phoe>
and in other files use (asdf:system-relative-pathname :foo.resources "bar/baz/quux.jpg")
<phoe>
that's for development
<phoe>
for deployment, ask around on #lispgames
<stacksmith>
I just copied the directory with my old system, giving it a new name. Then, I had to change the asdf file name and contents, to avoid clashing with the old system. I thought that's enough for a quick and dirty way to try something new with the old system around. Then, I realized that there are hardwired references to system name, which I thought could be abstracted by querying ASDF.
<stacksmith>
I haven't thought about defining a separate system for resources... That would work.
Cymew has quit [Ping timeout: 240 seconds]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
<phoe>
afk, time to bus
<stacksmith>
Thanks, phoe and Shinmera.
Cymew has joined #lisp
drastik has joined #lisp
jmercouris has joined #lisp
Cymew has quit [Ping timeout: 265 seconds]
Cymew has joined #lisp
<Josh_2>
stacksmith: brains are overrated just become a plant
drastik_ has quit [Ping timeout: 268 seconds]
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
fourier` has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
khisanth__ has quit [Ping timeout: 276 seconds]
milanj__ has joined #lisp
bakkal has quit [Ping timeout: 240 seconds]
SenasOzys_ has quit [Ping timeout: 264 seconds]
Baggers has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
Mutex7 has joined #lisp
lnostdal has quit [Ping timeout: 268 seconds]
Cymew has joined #lisp
energizer has quit [Ping timeout: 264 seconds]
Guest6423 has quit [Ping timeout: 260 seconds]
Achylles has joined #lisp
drastik_ has joined #lisp
drastik has quit [Read error: Connection reset by peer]
khisanth__ has joined #lisp
jmercouris has quit [Ping timeout: 260 seconds]
SenasOzys_ has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
markong has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
smasta has quit [Read error: Connection reset by peer]
smasta has joined #lisp
pierpal has joined #lisp
Karl_Dscc has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
pierpal has quit [Client Quit]
LiamH has joined #lisp
pierpal has joined #lisp
drastik has joined #lisp
Cymew has joined #lisp
drastik_ has quit [Read error: Connection reset by peer]
zbir has quit [Ping timeout: 256 seconds]
Cymew has quit [Ping timeout: 256 seconds]
johnnymacs has quit [Ping timeout: 276 seconds]
Cymew has joined #lisp
damke has quit [Ping timeout: 264 seconds]
Cymew has quit [Ping timeout: 264 seconds]
hhdave has joined #lisp
Cymew has joined #lisp
<jcowan>
plants don't eat food or pay rent
Folkol has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
Cymew has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
jcowan_ has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
jcowan has quit [Ping timeout: 260 seconds]
jack_rabbit has joined #lisp
<aeth>
depends on the plant
Cymew has joined #lisp
<aeth>
some plants eat insects; certain trees (e.g. fruit trees) "pay rent"
iqubic has quit [Ping timeout: 265 seconds]
<jack_rabbit>
Does anyone know what's up with the development of quicklisp? The client doesn't seem to have any commits on github in > 1 year, yet issues are being resolved. Are they keeping the working repo somewhere else?
ruste has quit [Ping timeout: 265 seconds]
Cymew has quit [Ping timeout: 256 seconds]
Achylles has quit [Ping timeout: 256 seconds]
<adlai>
jack_rabbit: irc moves slowly, please wait for an answer to your question :)
<aeth>
Some are rejected feature requests, many are upstream implementation bugs.
__rumbler31 has joined #lisp
<jack_rabbit>
I see. I should have looked more closely. I guess I was mostly surprised that there were no commits in the last year, but "if it ain't broke..."
Cymew has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
angavrilov has quit [Remote host closed the connection]
<stacksmith>
Not messing with things that work is a wonderful thing.
LiamH has quit [Quit: Leaving.]
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Anthaas_ has quit [Ping timeout: 268 seconds]
himmAllRight has quit [Quit: WeeChat 2.0.1]
Cymew has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
__rumbler31 has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 240 seconds]
hhdave has quit [Quit: hhdave]
Cymew has joined #lisp
hhdave has joined #lisp
fourier` has quit [Ping timeout: 240 seconds]
kerrhau has joined #lisp
kerrhau has quit [Changing host]
kerrhau has joined #lisp
Cymew has quit [Ping timeout: 264 seconds]
Cymew has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
BlueRavenGT has joined #lisp
Baggers has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 265 seconds]
energizer has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Cymew has joined #lisp
hhdave has quit [Quit: hhdave]
pfdietz2 has quit [Ping timeout: 256 seconds]
cpc26_ has quit []
cpc26 has joined #lisp
cpc26 has quit [Changing host]
cpc26 has joined #lisp
energizer has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 265 seconds]
Cymew has joined #lisp
Kundry_Wag has joined #lisp
__rumbler31 has joined #lisp
DataLinkDroid has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Cymew has joined #lisp
smasta has quit [Ping timeout: 256 seconds]
Kevslinger has quit [Quit: Connection closed for inactivity]
ruste has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
Fare has quit [Ping timeout: 256 seconds]
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
asarch has quit [Quit: Leaving]
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
Guest6344 has joined #lisp
BlueRavenGT has quit [Read error: Connection reset by peer]
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
jealousmonk has joined #lisp
smasta has joined #lisp
jstypo has joined #lisp
sea has joined #lisp
<sea>
Apparently, iterating over a list is faster than iterating over a vector. Why?
jcowan_ is now known as jcowan
<sea>
(time (loop for i in l)) and (time (loop for j being the elements of v)), where v and l are a vector and a list, both with the same number of elements (same elements, in fact)
<sea>
<sea>
The second one is almost 10x slower
<sea>
oh wait, nvm
Cymew has quit [Ping timeout: 256 seconds]
<ebrasca>
sea: I think it is related with predicting next step to execute in cpu.
smasta has quit [Ping timeout: 240 seconds]
<sea>
I don't think that's it, because then the results would be backwards. The vector has better locality and branch prediction
<sea>
but it's slower
<aeth>
In general, vector operations will be *faster*, especially if the complete type (which includes the length!) is known.
<aeth>
Is it possible that the loop is doing a bounds check each iteration?
<sea>
I don't know. That's the full code of my test right there
<aeth>
Try disassembling a function with it
Cymew has joined #lisp
<aeth>
What implementation is this?
<sea>
SBCL
varjag has quit [Ping timeout: 268 seconds]
<edgar-rft>
AFAIK it's (loop for i in <list>) and (loop for i across <vector>)
PinealGlandOptic has quit [Quit: leaving]
<aeth>
Well I cannot reproduce it.
<sea>
Okay so I changed it to 'across' instead of 'being the elements of'. It's much faster now, but the vector loop is still slower, by a factor of..4
__rumbler31 has quit [Remote host closed the connection]
<aeth>
(defun foo (v) (loop for j being the elements of v do (print j))) (defun bar (v) (loop for j being the elements of v do (print j))) (let ((l (list 1 2 3 4 5))) (time (foo l))) (let ((v (vector 1 2 3 4 5))) (time (bar v)))
<aeth>
When testing this sort of thing, (1) always define a function and (2) always initialize the outside data structure outside of the time
Cymew has quit [Ping timeout: 256 seconds]
<sea>
I'm doing this:
<sea>
(let ((v (coerce (iota k) 'vector)) (l (iota k))) (time (loop for i in l)) (time (loop for j across v)))
<sea>
and k is 100,000
<sea>
So both time calls are separate, and it's initialized outside of it
Fare has joined #lisp
blackwolf has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
Cymew has joined #lisp
Bike has joined #lisp
<aeth>
okay: (defun foo (l) (loop for i in l do (format nil "~D " i))) (defun bar (v) (loop for j being the elements of v do (format nil "~D " j))) (let ((l (iota 100000))) (time (foo l))) (let ((v (coerce (iota 100000) 'vector))) (time (bar v)))
<sea>
When I switched to your code, and took out the print, I had to use k = 1,000,000 before the difference showed up. The vector one is half as fast
<aeth>
for me, v is winning in processor cycles most times I run that
<aeth>
One issue, though, is that it's generating a ton of garbage.
<sea>
When I run your exact code here, I get respectively:
<sea>
Oh, your exact code doesn't have the vector slower
<sea>
weird
<sea>
but when I swap in 1 million instead, it becomes slower again
Fare has quit [Ping timeout: 240 seconds]
<aeth>
It might be better to use (sb-profile:profile foo bar) instead of using time
Cymew has quit [Ping timeout: 256 seconds]
<sea>
bar is slower in the profiler. 0.380999 sec/call, compared to 0.354999 sec/call for foo
Cymew has joined #lisp
<sea>
bar spends more time in the GC for some reason
<aeth>
The trick might be to find something that generates less garbage but that isn't optimized away
<aeth>
GC noise might be overwhelming anything meaningful
<sea>
but why is it consistently on bar?
<aeth>
try running them in the reverse order!
<aeth>
bar might be the loser because it runs second
<sea>
Hrm, ran it in reverse order. The times are much closer, but bar still spends more time in the GC
<sea>
even when I swap to 'across' in the loop
<sea>
[ Run times consist of 0.920 seconds GC time, and 3.040 seconds non-GC time. ] for bar
TCZ has joined #lisp
<sea>
[ Run times consist of 0.383 seconds GC time, and 2.981 seconds non-GC time. ] and foo
<sea>
It must be the loop macro doing something
Cymew has quit [Ping timeout: 260 seconds]
<aeth>
This removes garbage... and the vector loses a lot. (I used do just to keep it consistent.)
<aeth>
(defun foo (l) (let ((sum 0)) (loop for i in l do (incf sum i)) sum)) (defun bar (v) (let ((sum 0)) (loop for j being the elements of v do (incf sum j)) sum)) (let ((l (iota 100000))) (time (foo l))) (let ((v (coerce (iota 100000) 'simple-vector))) (time (bar v)))
Josh_2 has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
Cymew has joined #lisp
<sea>
What's the difference between 'vector and 'simple-vector?
Bike has quit [Ping timeout: 240 seconds]
<aeth>
This gets the vector to win: (defun foo (l) (let ((sum 0)) (loop for i in l do (incf sum i)) sum)) (defun bar (v) (declare ((simple-array fixnum (100000)) v)) (let ((sum 0)) (loop for j across v do (incf sum j)) sum)) (let ((l (iota 100000))) (time (foo l))) (let ((v (coerce (iota 100000) '(simple-array fixnum (100000))))) (time (bar v)))
<aeth>
Even with * instead of 100000
<LdBeth>
sea: simple vector does not have point-filler
<sea>
bar is 4x slower
<sea>
running your exact code again
<LdBeth>
fill-pointer
<aeth>
sea: Do you have (debug 3) or something?
<sea>
I think so. I took that off. Now I'm running with: (declaim (optimize (debug 0) (speed 3) (space 0)))
<aeth>
well, you can just do it locally in bar
<aeth>
(defun foo (l) (let ((sum 0)) (loop for i in l do (incf sum i)) sum)) (defun bar (v) (declare (optimize (speed 3) (debug 1)) ((simple-array fixnum (*)) v)) (let ((sum 0)) (loop for j across v do (incf sum j)) sum)) (let ((l (iota 100000))) (time (foo l))) (let ((v (coerce (iota 100000) '(simple-array fixnum (*))))) (time (bar v)))
<sea>
837,554 processor cycles vs 6,534,470 processor cycles and this time, it takes 8x as long!
Mutex7 has quit [Quit: Leaving]
<aeth>
that is strange, I don't get that
<aeth>
I get the same time.
Cymew has quit [Ping timeout: 256 seconds]
<aeth>
Both in time and sb-profile
<sea>
this is interesting. If I repeatedly run bar, the time varies kinda wildly
Fare has joined #lisp
<aeth>
and making it longer (1 million instead of 100k) has bar win
<aeth>
sea: yeah, that's why sb-profile:report is better.
<aeth>
Run it many, many, many, many times and look at the sec/call
Cymew has joined #lisp
<aeth>
assuming you did (sb-profile:profile foo bar)
<sea>
I'm running it 100 times with profiling on and reset
<aeth>
My latest bar has this: (declare (optimize (speed 3) (debug 1)) ((simple-array fixnum (*)) v))
Achylles has joined #lisp
<aeth>
It's simple-array that contains fixnums, which should certainly make it win.
<aeth>
Your bar looks like a much earlier version
damke has joined #lisp
<aeth>
The one that's generic for all sequences
<sea>
Hang on then. I'll put in your declare in my bar
<aeth>
Generic sequence and number code is almost always going to lose to specific sequence and number code in performance. They're basically the only two areas where type declarations are very useful for performance ime.
<jack_rabbit>
It doesn't matter the data type if the code iterating through it is for generic sequences.
<sea>
I need to alter the coerce as well. How do I coerce something to be a simple array of fixnums?
<aeth>
jack_rabbit: but my SBCL still optimizes bar once it knows that it is a simple-array fixnum (*)
<sea>
I get type errors when I try to call bar otherwise
<jack_rabbit>
aeth, Yes, you are correct. I was speaking to sea, not you.
<aeth>
sea: you have to coerce it to '(simple-array fixnum (*))
Cymew has quit [Ping timeout: 268 seconds]
<aeth>
sea: If it can only hold something of one non-T type, it's going to be a different thing than something that holds something of T
<sea>
Okay so, I reset the profiler, re-profiled foo and bar, and ran them 100x
<aeth>
You win twice with an array type like I just gave (three times if a length is given): (1) it knows it's a certain kind of sequence and (2) it can infer what type the items are, which usually cannot be done
<aeth>
Unfortunately, this only applies to a small number of things. Portably just bit and character. Non-portably, a bunch of other numeric types like (almost always) single-float and (unsigned-byte 8) and fixnum
<aeth>
An array with an element-type should almost always be the most performant kind of sequence (or data structure in general) in Common Lisp. It will even beat lists at some things that lists are supposed to be better at.
<aeth>
It's really the one optimization always worth doing if you can get away with it.
<sea>
That's how I discovered this in the first place. I was timing an 'optimized' program, and found it got slower
Cymew has quit [Ping timeout: 260 seconds]
markong has quit [Ping timeout: 256 seconds]
<sea>
and the thing is that along with the time: 445,976 processor cycles , 4,636,812 processor cycles I get a tonne of time results printed as well, and they all basically look like this. The vector one is much larger
Cymew has joined #lisp
<aeth>
Try restarting CL?
energizer has joined #lisp
<sea>
Okay, restarted and re-evaluated what I had in the paste before. 0.148 seconds for bar, and 0.014 seconds for foo
Kaisyu has joined #lisp
<sea>
Maybe my processor has some kind of issue that makes it slower on the vector version.
Kundry_Wag has joined #lisp
<pierpa>
arrays with an element-type are not necessarily more performant than arrays with generic element types. It depends on what/when/how much the elements needs unboxing and reboxing.
Cymew has quit [Ping timeout: 260 seconds]
<pillton>
The disassemble of bar shows that it calls make-sequence-iterator.
<pillton>
Which means it is calling a function to get the next element.
energizer has quit [Remote host closed the connection]
Cymew has joined #lisp
<pillton>
Disassemble (loop for j across v) and you see that it does not.
energizer has joined #lisp
<sea>
hang on that might not be the latest disassemble. This one is here:
<pierpa>
nobody can tell you why "being the elements" is slow since "being the elements" is not CL. It must be an extension of the implementation you are using.
EvW has joined #lisp
<sea>
I was wondering why I couldn't find it in CLHS just now
<jack_rabbit>
I'll try those. I've only tried clozure and clisp, and both gave me issues.
drastik__ has joined #lisp
<jack_rabbit>
wait, ccl is clozure.
<pierpa>
if these gave you issues, most probably the flaws are in your code, IMO
drastik_1 has joined #lisp
<aeth>
CCL has a superior GC than SBCL and is fairly comparable to performance in SBCL. ECL apparently is better on some niche areas like bignum performance.
<aeth>
SBCL, though, in general is pretty nice. It's usually the fastest, the most helpful, and the most feature-rich.
drastik has quit [Ping timeout: 256 seconds]
Cymew has quit [Ping timeout: 246 seconds]
<aeth>
You could definitely beat SBCL in performance, though, if you really tried. There's definitely lots of room for improvement all over the place.
damke has quit [Ping timeout: 264 seconds]
drastik_ has quit [Ping timeout: 246 seconds]
Cymew has joined #lisp
<aeth>
SBCL is pretty fast, but its optimizations don't really compare to some of the ridiculous optimizations compilers with big budgets can do these days.
<jack_rabbit>
pierpa, ccl gave me an error compiling some quicklisp library. I assume that is the library's fault. clisp crashes trying to load swank, which I assume is clisp's fault.
<aeth>
Libraries are definitely written just for SBCL.