comborico1611 has quit [Quit: Konversation terminated!]
fikka has joined #lisp
MichaelRaskin has quit [Ping timeout: 252 seconds]
Kaisyu has joined #lisp
stardiviner has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
Kaisyu7 has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
eli_oat has joined #lisp
rumbler31 has joined #lisp
fikka has joined #lisp
karswell_ has quit [Read error: Connection reset by peer]
markong has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 252 seconds]
Kaisyu7 has joined #lisp
elfmacs has joined #lisp
Kaz has quit [Quit: Connection closed for inactivity]
fikka has joined #lisp
mindCrime has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 252 seconds]
jason_m has joined #lisp
fikka has joined #lisp
rumbler31 has quit []
rumbler31 has joined #lisp
yaewa has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
moei has quit [Ping timeout: 252 seconds]
ZombieChicken has joined #lisp
fikka has joined #lisp
jason_m has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 245 seconds]
raynold has joined #lisp
fikka has joined #lisp
yaewa has quit [Quit: Leaving...]
moei has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Pixel_Outlaw has joined #lisp
vtomole has joined #lisp
innovati has quit [Read error: Connection reset by peer]
innovati has joined #lisp
warweasle has quit [Quit: Leaving]
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
johnvonneumann has joined #lisp
johnvonneumann is now known as Guest50137
d4ryus1 has joined #lisp
d4ryus has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
EvW has quit [Ping timeout: 245 seconds]
ZombieChicken has quit [Remote host closed the connection]
MasouDa_ has quit [Ping timeout: 252 seconds]
thekolb has quit [Read error: Connection reset by peer]
ioa has quit [Read error: Connection reset by peer]
ioa has joined #lisp
mrottenkolber has joined #lisp
mrottenkolber is now known as Guest85156
fikka has joined #lisp
energizer has quit [Remote host closed the connection]
energizer has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
zazzerino has quit [Ping timeout: 252 seconds]
jason_m has joined #lisp
fikka has joined #lisp
quazimodo has quit [Ping timeout: 245 seconds]
jason_m has quit [Ping timeout: 260 seconds]
Oladon has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
pierpa has quit [Quit: Page closed]
jason_m has joined #lisp
pierpal has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
beizhia has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
SenasOzys has quit [Ping timeout: 252 seconds]
mejja has quit [Quit: mejja]
jason_m has quit [Quit: Leaving]
robwgla has joined #lisp
mathrick has quit [Ping timeout: 240 seconds]
adlai has quit [Ping timeout: 264 seconds]
shka_ has joined #lisp
quazimodo has joined #lisp
Pixel_Outlaw has quit [Quit: Leaving]
adlai has joined #lisp
schoppenhauer has quit [Ping timeout: 245 seconds]
EvW has joined #lisp
iqubic has quit [Remote host closed the connection]
schoppenhauer has joined #lisp
fikka has joined #lisp
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
eli_oat has quit [Quit: Leaving.]
eli_oat has joined #lisp
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
smurfrob_ has joined #lisp
smurfrobot has quit [Read error: Connection reset by peer]
smurfrob_ has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
smurfrob_ has joined #lisp
smurfrobot has quit [Read error: Connection reset by peer]
Bike has quit [Quit: Lost terminal]
<beach>
Good morning everyone!
loli has quit [Quit: WeeChat 2.1]
smurfrobot has joined #lisp
smurfrobot has quit [Read error: Connection reset by peer]
loli has joined #lisp
smurfrobot has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
smurfrob_ has quit [Ping timeout: 260 seconds]
smurfrobot has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
robwgla has quit [Quit: robwgla]
robwgla has joined #lisp
smurfrobot has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
smurfrobot has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
robwgla has quit [Client Quit]
smurfrobot has quit [Read error: Connection reset by peer]
smurfrob_ has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
marusich has joined #lisp
smurfrobot has joined #lisp
eli_oat has quit [Quit: Leaving.]
smurfrobot has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
smurfrobot has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
smurfrob_ has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
smurfrobot has quit [Read error: Connection reset by peer]
smurfrob_ has joined #lisp
smurfrobot has joined #lisp
smurfrob_ has quit [Read error: Connection reset by peer]
smurfrob_ has joined #lisp
smurfrob_ has quit [Read error: Connection reset by peer]
smurfrob_ has joined #lisp
smurfrobot has quit [Read error: Connection reset by peer]
smurfrob_ has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
kmurphy4 has quit [Quit: kmurphy4]
EvW has quit [Ping timeout: 245 seconds]
<beach>
Did other people here get email from Concordia University about API-breaking changes?
elfmacs has quit [Ping timeout: 245 seconds]
Mutex7 has joined #lisp
asarch has joined #lisp
Oladon has quit [Quit: Leaving.]
fikka has quit [Ping timeout: 245 seconds]
<loke>
beach: Changes to what?
Xach has quit [Ping timeout: 260 seconds]
Xach has joined #lisp
fikka has joined #lisp
pierpal has joined #lisp
<jeosol>
Morning beach
<jeosol>
Didn't get email
pierpal has quit [Ping timeout: 245 seconds]
failproofshark has joined #lisp
failproofshark has quit [Client Quit]
shka_ has quit [Ping timeout: 252 seconds]
<beach>
It was for people who have GitHub repositories. They are doing a survey on how API-breaking changes impact the work, and on to what degree those people introduce API-breaking changes.
<beach>
I took the survey because it was an opportunity to mention Common Lisp.
cpape` has quit [Ping timeout: 255 seconds]
makomo has quit [Quit: WeeChat 2.0.1]
nullman has quit [Ping timeout: 248 seconds]
makomo has joined #lisp
skeuomorf has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
<loke>
beach: I have lots of such repositories and I got no such email.
<beach>
OK. Strange.
fikka has joined #lisp
bailon has quit [Ping timeout: 276 seconds]
bailon has joined #lisp
<jackdaniel>
I didn't receive such email too
karlosz has quit [Quit: karlosz]
makomo has quit [Ping timeout: 264 seconds]
Mutex7 has quit [Quit: Leaving]
aindilis has quit [Read error: Connection reset by peer]
oleo has quit [Quit: Leaving]
dddddd has quit [Remote host closed the connection]
<rme>
I've received messages like that before (where someone is doing research based on GitHub repositories); I am afraid that I tend to ignore them.
<beach>
I do too. But this was an opportunity to mention that 1. I use Common Lisp and 2. There are very few problems of this type with Common Lisp.
asarch has quit [Quit: Leaving]
nickenchuggets has quit [Read error: Connection reset by peer]
<loke>
OK, I have the seirdest behaviur
<loke>
all of a sudden the SLIME Debugger starts displaying all symbols in lower case.
<loke>
The REPL still behaves normally.
<loke>
What could have happened? (it is triggered some time after loading one of the McCLIM files and an error happens)
<beach>
The readtable case might have changed.
<loke>
beach: Right, but which one? The one in my REPL (both SLIME repl and *inferior-lisp*) are still normal.
<loke>
Does the SLIME debugger have its own readtable?
<beach>
Don't know. Sorry.
<loke>
Thanks anyway :-)
<loke>
It's not really a problem, I actually prefer lower case. It's just unsettling that I have no idea why it happens.
<loke>
aaaah. wait a second. It only happens for stack traces generated from the CLIM Command Reader.
<loke>
So I'd guess somewhere in there, *READTABLE-CASE* is dynamically rebound.
vtomole has quit [Ping timeout: 260 seconds]
kajo has quit [Ping timeout: 245 seconds]
sauvin has joined #lisp
vlatkoB has joined #lisp
josemanuel has quit [Quit: leaving]
manualcrank has quit [Quit: WeeChat 2.1]
flamebeard has joined #lisp
shrdlu68 has joined #lisp
shrdlu68 has quit [Ping timeout: 260 seconds]
shrdlu68 has joined #lisp
epony has quit [Ping timeout: 256 seconds]
elfmacs has joined #lisp
nullman has joined #lisp
nosaj88 has joined #lisp
nosaj88 has quit [Client Quit]
stardiviner has quit [Quit: WeeChat 2.1]
epony has joined #lisp
nosaj88 has joined #lisp
beizhia has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
nika_ has joined #lisp
nosaj88 has quit [Quit: Leaving]
smurfrob_ has joined #lisp
smurfrobot has quit [Read error: Connection reset by peer]
smurfrob_ has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
skeuomorf has left #lisp ["Killed buffer"]
shrdlu68 has quit [Ping timeout: 245 seconds]
shrdlu68 has joined #lisp
sz0 has quit [Quit: Connection closed for inactivity]
bbobb has joined #lisp
isBEKaml has joined #lisp
kajo has joined #lisp
fkac has joined #lisp
schweers has joined #lisp
<shrdlu68>
Hey, I'm reading online and some guy says that Lisp has two fundamental features: 1. Programs and data being the same 2. nil eq () eq false.
<shrdlu68>
He says without either of these, a language is not a lisp. In what qay is 2. a fundamental lisp feature?
fkac has quit [Remote host closed the connection]
fkac has joined #lisp
<schweers>
shrdlu68: maybe in order to disqualify scheme from being a lisp?
<shrdlu68>
schweers: Yes he does say "Scheme screwed up when the broke"
<shrdlu68>
the second feature."
<schweers>
I like nil punning and the like, but I don’t think it’s /that/ essential. But hey, maybe
<schweers>
I’m missing something.
<shrdlu68>
Yeah, I don't get why he considers 2. a defining feature of lisp.
<schweers>
where did you get this from? do you have a link handy?
<flip214>
shrdlu68: having one, and only one false value is a really welcome fact about CL.
<flip214>
(with various names like FALSE, false, NULL)
<flip214>
consider all the problems with eg python, perl, etc, where you have multiple "false"s: "", "0", false, 0, []
<schweers>
flip214: it is a nice feature, but I don’t think that it is necessary to be a lisp
<schweers>
although I’m not so sure anymore if I regard scheme to be a lisp, albeit for different reasons.
<flip214>
schweers: well, python is called "a lisp without the parenthesis" - I don't understand why. so how many parts of lisp are needed to _get_ a lisp?
<schweers>
python does not have data as code
<schweers>
as far as I know, only false and None are non-true in python. Am I wrong? (Not that it matters)
<flip214>
that's 2.7.15, though... perhaps python 4 changes all that again?!
<ecraven>
at least it's the same in python2 and python3
<schweers>
ugh, I hate python. this indentation stuff really is stupid. And not for the reason most python newbies have.
<schweers>
python 4?
<flip214>
just hyperbole
<schweers>
I really have not been paying attention to python. I was to busy using lisp
<schweers>
k, but still. The fact that I couldn’t tell says it all :D
<beach>
shrdlu68: There is no widespread agreement about the definition of "Lisp". That's why this channel is dedicated to Common Lisp, which is well defined.
<schweers>
and python is no not Common lisp :-P
deng_cn has quit [Quit: deng_cn]
<shrdlu68>
beach: Ah, so there's no way to validate this gentleman's claim, there being no standard definition.
<beach>
shrdlu68: Correct. So it depends on the person's agenda.
aindilis has joined #lisp
<schweers>
s/no/so/
<beach>
Therefore it leads to pointless discussions, since every person has his or her prerequisites for some language being "a Lisp".
<schweers>
I actually like most of his writings, but I have to say, what he says about lisp not being an acceptable lisp ... does not seem to be true to me. Just the other day, I thought that this constant talk, that Common Lisp is supposedly some ugly beast ... I don’t get it, and it has stopped me from getting earnest with Common Lisp earlier in my life.
<flip214>
schweers: some details show their age... like CDR and CAR.
<schweers>
I don’t get what’s so bad about having CAR and CDR, especially given that there is also FIRST and REST.
<schweers>
I use all of them, depending on the context of how I’m using the cons in question.
<loli>
car and cdr are nice if one doesn't match away all their problems
scymtym has quit [Ping timeout: 245 seconds]
<flip214>
schweers: they are _not_ bad. they just show Lisp's age.
pierpal has joined #lisp
pierpal has quit [Client Quit]
<flip214>
for some more criticism, see also CL21. For example, the argument order differs between AREF and PUSH - container first resp. last argument.
<schweers>
okay, then I may have misunderstood you, but my question is still: how is CL so ugly as some people claim? I just don’t see it. Yes, you can write horrendous code in a lisp which uses cons cells as its only data-structure, but that style of programming is not tied to lisp.
pierpal has joined #lisp
<flip214>
schweers: "some" people just don't get over the parenthesis, I guess.
<schweers>
okay, now that is something I understand, but still doesn’t disqualify it, especially given that I can see the signature at the bottom of the screen.
<flip214>
If you use a Lisp for longer, then you don't mind them any more (or even welcome them) - but then you get to see other parts that are not that nice.
<flip214>
schweers: the function signature in the UI is just a kind of workaround.
<schweers>
yes, but these “some” people are not those I’m concerned about at the moment. I’m talking about the people who think that LISP is a great idea, but that all current lisps suck
<schweers>
flip214: I don’t see that as a workaround. I want that, no matter how well the standard library is designed.
<flip214>
PHP is famous for all the inconsistencies re argument order - so why should be just say "I _LIKE_ that inconsistencies!" when it comes to CL?
<flip214>
schweers: true. I like these hints too!
<schweers>
I didn’t say I /like/ them, just that a few inconsistencies in the standard library are not bad enough for me to say that CL as a whole is ugly.
<schweers>
Especially given that I can fix that if I really care.
<shrdlu68>
schweers: I don't see any unpleasantness at all either, in fact I find the uniformity, symmetry, and simplicity very endearing, but I guess it may not seem so at first.
<flip214>
well, I didn't say that CL is ugly - just that there are not-so-fine parts in that town ;)
<flip214>
schweers: fixing that is what CL21 is all about.
<schweers>
I know that you didn’t say that, just that other people might say that.
pierpal has quit [Ping timeout: 252 seconds]
<schweers>
hmmm ... package local nicknames ... that is indeed something I miss in lisp. At least, if they mean the same thing as I do.
<flip214>
there's a library for that ;)
<jack_rabbit>
Are there any libraries you guys know about with implementations of interesting data structures?
<loli>
it's fun to steal structures from purely functional datastructures
<loli>
shka: I might take you up on that some time
<shka>
cool,
<shka>
cl-data-structures is kinda cool
<shka>
rough edges and poor documentation, though
cpape has joined #lisp
implicitdiff has joined #lisp
<loli>
is this the library with interface style passing?
<schweers>
okay, I think there may be another thing some people find ugly: that not all sequence functions work on all sequence types. For instance the map family of functions, nth vs elt vs aref, etc.
<loli>
I tried using that one, but it was very underdocumented, so I put it on hold
<loli>
laziness and dynamic variables can interact in odd ways
<shka>
but it gave me some ideas
<loli>
it's a neat idea
<shka>
jack_rabbit: not sure
<loli>
it would be nice to get more generic functions, outside of creating defgenerics, and then implementing them on ones struct
<shka>
yeah, i guess
<shka>
but honestly, i figured that what i really need is just protocol for performing modifications of data structures and separate protocol to perform iteration
<flip214>
schweers: true
<shka>
composing data structures is cool for sure, but not that useful
<shka>
so i just went with those two things
<shka>
besides: i think that i may have proper composition in the near future
<shka>
i need to stop adding features, and start writing better docs anyway...
<shka>
because the state of docs is not optimal
<shka>
not even close
araujo has quit [Quit: Leaving]
quazimodo has quit [Read error: Connection reset by peer]
<loli>
I see your library has a HAMT, is there a vector/array specialization of it in your library.
<loli>
An array/vector is one of the few structures I haven't found a functional counterpart in CL yet
<loli>
well found or have made
smurfrobot has quit [Remote host closed the connection]
<shka>
so th etrick is to pass (callback easy-write) into your C
<beach>
schweers: yes, but look, this is freenode. We are into free software. When you "duplicate" some existing C code in Common Lisp, you make it safer, and more available to other Lispers.
<shka>
anyway: simple in concept but interacting with other languages is always PITA
<beach>
Of course. The semantics can be very different from one language to another.
<ZombieChicken>
I doubt it will always be 'safer'. Well-tested encryption algorithms in C would be preferable to a relatively untested version in CL
<schweers>
beach: I’m not sure how things will turn out exactly, but I might need a library callable from lisp and other languages, possibly gauche scheme (written in C, can call C functions)
<beach>
ZombieChicken: So you are saying, we should just throw in the towel for every case, and abandon the goal of writing Common Lisp code?
scymtym has joined #lisp
<ZombieChicken>
Ah, troll. Got ya
<shka>
ZombieChicken: beach is not a troll
schjetne has quit [Remote host closed the connection]
<shka>
schweers: writing bindings sucks for everything that was not designed explicitly to support bindings
<ZombieChicken>
Hard to believe that when they make such a sweeping generalization
schjetne has joined #lisp
<beach>
ZombieChicken: I am genuinely concerned about the way software is produced today. I think many people, including most of the industry, is doing the wrong thing, wasting a lot of effort using the wrong language, and producing unreliable code.
<beach>
s/is/are/
<ecraven>
beach: many would agree with you, but start arguing on what actually *is* the right language
<shka>
for instance, zeromq is ok because of simple api
<edgar-rft>
We could write a new earth in Commom Lisp, we'd only be willing to invest 4.5 billion years of work.
<loke>
shka: But at the saem time, zeomq is kinda toss
<loke>
shka: Before long, you'll fiond yourself looking for something better.
<loke>
Thankfully, RabbitMQ exists, and it's very good, and arguably written in a safe, acceptable language
<beach>
ecraven: I am totally convinced that Common Lisp, while perhaps not THE RIGHT language (especially not for EVERY situation), is a huge step in the right direction compared to most commonly used languages. And that includes using C or C++ for applications.
<shrdlu68>
beach: For an industry/profession/trade that automates things, we're doing a poor job of automating ourselves away. That, for me, is the first sign that something is wrong with the way software is produced today.
<loke>
beach: I would suspect that you are also in favour of Erlang?
<beach>
shrdlu68: I can't agree more.
<ecraven>
not disputing this, just saying that *that* is where people'so opinions probably differ ;)
<schweers>
beach: I share your sentiment, and in general agree with what you told me earlier, that I should rather be writing in lisp than in C. That being said, I may be forced to have parts of the code in a way that accepts a C function. I hope I can avoid this, but I wanted to know the state of things beforehand.
implicitdiff has left #lisp [#lisp]
<beach>
loke: Sure. Not that I know it, but it seems adapted to some cases.
<loke>
beach: I've used it a bit (mostly using Elixir), and it does have many of the same benefits as Lisp.
<ZombieChicken>
beach: Perhaps, but there are practical concerns in the mean time. I'd rather see someone call known good C in some cases (mainly encryption) than reimplement the code in CL and potentially break something important. Of course, this doesn't apply to people who do know how to write such code and verify that it is indeed right.
<shka>
loke: you can build better things with zeromq
<shka>
it is just low level
<loke>
shka: I tried. I had to give up.
<loke>
I went to Rabbit and haven't looked back.
RebelCoderRU has quit [Ping timeout: 252 seconds]
<beach>
schweers: I understand. Though I am always skeptical when it comes to phrases such as "have to", or "forced to". It is a choice after all. In fact it's a choice to even write software in the first place.
<shrdlu68>
ZombieChicken: No such persons exist.
<shka>
loke: well, if it works, it works
<shka>
personally, i really like zmq
<shrdlu68>
It's a myth - an illusion - that there are some wizards out there who know how to implement crypto correctly.
<loke>
shka: I'm curious as to what your use case is? For me, as soon as I wanted to do anything beyond the absolute simplest use-case where I was sending simple messages from one place to another, it simply wasn't able to provide the necessary functionality.
<jdz>
cyber is hard.
* loke
cyber jdz
<beach>
ZombieChicken: Sure. I am merely pointing out that we are in #lisp and that I feel that I should encourage people to put in a little extra effort so that we can increase the collectively available amount of Common Lisp code, rather than to solve their own problem that is much harder to share.
<loke>
beach: You have no idea how many poeople in the Maxima community have adviced me to “just use qxmaxima” or “put your effort in jyupiter for Maxima instead”. Luckily, I'm stubborn and refuse. :-)
<loke>
I meant wxmaxima
<beach>
loke: Good! We agree!
<loke>
beach: In that respect we do :-)
<schweers>
loke: what’s wrong with wxmaxima?
<beach>
ZombieChicken: I am also saddened by the proportion of the traffic in this channel that is dedicated to questions, answers, and discussions about how to use other languages that Common Lisp.
<beach>
s/that/than/
fikka has joined #lisp
<shka>
loke: i built distributed system with it, i used zeromq for messeging between machines, monitoring processes and so one
<loke>
beach: At some point I resign myself to the fact that all needed software won't ever be rewritten in Lisp. Hence by choice to use CFFI to call out to Freetype and Harfbuzz. (I know JD doesn't like that)
<beach>
loke: Nor do I.
<loke>
shka: My biggest issue with zeromq was that it has no subscription or selection features.
<shka>
it has?
<loke>
beach: I know, but I have a hard time thinking of an alternative.
<beach>
loke: Fair enough.
<loke>
beach: I think that's as close as we're going to get to the proverbial “I hust/have to use C code”.
<ZombieChicken>
Perhaps a silly question, but if it's more complicated than it needs to be, why reimplement it in any language?
vsync has joined #lisp
<shka>
loke: i can't find example in acceptable language, but just use pub-sub and setsockopt to subscribe
<ecraven>
ZombieChicken: I don't think it is more complicated than it needs to be, writing systems are just amazingly complex
<loke>
shka: I don't think that's enough... My requirements (what I use in Rabbit, and what made me switch) is that I need to be able to include metadata to messages which are broadcast to various channels. The listeners use selectors to pick messages based this metadata (Rabbit calls them “routing keys”)
<beach>
ecraven: That's the kind of wisdom I make my living questioning.
<loke>
Another thing I need is the ability to have expiring messgaes, that disappear if they are not picked up in a certain amopunt of time.
<ecraven>
beach: I understand that, but writing systems are kind of a hobby of mine, and I really do think that people vastly underestimate the complexity to deal with *any* writing system (not just a few specific ones)
<shka>
loke: well, that's how ZMQ works
energizer has quit [Ping timeout: 260 seconds]
<shka>
as for disappearing messages, i don't think you can do that in ZMQ
<shka>
at least not easily
<beach>
ecraven: I am not sure what you mean by a "writing system".
<loke>
shka: Another feature I use is queue timeouts, where a receiver queue (bound to a broadcast source) times out if a client hasn't touched it in some amouint of time.
<loke>
shka: There is also the concept of a “dead letter” queue where unprocessed messages are routed.
<ecraven>
beach: latin letters, devanagari, kanji/kana, that sort of stuff
<loke>
I don't think any of that exists in zeromq
eSVG has quit [Ping timeout: 260 seconds]
<beach>
ecraven: With respect to rendering text in those systems, you mean?
<loke>
shka: Also, transactional support.
<beach>
ecraven: The intrinsic complexity, I mean.
<shka>
loke: so ok: zmq has subscriptions, but as for the rest of the stuff: it is socket library
<ecraven>
beach: yes, converting a sequence of unicode codepoints to an image, in essence
<shka>
so features like those are out of scope
<beach>
ecraven: Got it.
<loke>
shka: Right. That was my point really. I discovered that while it had “MQ” in its name, it's not really a message queue. It's a fancy socket library.
<loke>
I would have much less issue with it if it was called something without mq in the name :-)
<shka>
well, yes
<shka>
but it is a GOOD socket library
<ecraven>
beach: I'm no expert on opentype, but there as a reason for most of the complexity. not saying it couldn't be done better, but it is the de-facto standard font format, it would be hard to replace it
<ecraven>
same for unicode, some very bad decisions were made, but there's no easy way to remedy that
<loke>
shka: didn't the author of it decide to rewrite it or something?
<shka>
i think yes
<shka>
because C++
<beach>
ecraven: I am willing to believe you.
<loke>
C++ is always a good reason for rewriting something. Unfortiunately he went to something that is only marginally batter, no? (C)
<loke>
better
<shka>
well, if you need to expose C bindings, you may as well write in C
<shka>
sadly
<loke>
shka: What's the closest equivalent to zeromq in Lisp?
<shka>
i don't know
<shka>
i would simply use zeromq from lisp
<shka>
though beach would disaprove
<ZombieChicken>
beach: Out of curiosity, what do you think of Prolog?
<beach>
shka: Not many people care what I approve or disapprove of.
<shka>
ZMQ is easy to use from other languages
<shka>
beach: I do :-)
<loke>
shka: for your next project, why don't you give Rabbit a try? If you need anything slightly more capable. It's really a wonderlfy system. :-)
<loke>
wonderful
* loke
cares very much what beach cares about.
<beach>
ZombieChicken: Seems like a good fit for some problems. I have also seen people use it as a general-purpose language, but I am more doubtful about that kind of use.
<shka>
beach: we care because you do
<loke>
I think the main reason I'm working on Climaxima is beach :-)
milanj_ has joined #lisp
<shka>
loke: maybe, right now i'm kinda stuck in the cl-data-structures
<loke>
shka: What is that?
<beach>
That makes 2. :) So "not many" is still a valid estimate. :)
<shka>
library for data structers and some semi-random selection of algorithms
<loke>
beach: But we are really important, or something :-)
<shka>
nothing that talks over network
<beach>
loke: Totally!
<loke>
You might know about me. I'm kind of a big deal.
<beach>
Of course.
<loke>
Of course :-)
<shka>
i was thinking about building basic distributed hash-table storage
<shka>
ZMQ is well suited for this, rabbit may be to much
* loke
stares at his rendering of square roopts... That line... Tha aliasing. it makes my eyes hurt.
<shka>
but i am not getting paid for this crap so it will take forever anyway
* dmiles
uses Prolog for general perpose language.. Though many times i'll use it as a glue to FFI
<loke>
I may have to implement that line-join algorithm I found just so that I can make line-drawing use Xrender.
fkac has quit [Remote host closed the connection]
<loke>
the number of rabbit-holes I've dub myself into...
<loke>
s/dub/dug/
vibs29 has quit [Ping timeout: 245 seconds]
terpri has quit [Ping timeout: 245 seconds]
vibs29 has joined #lisp
fm4d_ has joined #lisp
smurfrobot has quit [Remote host closed the connection]
megalography has quit [Ping timeout: 252 seconds]
smurfrobot has joined #lisp
smurfrobot has quit [Read error: Connection reset by peer]
<fm4d_>
Hello, is there any way to have a string that spans across multiple lines (most programming language supports it via \ etc.) in common lisp? I've only found a way to do it in format control string. Thanks :)
smurfrobot has joined #lisp
<schweers>
stupid question: how do you do it in a format string?
smurfrobot has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
smurfrobot has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
<loke>
fm4d_: Yes. Just press newline in the middle fo a string
<loke>
fm4d_: In Lisp, strings can contain newlines.
<fm4d_>
Sorry, I've forgot to add that I would like that multiline string to be without newlines.
smurfrob_ has joined #lisp
<fm4d_>
Like if I used "foo" \ "bar" or ("foo" "bar") in python
smurfrob_ has quit [Read error: Connection reset by peer]
<fm4d_>
I can of course concatenate the two strings or remove the newline afterwards, but that feels dirty
smurfrob_ has joined #lisp
<loke>
fm4d_: I can think of two ways:
<loke>
first way: (concatenate string "first line" "second line")
<loke>
(and newline between thestrings of course)
<loke>
the second way:
<loke>
(format nil "first line%
<loke>
second line")
smurfrobot has quit [Ping timeout: 256 seconds]
<schweers>
you could wrap it around a #. read macro
<loke>
Yes
<flip214>
fm4d_: CL-WHO supports that and other string-niceties
smurfrob_ has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
<loke>
fm4d_: With the FORMAT trick, you can even have space at the beginning of the second line to line things up, FORMAT will strip those off. If you don't like that behaviour you can terminate each line with ~: instead of ~
megalography has joined #lisp
<loke>
(I made a typo in my example by the way, the character to use is ~, not %)
* loke
has been doing too much Elisp lately.
smurfrobot has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
<ecraven>
loke: any idea why elisp chose % instead of ~? doesn't ~ have precedent in earlier lisps?
<loke>
ecraven: Because Elisp's format is more like C's format than CL.
<loke>
Also, Emacs is older than CL.
<ecraven>
loke: I know, but doesn't ~ have precedent in lisps older than CL?
<loke>
That said, Maclisp had FORMAT with pretty much the same syntax as CL and it is contemporary with Emacs.
<loke>
ecraven: ~ comes from FORTRAN, I think.
<ecraven>
ah, never knew that, thanks!
loli has quit [Ping timeout: 245 seconds]
<fm4d_>
loke thanks, ~ at the end is neat, I will stick to that :)
smurfrobot has quit [Read error: Connection reset by peer]
smurfrob_ has joined #lisp
<loke>
fm4d_: If you want to be really fancy, you could create a reader macro to provide custom syntax for that. :-)
loli has joined #lisp
smurfrobot has joined #lisp
smurfrob_ has quit [Read error: Connection reset by peer]
<fm4d_>
For now I am happy to be able to solve some real world problems in clisp without constantly searching in books and frantically googling :D
smurfrobot has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
<loke>
fm4d_: It's a great feeling when you reach that point.
<loke>
After that things tend to be smooth :-)
makomo has joined #lisp
loli has quit [Quit: WeeChat 2.1]
loli has joined #lisp
ym has joined #lisp
<ym>
Hi. How do I send Elisp code from slime to Emacs? Like with M-:, but with slime/swank.
makomo has quit [Ping timeout: 240 seconds]
edgar-rft has quit [Quit: edgar-rft]
<loke>
ym: you want to type CL code in emacs and have it run in the CL? Or you want to run a CL comamnd from within Lisp and have it pass Emlisp code for execution in Emacs?
<ym>
Second.
<ecraven>
I don't think there's a message for that
<ecraven>
look in contrib/slime-repl.el, around line 1710 (defun slime-repl-event-hook-function ..)
<ecraven>
I *think* that is what you can send to slime from swank
<ym>
I want to use emacs as UI-frontend to my CL program, but everything points me out that it isn't the way.
<ecraven>
just pass s-expressions back and forth, like notmuch does, for example
quazimodo has quit [Ping timeout: 245 seconds]
damke has quit [Ping timeout: 252 seconds]
Arcaelyx has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
Arcaelyx_ has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 268 seconds]
EvW1 has joined #lisp
<ym>
Like slime does.
<ym>
That's interesting.
ZombieChicken has quit [Quit: Have a nice day]
<shka>
you can literally use slime/swank for that
fikka has joined #lisp
<ecraven>
shka: depending on what you want to interface with, slime/swank might get in the way more than it helps
beach has quit [Ping timeout: 240 seconds]
nullman has quit [Ping timeout: 245 seconds]
python476 has joined #lisp
<shka>
there is a project for nvim that allows you to write extensions with lisp code
<shka>
perhaps you can try to look at that
<shka>
because you are doing the same thing
<shka>
just for emacs
m00natic has joined #lisp
<ym>
I'd be fine with CL-implementation-independent Emacs-frontend, and seems like just digging into slime/swank is exactly what I need. Reading it's docs. Thanks for help.
nullman has joined #lisp
foojin has joined #lisp
<dim>
mm, I just discovered today that in SLIME C-c C-c is more like C-M-x than like C-c C-e, and that I like C-c C-c a lot, when I used to only use C-M-x
<shka>
what C-M-x does?
<loke>
shka: eval-devun I think
<loke>
eval-defun
<shka>
never ever used it
<loke>
‘slime-eval-defun’ to be precise
markong has joined #lisp
smurfrob_ has joined #lisp
smurfrobot has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 240 seconds]
EvW1 has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
terpri has joined #lisp
elfmacs has quit [Ping timeout: 256 seconds]
zooey has quit [Ping timeout: 250 seconds]
igemnace has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
<dim>
shka: C-M-x runs the command slime-eval-defun
<dim>
so about the same as C-c C-c runs the command slime-compile-defun
EvW has joined #lisp
fikka has joined #lisp
zooey has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
<loke>
On SBCL they should be pretty much idental, no?
smurfrob_ has quit [Remote host closed the connection]
smurfrobot has joined #lisp
igemnace has quit [Quit: WeeChat 2.1]
fikka has joined #lisp
Guest85156 is now known as kolb
<dim>
I guess I just got used to using C-M-x for no reason really
<dim>
I know I prefer C-c C-l to C-c C-k for whole files, in order to avoid having fasl files around, but for defun forms it seems not to do that
fikka has quit [Ping timeout: 264 seconds]
<dim>
oh, C-c C-c annotate the sources, which C-M-x does not
quazimodo has joined #lisp
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
TCZ has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
dddddd has joined #lisp
milanj_ has quit [Quit: This computer has gone to sleep]
TCZ has quit [Quit: Leaving]
fikka has quit [Ping timeout: 245 seconds]
raynold has quit [Quit: Connection closed for inactivity]
nika_ has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
isBEKaml has quit [Quit: leaving]
SenasOzys has joined #lisp
fikka has joined #lisp
lumm has joined #lisp
smurfrobot has joined #lisp
glv has joined #lisp
smurfrobot has quit [Ping timeout: 245 seconds]
smurfrobot has joined #lisp
elfmacs has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
edgar-rft has joined #lisp
fikka has joined #lisp
glv has quit [Quit: Leaving]
damke has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
beach has joined #lisp
milanj_ has joined #lisp
fikka has joined #lisp
elfmacs has quit [Quit: WeeChat 2.1]
scymtym_ has joined #lisp
smurfrobot has quit [Remote host closed the connection]
scymtym has quit [Ping timeout: 260 seconds]
smurfrobot has joined #lisp
EvW has quit [Remote host closed the connection]
EvW has joined #lisp
shrdlu68 has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 256 seconds]
glv has joined #lisp
fikka has joined #lisp
damke has quit [Ping timeout: 252 seconds]
shrdlu68 has joined #lisp
makomo has joined #lisp
sjl has quit [Quit: WeeChat 2.1]
sjl has joined #lisp
<dim>
Heap exhausted during garbage collection
<dim>
mmm, not quite there yet with taming SBCL, or rather understanding what parts of the code are consing, I guess
warweasle has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
milanj_ has quit [Quit: This computer has gone to sleep]
mindCrime has joined #lisp
tcr has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
SenasOzys has quit [Ping timeout: 245 seconds]
Bike has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
SenasOzys has joined #lisp
LiamH has joined #lisp
<Xof>
you could use dougk's new allocation profiler!
fikka has joined #lisp
Ukari has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
araujo has joined #lisp
araujo has quit [Max SendQ exceeded]
araujo has joined #lisp
araujo has quit [Max SendQ exceeded]
araujo has joined #lisp
orivej has quit [Ping timeout: 248 seconds]
makomo has quit [Ping timeout: 248 seconds]
makomo has joined #lisp
<dim>
that sounds interesting indeed
<dim>
in that case though I think I can use a streaming API instead of packing things in-memory in a batch, with the ZS3 stream support
<dim>
that might improve performances and reduce consing at once
python476 has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
<dim>
oh no, right, sz3:put-stream doesn't do what I keep thinking it does
Guest50137 has quit [Remote host closed the connection]
<dim>
the code already does (sb-ext:gc :full t) each time it gets rid of a batch, to hint SBCL
<dim>
so 6% of the funcalls saw by the sprof are calls to make-hash-table?
<aeth>
What for?
trocado has quit [Ping timeout: 260 seconds]
<dim>
I don't think I'm doing that :/
pierpal has quit [Ping timeout: 268 seconds]
<Bike>
what exactly are you profiling? that looks like it's in the compiler
<scymtym>
dim: are you benchmarking with cold CLOS caches?
<scymtym>
(or PCL caches, technically)
<dim>
Bike: a pgloader run
<dim>
the run includes parsing a command language, which returns a lambda form, that is then compiled
<dim>
and then funcalled
<_death>
maybe try sbcl's evaluator(s)
<scymtym>
if you call COMPILE at runtime, some amount of compiler stuff is going to be in the profile (disregarding what PCL might add)
<dim>
pgloader in that profiled run loaded 121746 rows (36.3 MB) in 2m23.802s, so the compiling shouldn't be leading the profile, that said it's a multi-threaded program, does the profiler knows how to profile multiple threads?
<dim>
retrying with options (:max-samples 10000 :mode :alloc :report :flat :threads :all :reset t), that should help, maybe
fikka has joined #lisp
<scymtym>
dim: it samples all running threads by default, iirc
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
sjl has quit [Ping timeout: 264 seconds]
mindCrime has joined #lisp
alandipert has quit [Remote host closed the connection]
Kaz has joined #lisp
alandipert has joined #lisp
alandipert has quit [Client Quit]
alandipert has joined #lisp
Kazimodo has joined #lisp
paul0 has quit [Quit: Leaving]
EvW1 has joined #lisp
mindCrime has quit [Ping timeout: 245 seconds]
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Kaz has quit [Ping timeout: 245 seconds]
Kazimodo has quit [Ping timeout: 260 seconds]
Bike has joined #lisp
sjl has joined #lisp
sjl has quit [Ping timeout: 260 seconds]
fkac has joined #lisp
fkac has quit [Remote host closed the connection]
kajo has quit [Ping timeout: 245 seconds]
Kundry_Wag has joined #lisp
kajo has joined #lisp
xaxaac has quit [Quit: Leaving]
Cymew has joined #lisp
MasouDa has joined #lisp
Kaisyu has joined #lisp
Cymew has quit [Ping timeout: 252 seconds]
MasouDa_ has quit [Ping timeout: 240 seconds]
light2yellow has joined #lisp
Plazma has quit [Read error: Connection reset by peer]
terpri has quit [Read error: Connection reset by peer]
terpri has joined #lisp
pierpal has joined #lisp
markong has joined #lisp
milanj has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
iqubic` has joined #lisp
Guest50977 has quit [Remote host closed the connection]
iqubic has quit [Ping timeout: 260 seconds]
on_ion has joined #lisp
eli_oat has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
<aeth>
I just finished moving nearly everything into with-accessors* and my custom prefixed versions (with-foo-accessors*) in my quest to reduce repetition in Lispy ways. Essentially, it's just with-accessors, but if it's a symbol instead of a list, then it assumes the binding and the accessor are the same name. No more (with-accessors ((width width) (height height)) foo ...)
<aeth>
Now it's just (with-accessors* (width height) foo ...)
Pixel_Outlaw has joined #lisp
fikka has joined #lisp
<aeth>
I wonder why they didn't do that in the standard. It's a pretty trivial change and I'd assume most uses of with-accessors use the same variable name as the accessor name unless the accessor name is prefixed (and I deal with uniform-for-an-object prefix elimination my own way, with a define-accessor-macro that essentially defines a with-foo-accessors that automatically applies the prefix)
<aeth>
(I suppose you could also do with-prefixed-accessor as an alternate solution)