binghe changed the topic of #lisp to: Common Lisp, the #1=(programmable . #1#) programming language <http://cliki.net/> logs:<https://irclog.whitequark.org/lisp, http://ccl.clozure.com/irc-logs/lisp/> | SBCL 1.4.0, CMUCL 21b, ECL 16.1.3, CCL 1.11.5
foom2 has quit [Ping timeout: 276 seconds]
nowhere_man has quit [Read error: Connection reset by peer]
nowhere_man has joined #lisp
smokeink has quit [Ping timeout: 265 seconds]
mareskeg has quit [Quit: mareskeg]
kamog has joined #lisp
Chream has quit [Remote host closed the connection]
juan-reynoso has quit [Ping timeout: 256 seconds]
markong has quit [Ping timeout: 256 seconds]
dieggsy has quit [Read error: Connection reset by peer]
nowhereman_ has joined #lisp
Amplituhedron has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
bigos has joined #lisp
z3t0 has joined #lisp
macrocat has joined #lisp
nirved has quit [Quit: Leaving]
hel-io has quit []
Achylles has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 260 seconds]
<pillton> DBeepBeep: It sounds like you need to fix the interface of the external library.
lnostdal_ has quit [Ping timeout: 255 seconds]
FreeBirdLjj has joined #lisp
Oladon has joined #lisp
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
lnostdal_ has joined #lisp
FreeBirdLjj has quit [Ping timeout: 256 seconds]
z3t0 has quit [Remote host closed the connection]
pmc_ has joined #lisp
orivej has joined #lisp
<pmc_> I was following along in PCL Chapter 2 with SBCL/SLIME/emacs on Windows. It reads "To quit you can use a SLIME shortcut: at the REPL, type a comma. Then you will be prompted for a command." When I press comma at the REPL, SBCL stops reasponding. I do not get a prompt at the bottom of the Emacs winodw. Any ideas why?
rumbler31 has joined #lisp
damke has joined #lisp
smurfrobot has joined #lisp
smaster has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
mareskeg has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
comborico1611 has joined #lisp
arescorpio has joined #lisp
Bike has quit [Ping timeout: 268 seconds]
lnostdal_ has quit [Ping timeout: 255 seconds]
Bike has joined #lisp
vultyre has joined #lisp
EvW has quit [Ping timeout: 255 seconds]
bigos has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 240 seconds]
Pixel_Outlaw has joined #lisp
pfdietz_ has quit []
ome has quit [Quit: Connection closed for inactivity]
sz0 has joined #lisp
quazimodo has joined #lisp
JenElizabeth has joined #lisp
<Xach> pmc_: did you figure it out?
mareskeg has quit [Quit: mareskeg]
mareskeg has joined #lisp
JenElizabeth has quit [Remote host closed the connection]
JenElizabeth has joined #lisp
JenElizabeth has quit [Remote host closed the connection]
djuber has joined #lisp
lnostdal_ has joined #lisp
mareskeg has quit [Quit: mareskeg]
rumbler3_ has joined #lisp
rumbler31 has quit [Read error: Connection reset by peer]
mareskeg has joined #lisp
python476 has quit [Ping timeout: 240 seconds]
stacksmith has quit [Ping timeout: 256 seconds]
ome has joined #lisp
Arcaelyx has joined #lisp
ebzzry_ has quit [Ping timeout: 264 seconds]
vultyre has quit [Quit: Leaving]
<comborico1611> What is the t here? (parse-integer (prompt-read "Rating") :junk-allowed t)
<Xach> comborico1611: t is a handy constant that evaluates to itself
<Xach> comborico1611: in this case it is passed as a value to the junk-allowed parameter.
lnostdal_ has quit [Ping timeout: 255 seconds]
<Xach> in the implementation of parse-integer that parameter is checked and changes how the function behaves.
<comborico1611> Xach: Hmm. Thank you!
<comborico1611> Xach: what book would you recommend for a programmer to learn CL?
<comborico1611> So far i am pleased with Practical Common Lisp, but i always like to have a backup.
stacksmith has joined #lisp
Kundry_Wag has joined #lisp
thallia has quit [Ping timeout: 264 seconds]
ramus has quit [Ping timeout: 264 seconds]
fouric has quit [Ping timeout: 264 seconds]
thallia has joined #lisp
Amplituhedron has quit [Ping timeout: 240 seconds]
fouric has joined #lisp
<Xach> comborico1611: paradigms of ai programming by norvig is densely packed with great info
Kundry_Wag has quit [Ping timeout: 264 seconds]
d4ryus1 has joined #lisp
d4ryus has quit [Ping timeout: 248 seconds]
ebzzry_ has joined #lisp
figurehe4d has quit [Ping timeout: 252 seconds]
Cymew has joined #lisp
lonjil has joined #lisp
pfdietz has joined #lisp
<pfdietz> I wish the systems in quicklisp were not sometimes incompatible.
<Xach> pfdietz: what kind of incompatibility is most problematic for you? the one that springs first to my mind is package names.
smurfrobot has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 264 seconds]
<pmc_> Xach: It turns out SBCL prints an error message when comma is entered at the REPL. I guess SLIME and emacs are not expecting that.
<Xach> pmc_: the possible problem is that you are not using the "fancy" repl, which was once the default but now is "optional"
<Xach> the fancy repl is pretty nice and i use it with slime always
<pfdietz> Yes, package name collisions.
<pmc_> xach: where can I read more about this "fancy" REPL?
<Xach> At any rate, M-x slime-repl-<command> will also do whatever ,<command> is described to do.
<pfdietz> net.uri defined in zacl and puri, for example. And others.
mareskeg has quit [Quit: mareskeg]
<Xach> pmc_: I'm not sure. possibly the slime manual. i use (slime-setup '(slime-fancy)) to get it
<Xach> that goes in my emacs init files
<pmc_> oh, ok. I will try that. Thanks!
<Xach> pfdietz: that specific example stems from the same desire to fake out code that thinks it's on allegro
zaquest has joined #lisp
ramus has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
EvW has joined #lisp
<Xach> pfdietz: I've wished to somehow relate system loading to packages defined, but haven't worked it out yet
<Xach> i am really eager to create static databases from dynamic images to find stuff out
<Xach> (also dynamic databases from dynamic images)
Naergon has joined #lisp
Kundry_Wag has joined #lisp
EvW has quit [Ping timeout: 256 seconds]
pmc_ has quit [Quit: Leaving]
smurfrobot has joined #lisp
<pfdietz> I think standarization and usage of local nicknames would help, but all the lisps would have to get together for that.
<pfdietz> This came up for me because I'm trying to load as many systems as I can from quicklisp to provide raw material for mutation testing.
Kundry_Wag has quit [Ping timeout: 260 seconds]
<pfdietz> Perhaps not a use that was considered.
figurehe4d has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
comborico1611 has quit [Ping timeout: 248 seconds]
<pillton> pfdietz: You would still need to use a GUID.
AntiSpamMeta2 has joined #lisp
AntiSpamMeta2 is now known as AntiSpamMeta
AntiSpamMeta has quit [Killed (verne.freenode.net (Nickname regained by services))]
galdor1 has joined #lisp
ioa_ has joined #lisp
ioa has quit [Read error: Connection reset by peer]
kolb has quit [Read error: Connection reset by peer]
damke_ has joined #lisp
mrottenkolber has joined #lisp
galdor has quit [Ping timeout: 255 seconds]
z0d has quit [Ping timeout: 268 seconds]
z0d has joined #lisp
damke has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
mareskeg has joined #lisp
dieggsy has joined #lisp
figurehe4d has quit [Ping timeout: 260 seconds]
willmichael has quit [Ping timeout: 240 seconds]
deng_cn has joined #lisp
willmichael has joined #lisp
makomo has quit [Ping timeout: 256 seconds]
Pixel_Outlaw has quit [Quit: Leaving]
stacksmith has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
sz0 has quit [Quit: Connection closed for inactivity]
<beach> Good morning everyone!
arescorpio has quit [Excess Flood]
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
pierpa has quit [Quit: Page closed]
Kundry_Wag has quit [Ping timeout: 248 seconds]
Kundry_Wag has joined #lisp
fikka has joined #lisp
panji has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
<mfiano> Xach: give up on Sly?
sjl has joined #lisp
vultyre has joined #lisp
sjl has quit [Ping timeout: 265 seconds]
ome has quit [Quit: Connection closed for inactivity]
fikka has quit [Ping timeout: 256 seconds]
schoppenhauer has quit [Ping timeout: 256 seconds]
Kaisyu has joined #lisp
schoppenhauer has joined #lisp
fikka has joined #lisp
Kaisyu7 has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
fikka has quit [Ping timeout: 256 seconds]
whatsupdoc has joined #lisp
<whatsupdoc> I need help writing a function in clisp
macrocat has quit [Read error: Connection reset by peer]
<whatsupdoc> My function takes as input a list that is always is of the form ((a b)(a c)(a d)) where a is the same number or atom
<whatsupdoc> and must return (a (b c d))
<Zhivago> I suggest asking a question.
<whatsupdoc> recursively
<whatsupdoc> How do I go about doing this? So stuck
<whatsupdoc> I tried (second (car q)) (undistribute-recursive (cdr q))
<Zhivago> And what was the first surprising thing that happened?
<whatsupdoc> but that only gives me the second number
<whatsupdoc> obviously
<Zhivago> Why did that surprise you?
<whatsupdoc> i have no idea how to incorporate the 1
raskolnikov has quit [Ping timeout: 276 seconds]
<whatsupdoc> first element
<Zhivago> By not using cdr?
<whatsupdoc> why not?
<Zhivago> What does (cdr '(a b c)) do?
<whatsupdoc> returns (b c)
marusich has quit [Ping timeout: 264 seconds]
<whatsupdoc> (i think)
<Zhivago> And if you want (a b c) instead, why would you call cdr to produce (b c)?
<whatsupdoc> i don't get how that relates to what i'm doing
<Zhivago> That's probably because you are very incoherent.
<whatsupdoc> example: ((1 2) (1 4) (1 6)) becomes (1 (2 4 6))
<Zhivago> It appears that you are complaining that recursively processing all but the first element of a list does not process the first element of the list ...
<Zhivago> So, why are you going to the trouble of excluding the first element?
<whatsupdoc> because i have no idea how to incorporate it
<Zhivago> What does (cdr '(a b c)) do?
<whatsupdoc> this is what i have https://pastebin.com/raw/fFj3exjM
<whatsupdoc> for me ((1 2) (1 4) (1 6)) outputs (2 4 6)
marusich has joined #lisp
zacts has quit [Quit: WeeChat 1.9.1]
<Zhivago> And why is that surprising?
<Zhivago> Yes, which is probably why they are confused.
<whatsupdoc> I have no idea how to incorporate the first element
<whatsupdoc> because it throws off the recursion
zacts has joined #lisp
<Zhivago> In what regard is the first element not incorporated given that ((1 2) (1 4) (1 6)) outputs (2 4 6)?
presiden has quit [Ping timeout: 252 seconds]
<whatsupdoc> becuase the '1' is never printed like it's supposed to
<Zhivago> What does that have to do with undistribute-recursive?
<Zhivago> (second (car q)) (undistribute-recursive (cdr q)) ;; look at this.
<whatsupdoc> it's outputing (2 4 6) instead of (1 (2 4 6))
* akkad cooks some more popcorn
<Zhivago> So, do that outside of the recursive part, as you showed above.
marusich has quit [Ping timeout: 248 seconds]
eschatologist has quit [Quit: ZNC 1.6.5+deb2build2 - http://znc.in]
<whatsupdoc> you can't
<Zhivago> Why not?
<Zhivago> I mean, I can do it -- why can't you do it?
eschatologist has joined #lisp
<whatsupdoc> without using another function?
<Zhivago> Why is using another function significant?
<whatsupdoc> i try something like this, but this is just dumb https://pastebin.com/raw/8KtkxeZu
<Zhivago> Please learn how to answer questions.
<whatsupdoc> idk it's not?
<Zhivago> Then why do you say that you can't do it?
marusich has joined #lisp
<Zhivago> Just write two functions -- one to do the whole job, and one to do the recursive bit.
<Zhivago> You pretty much had it with your (second (car q)) (undistribute-recursive (cdr q)) except for the stupid bits.
<Zhivago> Although if you really want a single function, you can compute it recursively -- you just need to consider the return path.
raskolnikov has joined #lisp
<whatsupdoc> i'm pretty sure i can do it with two functions, just not with 1
<whatsupdoc> although idk
<Zhivago> Think of the solution for ((1 2) (1 4) (1 6)) and the solution for ((1 4) (1 6)), then think of how to get from the latter to the former.
<Zhivago> Remember in the recursive approach you are reducing ((1 2) (1 4) (1 6)) to some operation plus the same reduction upon ((1 4) (1 6)) and so on.
<beach> whatsupdoc: Is this homework?
Kundry_Wag has joined #lisp
<beach> whatsupdoc: Did you not learn how to layout Common Lisp code in class?
<Zhivago> Well, he didn't learn recursion, so I expect not.
damke has joined #lisp
<Zhivago> They need to start with a class on "Questions: How to ask and answer them intelligently".
<aeth> There are two kinds of academic Lisp. Academic Lisp that follows conventions and academic Lisp that does not follow conventions.
<whatsupdoc> i still don't know how to do it. maybe i should just use another function
presiden has joined #lisp
<akkad> "how to become a Turkish Customs Agent." "you joined lisp to see soo many assholes"
akkad has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
nowhere_man has joined #lisp
learning has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
<beach> whatsupdoc: This is not a channel for newbies. But if your purpose is to learn Common Lisp (CLISP is not an abbreviation for Common Lisp, it is an implementation of Common Lisp) we can help you. But then, you first have to use the conventions and the tools that the people here use.
Kevslinger has quit [Quit: Connection closed for inactivity]
<Zhivago> whatsupdoc: Probably -- that would help you to avoid learning, at least.
Kundry_Wag has quit [Ping timeout: 240 seconds]
<whatsupdoc> damn.....i so badly want to see the solution
<whatsupdoc> it's probably something so simple
<learning> this is an academic question (ie not building something just trying to understand), can i see all of the generic functions that take a specific class as an argument
<beach> whatsupdoc: However, if your purpose is to have someone do your homework for you, so that you don't have to learn Common Lisp, then you might be out of luck.
<learning> sorry if i used the wrong vocab
<whatsupdoc> i'm not asking for someone to do it for
<whatsupdoc> em
<whatsupdoc> *me
<Zhivago> whatsupdoc: Then try answering the questions I asked.
mikecheck has joined #lisp
<Zhivago> whatsupdoc: What does undistribute-recursive produce given ((1 2) (1 4) (1 6))? How about for ((1 4) (1 6))?
<whatsupdoc> (1 (2 4))
<whatsupdoc> (1 (4 6))
<beach> learning: Yes, you can. Hold on...
nowhereman_ has quit [Ping timeout: 248 seconds]
<beach> mop specializer-direct-generic-functions
<beach> learning: up arrow
<beach> oops
<beach> ↑
<Zhivago> whatsupdoc: Now, what _should_ it produce for those, if it were working correctly?
<beach> learning: Is that what you are looking for?
fikka has quit [Ping timeout: 240 seconds]
<learning> reading now
<whatsupdoc> that is what it should be producing it was working correctly
<Zhivago> What happened to the (1 6) from the first case?
<learning> that is so fucking op
vtomole has joined #lisp
<learning> thank you immensely beach
<learning> lisp blows me away
<beach> Anytime.
<learning> i mean of course a programmer woudl want to be able to do that
<learning> but you'd think you'd have to code it yourself
mareskeg has quit [Quit: mareskeg]
<whatsupdoc> (1 (6))
<beach> learning: If you are using SBCL, you could try (sb-mop:specializer-direct-generic-functions (find-class 'character))
<Zhivago> So, shouldn't we expect (1 (2 4 6)), (1 (4 6)), (1 (6)) given ((1 2) (1 4) (1 6)), ((1 4) (1 6)), and ((1 6))?
<whatsupdoc> no, because that's invalid input
<whatsupdoc> actually yes
<whatsupdoc> yes, you're right
chenbin has joined #lisp
<Zhivago> Ok, can you see a pattern here? How could you turn (1 (6)) into (1 (4 6))?
<whatsupdoc> add a 4
<learning> is mop implmentation dependent
<aeth> yes
<aeth> use closer-mop
<beach> learning: Yes. CLOSER-MOP is one of those wonderful compatibility packages though, so you can use it independently of your implementation.
<learning> and i can see how shit works cause its on github!
chenbin has quit [Remote host closed the connection]
<beach> You can even see non-shit things.
<whatsupdoc> why do people learn lisp? it seems so annoying to program in
<Zhivago> whatsupdoc: To annoy C++ programmers.
<learning> non-shit open source code? blasphemy
<beach> whatsupdoc: Because we are silly people. I advice you to quit before it's too late.
<k-hos> zhivago I'm a c++ programmer learning lisp ._.
vultyre has quit [Quit: Leaving]
<whatsupdoc> you don't even have types like how the heck can you even do anything complex
<aeth> whatsupdoc: Consider the problem of doing foo at compile time. Clearly, that's possible in dozens of languages.
<Zhivago> whatsupdoc: Consider (defun add (l) (if (endp l) 0 (+ (first l) (add (rest l)))
<Zhivago> whatsupdoc: You do have types -- what is (type-of 10)?
<aeth> But doing things at compile time is painful in nearly every language.
<whatsupdoc> two types
<whatsupdoc> lists and atoms
<beach> whatsupdoc: We can't. Like I said, we are silly people. Quit before it's too late, or you won't want to go back to your current languages ever again.
<whatsupdoc> so basic
<Zhivago> whatsupdoc: atoms aren't types -- see above.
<whatsupdoc> number
<Zhivago> whatsupdoc: So your thesis is wrong -- become less ignorant and ask a more intelligent question.
<k-hos> what is a type but a miserable collection of bits
<learning> i got to a point where i needed to commit to a language if i wanted to get better at programming. so i chose the one that fit my personality type, the one with outlandish promises of how amazing it is. that's why i chose lisp. it took me years before i actually got to the point where i could explain using lisp over other languages. and ive been a slightly less shitty programmer ever since
<Zhivago> whatsupdoc: Now, understanding how 'add' works, can you see how your problem has a similar recursive structure?
<learning> are you using rainbow parentheses?
<Zhivago> k-hos: Did not knowing lisp annoy you? :)
<beach> Is the fact you did not know Lisp the reason why you came here today?
<whatsupdoc> I don't know what endp is yet
<k-hos> before I decided to learn it? not really
<beach> clhs endp
<k-hos> I wanted a change though
<beach> whatsupdoc: ↑
<aeth> (and (typep 10 'number) (typep 10 'real) (typep 10 'rational) (typep 10 'integer) (typep 10 '(signed-byte 64)) (typep 10 'fixnum) (typep 10 '(unsigned-byte 32)) (typep 10 '(integer 0 1000)) (typep 10 '(mod 360))) ; not an exhaustive list
<learning> lisp has no types, 2 types, blue types, red types: http://sellout.github.io/media/CL-type-hierarchy.png
<k-hos> and lisp seemed like an interesting direction, since I have always liked the syntax
<learning> so much types!
<aeth> lisp has too many types
<beach> learning: "many". Much stuff, many things.
<learning> im being silly
<learning> that was post doctor seuss ref
<Zhivago> whatsupdoc: Just pretend that you're not a completely useless human being and look it up.
<beach> Zhivago: I admire your patience.
<learning> the problem with trolling lispers is that we can't wait to talk to anyone about lisp
<beach> Heh.
<aeth> learning: we're like missionaries
<learning> ^^
<aeth> a missionary will talk to you for ages
<learning> perfect analogy
<aeth> the only difference is that we're not yet organized enough to go door to door
<learning> xach is working on a bot to do that for us
smaster has quit [Quit: WeeChat 2.0.1]
<learning> 1 line of lisp code
<aeth> hopefully a roomba
<Zhivago> beach: Eventually some of them unlearn their acquired stupidity sufficiently to be able to learn.
<beach> Zhivago: I know. It just hard work convincing them.
haruka has quit [Remote host closed the connection]
<Zhivago> Working with three year olds is in that regard much nicer.
<beach> I like the term "acquired stupidity". Do you mind if I used it in my essays?
<beach> True that.
haruka has joined #lisp
<Zhivago> Certainly -- it comes from viewing stupidity as a set of learned skills to help prevent learning.
<beach> Yes, I understand. And I like that view.
<beach> The spirit is totally opposite to that of #lisp.
<whatsupdoc> Zhivago don't get me wrong i'm not retarded
<whatsupdoc> i'm totally capable of solving that problem https://pastebin.com/raw/U2Yj1EzK
xt3 has joined #lisp
<beach> This must be ECS 140A.
<whatsupdoc> i was just curious of how to do it in 1 function
<whatsupdoc> lol
<beach> I should ask the professor how this is taught.
<whatsupdoc> beach: it's a valid solution
<whatsupdoc> the way i did it works perfectly fine
<aeth> protip: you can add ;s at he end of every line if you really want to make it ugly
<Zhivago> whatsupdoc: Well, if you were retarded you would have a legitimate excuse.
<beach> whatsupdoc: You seem to know nothing about elementary software engineering. If you submitted such non-idiomatic code to me, I would give you a failing grade.
<whatsupdoc> what do you mean?
<Zhivago> He means that you write code like a retarded monkey might, if given sufficient drugs.
<learning> i end all my lisp lines with semicolons just to remind myself that it's my choice not the computer's
<beach> whatsupdoc: Your code doesn't even follow the formatting conventions of Common Lisp. Maybe you have not been taught that code is mainly a means of communication between developers and not between a developer and the computer.
<beach> whatsupdoc: So the first thing you need to do is to respect the conventions that the people reading your code are used to.
<whatsupdoc> what's the proper formatting?
<aeth> learning: You can even write C in Lisp if you non-portably use type declarations in declare or portably use check-type and pretend that that's good enough (it usually is)
<whatsupdoc> source?
<aeth> learning: but that's not as fun as writing asm in lisp, with tagbody
<Zhivago> It's hard to do C properly without pointers.
<beach> whatsupdoc: I think if you were to read a few existing Common Lisp programs, you would see how different they look from the code that you show us.
<learning> or use a C library in lisp, you'll be writing C code in no time!*** *haven't actually done this
<aeth> Zhivago: just have a large array of (unsigned-byte 8)s or something, C doesn't have any types, anyway, just bytes
<aeth> (C not having any types is probably more accurate than CL not having any types)
<beach> whatsupdoc: In that respect, programming is like writing novels. You have to read a lot of what other experts write in order to do it the way it is supposed to be done.
<learning> asm rofl
<whatsupdoc> i really need a book on lisp
<learning> little lisper will get you started
xt3 has quit [Client Quit]
<aeth> learning: just replace variables with an array representing registers and a larger array representing memory, and do everything in a tagbody, and you're basically there afaik
<whatsupdoc> i think it's a cool idea, but it's so different from waht i have seen in C/C++
<learning> pencil and paper
Bike has quit [Quit: Lost terminal]
<Zhivago> aeth: If that were true, then arithmetic wouldn't work -- C has types, the bytes are just the underlying representation.
<learning> this god damned joke police
<learning> real talk
<beach> whatsupdoc: The idea of programming as communication is common to all languages. There are lots of incompetent programmers who don't realize that, of course.
<learning> i almost chose c over lisp
<learning> and i was following a tutorial and the dependency wouldn't install
<learning> i said fuck it all and never looked back
Naergon has quit [Remote host closed the connection]
<whatsupdoc> is there a list formatting tool?
CrazyEddy has quit [Ping timeout: 248 seconds]
<aeth> learning: Fortunately, handling C and C++ dependencies has gotten better since then.
<aeth> Just kidding! :-p
<learning> hahahahaha
<learning> i was enjoying it too!
<learning> i was following C The Hard Way
<beach> whatsupdoc: I suggest you install Portacle. It is a set of tools for Common Lisp that are easy to install.
<whatsupdoc> dang looks interesting thanks
<learning> you need rainbow parentheses!
<learning> rainbows faggot!
<aeth> I just wish CL had a standard for "inline" assembly. Then we wouldn't ever need to use C, and some better low-level abstration would have been built by now.
<learning> sorry im going to calmdown
<whatsupdoc> using no ide is so annoying, too many times i missed parentheses already
<vtomole> How would you write C in Lisp with respect to manual memory management? Turn off the GC?
<learning> we just need a common lisp to llvm converter
<learning> so i can write WASM in lisp
<aeth> learning: good news
<beach> Oh wow, the instructor's code stinks too!
<aeth> learning: talk to drmeister if you're serious
<learning> im waiting for wasm to mature
<beach> That code is just awful.
<learning> apparently you cant access the dom yet?
<whatsupdoc> lol
<beach> The blind leading the blind.
<beach> Oh well.
* drmeister ears are burning - not just because his name was mentioned but the salty language!
<learning> why are the parentheses formatted the way i did it on my first day with lisp
<vtomole> beach: From my experience, professors are usually not software engineers. They are computer scientists who write proofs all day long basically. Most of them don't program.
<learning> sorry dr lol
<whatsupdoc> the examples we've seen are one or two liners
<learning> i went on a huger rant today about how the people who teach programming don't actually make programs
<learning> because someone asked on quora, "if i get a B in my java class does that mean im too incompetent to become a programmer?"
smurfrobot has joined #lisp
<learning> that's just how we write programs in lisp. 1 or 2 lines and then get back to spamming irc.
<Zhivago> aeth: Javascript has everything you want -- it is the most successful of the lisps :)
<learning> hahahhaha
smasta has joined #lisp
<Zhivago> The inability to spell "I'm" is probably the clincher.
<learning> are you seriously on my ass because i used a contraction OF A CONTRACTION
<learning> get on my contraction lvl bruh
parjanya has quit [Ping timeout: 256 seconds]
smurfrobot has quit [Ping timeout: 240 seconds]
CrazyEddy has joined #lisp
z3t0 has joined #lisp
whatsupdoc has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<aeth> Zhivago: Common Lisp should copy the way JavaScript handles numbers because the numeric tower is too complicated.
stacksmith has joined #lisp
<fouric> learning: that type diagram is super dope
<learning> oh yeah. love it.
<aeth> it's actually a simplification!
Kundry_Wag has quit [Ping timeout: 255 seconds]
<fouric> O.o
<fouric> that's amazing lol
<fouric> oh, *there's* the hierarchy of number types that i've been looking for all my life
<fouric> til (not (eq bignum fixnum))
<fouric> learning: also rainbow-parentheses is awesome too
<fouric> it's almost like a completely new axis of "sensation" has been added to my code
<fouric> i now read code using indentation *and* the colors of the parens
<fouric> Zhivago: but muh macros
<fouric> (also symbols)
<pfdietz> There is some weirdness in CL's array type rules/
<fouric> (i really wish javascript had symbols)
<Zhivago> Unfortunately they screwed up bignum and fixnum -- those should be classes, rather than types.
<fouric> why?
<Zhivago> fouric: What's wrong with strings being immutable symbols?
<Zhivago> Well, bignum and fixnum correspond to implementation strategies.
<fouric> because strings and symbols don't *do* the same things
<fouric> strings are meant for humans, and symbols are meant to name objects
<Zhivago> name objects for human use?
<fouric> fine, human use at runtime
<fouric> i haven't heard of a javascript runtime smart enough to optimize strings that happen to be the names of functions into pointers to the functions themselves
<fouric> (implementation strategies?)
borei has joined #lisp
<borei> hi all
<Zhivago> I would have thought trace lead strategies like v8 would have done that implicitly.
<fouric> aeth: "everything is a double"?
<fouric> Zhivago: i suppose i could be wrong, i haven't looked at the v8 source yet
Xal has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
<borei> i have quikc question about macros
<borei> macros and function that use it
<borei> it works
shrdlu68 has joined #lisp
<Zhivago> I expect it is a very nice question.
<borei> but im not happy that i use i and j indexes implicitely
<borei> im not sure about proper lisp solution
<Zhivago> I acknowledge your unhappiness and indecision.
<borei> my solution can be complete garbage, don't judge too strickt :-)
<Zhivago> Let me know if you decide to share your question.
<fouric> borei: Zhivago is trying to say that you should phrase your question as a proper question
<borei> let me try :-)
<fouric> however, to answer that question: i suggest modifying your macro to take symbols that are used to name the variables that you would like the values bound to
<fouric> sdl2's with-* macros do this
<fouric> lemme see if i can find one
<fouric> aha!
<fouric> see that RENDERER-SYM? when the renderer is created, it's assigned to a variable with that symbol as a name
nopf has quit [Remote host closed the connection]
<borei> question would be - i don't see that my solution is correct, but it works. Is there proper solution that will not implictly use indexes i and j in my case
<fouric> perhaps change that (MATRIX &BODY BODY) to be ((MATRIX ROW-SYM COL-SYM) &BODY BODY), then (LOOP FOR ,ROW-SYM FIXNUM FROM ... and (LOOP FOR COL-SYM FROM ...
<fouric> although Zhivag0 will probably have a better solution
stacksmith has quit [Ping timeout: 256 seconds]
<fouric> oh, and this isn't the question that you're asking, but that macro should probably bind MATRIX to a variable (named by a gensym, of course)
fikka has joined #lisp
<borei> hmm, but technically that macros doesn't need row-sym col-sym at all
z3t0 has quit [Remote host closed the connection]
st_iron has quit [Quit: ZNC - http://znc.in]
<borei> i was trying to build macros that is doing loop through all matrix elements and apply "something" to elements
<fouric> howso? don't you want to be able to access the elements of the matrix?
dieggsy has quit [Ping timeout: 276 seconds]
Xal has joined #lisp
<borei> elements are inside macros
<fouric> hm
* fouric has to go, but perhaps someone else can help
<fouric> sorry!
<borei> np np
zooey has quit [Remote host closed the connection]
<fouric> (we should consider putting a link to http://www.catb.org/esr/faqs/smart-questions.html in the topic)
<aeth> borei: a potential problem is if someone creates a matrix in the macro instead of passing in a matrix variable
<aeth> i.e. (with-matrix-elements (matrix ...) ...)
zooey has joined #lisp
aindilis has quit [Read error: Connection reset by peer]
st_iron has joined #lisp
aindilis` has joined #lisp
vtomole has quit [Ping timeout: 260 seconds]
<borei> aeth: i got your point
cpape has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 268 seconds]
<sigjuice> any particular reason why iolib has its own src/grovel/* ?
rumbler31 has joined #lisp
rumbler31 has quit [Read error: Connection reset by peer]
<borei> aeth: you just nailed me - i don't see way how to make that macros safe
fourier has joined #lisp
<aeth> I think this works (I'm doing the dangerous thing and writing it on the top of my head without testing it first): (let ((matrix-binding (gensym))) `(let* ((,matrix-binding ,matrix) ...) ...))
<aeth> although maybe worrying about the edge case isn't useful because the actual macro is apparently useless if the user does this edge case
<mfiano> My biggest concern with the code is why the need to reimplement the plethora of mature linear algebra libraries already available for Common Lisp?
<borei> learning purpose
<mfiano> You get more value studying how they were written then
<aeth> mfiano: nearly every library is 80% complete, which seems to encourage wheel reinvention
fourier has quit [Ping timeout: 260 seconds]
<mfiano> I am not sure where you get your statistics, but I find it not very factual.
<borei> well, to learn somebody logic and trying to develop and apply your own - i think it's different
<aeth> mfiano: The percentage is made up, but my point was: I'm not aware of any big scary libraries that discourage reinvention in CL except maybe cl-ppcre, although I think there's at least one other regex library.
<aeth> Oh, I guess maybe ASDF, too.
<mfiano> beach is right. We need to show even some of the CL veterans they are doing it wrong
krwq has joined #lisp
<jackdaniel> sounds like an interesting backlog to read :)
Oladon has quit [Quit: Leaving.]
<borei> i don't know - i think if you want to walk at least you need to learn how to make steps, just watching how other peoples are walking - doesn't help a lot
<beach> The code at the UC Davis website made me remember a long-term idea that I have had for some time. The background is that 1. Professors don't want to get early to give a lecture, 2. Students don't want to get up early to go to a lecture. 3. Lectures are very inefficient and that is well known. 4. Most professors are incompetent in Common Lisp anyway.
<beach> So I would like to put together a site with lots of linked pages, video snippets, talking heads, real-time coding, etc. to replace typical lectures.
<beach> It should allow for students with various levels of knowledge to follow.
dddddd has quit [Remote host closed the connection]
<beach> It must therefore allow for links to background material that the student may not have, but that is required.
<beach> And it should allow for advanced students to go faster than the others.
<beach> This way, courses based on Common Lisp can skip the lectures and concentrate on labs.
<beach> Furthermore, instructors, who are often incompetent in Common Lisp, software engineering, programming and whatnot, can follow the same lectures without embarrassing themselves by sitting in a lecture room.
Karl_Dscc has joined #lisp
smokeink has joined #lisp
<mfiano> I think we need a learning resource that guides a newcomer towards a proper Common Lisp editing environment. Today I had stumbled upon 2 newcomers using CLISP on _Sublime Editor_ with no SLIME, or anything.
<bjorkint0sh> beach, I thought you were gonna write the book to end all books on the subject of common lisp!
<bjorkint0sh> you've already got one :-)
<beach> mfiano: Yes, that would be one "diversion link" on such a site.
fikka has joined #lisp
<beach> bjorkint0sh: I have several book projects. I don't think I can squeeze everything into one book.
<bjorkint0sh> no? ebooks can be as GIANT as one wants them to be!!!
<beach> 1. Intro programming using Common Lisp. 2. Advanced Common Lisp programming. 3. Object-oriented programming in Common Lisp. 4. Common Lisp for language implementers. 5. Common Lisp language reference.
<aeth> The Art of Common Lisp Programming
<beach> Each one would probably be 500 pages or more.
mishoo has joined #lisp
<borei> i'd love to have such library
<bjorkint0sh> Damn. at which point would one finish reading and start programming?
<beach> bjorkint0sh: I have a problem with electronic books at the moment.
<bjorkint0sh> perhaps though, an annotated common lisp code which talks about what's going on and points out common themes?
<mfiano> I spent about an hour trying to get them familiar with a proper environment, and about 45 minutes were used up by their persistence to use a "text editor". I don't know of any good resources that explains why one needs a proper editing environment for modern Common Lisp.
<beach> bjorkint0sh: Either they are available for free, and I would not get any compensation for my work, or else they are controlled by companies such as Amazon.
<aeth> bjorkint0sh: Or an IDE with excellent integrated tutorials
<bjorkint0sh> that way, one's looking at code immediately, not endless drivel about list manipulation and bindings.
<bjorkint0sh> beach, ah I get it. it's a conundrum indeed.
<beach> Yeah, I don't know what to do about it.
smurfrobot has joined #lisp
<phoe> jupyter notebooks?
<beach> For the "lecture site" project, I am thinking that each video snippet should be short, perhaps max 10 minutes, as opposed to the length of a typical lecture.
<beach> That would suit people with an attention span of a gnat, which seems more common these days.
fikka has quit [Ping timeout: 256 seconds]
<bjorkint0sh> there's lots and lots and lots of 'talking heads'. endless. what I don't see a lot of, is "this is written code. this is what's wrong with it. this is what's right with it".
<beach> bjorkint0sh: Yes, that would definitely be needed.
<beach> Since such a site would not have to fit into any particular format, one could have lots of material like that. Material that would typically not be part of a course.
<bjorkint0sh> i've got at least 20something books on common lisp alone. the only one which comes close to the code-first approach is land of lisp.
<beach> Maybe some day I'll sketch out a "table of contents" of such a site.
<bjorkint0sh> perhaps that's all that's needed! a TOC!
<beach> Different people learn very differently, so it would be good to support different styles of learning.
<bjorkint0sh> the book-ey approach is the most popular.
<bjorkint0sh> you know what's really hard? knowing why one approach is better or worse than another.
<borei> can somebody drop me some input on my code - https://pastebin.com/R1Tc0sgg. i got some feedback from aeth:, but conversation switched direction
<shrdlu68> Different authors also phrase things very differently. I find that consulting multiple references when learning something new works best for me.
<beach> bjorkint0sh: The table of contents would contain desired video snippets and code examples for every "page". Then we could ask the knowledgeable people here on #lisp to record snippets and make up code examples.
<bjorkint0sh> aha! that sounds fantastic.
<phoe> borei: the fact you don't allow the user to define vars for I and J seems not okay in this scenario.
<phoe> I might prefer X and Y.
<phoe> I also hope you don't expose this macro externally outside your code. OPTIMIZE decisions should be left to the user.
<phoe> Also, LOOP FOR I FIXNUM is redundant, I is already declared fixnum.
<shrdlu68> just reminding the compiler
<mfiano> It's also redundant in that "from 0" is the same as leaving it out.
<phoe> mfiano: actually this one I often leave in code for readability.
<phoe> But that's just my habit.
<borei> macros is only for internal use, i don't see that it's gonna be exposed
<mfiano> I don't like that you aren't using proper indentation style either
fikka has joined #lisp
<mfiano> It makes reading it more work
<phoe> that too, LET is indented wrong.
<borei> a bit confused about I and J vs X and Y ??
<mfiano> also the loop forms are
<phoe> borei: you implicitly bind variables I and J inside your macro.
<borei> copy-paste from emacs
aindilis` has quit [Remote host closed the connection]
<mfiano> both "do" levels are inconsistent, and neither is correct
<phoe> (with-matrix-elements matrix (print x) (print y))
<phoe> I can't do that with your code.
d4ryus1 is now known as d4ryus
damke_ has joined #lisp
<phoe> If anything I'd go for (with-matrix-elements matrix (foo bar) (print foo) (print bar))
<phoe> where (FOO BAR) is where I can bind my own variables.
<mfiano> Consider what would happen if you pass in the symbol ROWS for MATRIX
damke has quit [Ping timeout: 264 seconds]
<phoe> oh right, there is no gensym there
<jackdaniel> beach: regarding publishing: have you considered self-publishing or 'pay what you want' model? leanpub comes to mind as one of platforms making this simple
<beach> I do use self publishing at the moment.
<mfiano> phoe: nor once-only
<phoe> so (with-matrix-elements matrix (setf rows nil)) has undefined consequences
<borei> yeah
<beach> jackdaniel: But I am using CreateSpace, which is part of Amazon. That way I get access to their network. But it has disadvantages of course.
<borei> damn, for me right now it's pandora box
<mfiano> (make-array 16) would be evaluated twice for example
<jackdaniel> uhm, maybe I misunderstood the problem then
nika_ has joined #lisp
<mfiano> borei: If you are going to be writing macros, you should learn about WITH-GENSYMS and ONCE-ONLY, which are utilities not included in the standard. They are required for a lot of macros, such as this one.
Naergon has joined #lisp
<borei> yeah
Karl_Dscc has quit [Remote host closed the connection]
<borei> ok, seems like i got what is my problem with that macros.
<mfiano> There isn't just one problem
<mfiano> It suffers from double evaluation, and accidental capture
<mfiano> I would actually recommend reading On Lisp or Let Over Lambda
<borei> If enduser will use I, J, ROWS nand COLS in the &body - that will cause conflict situation
<borei> can you please clarify - "double evalution" ?
<jackdaniel> you've missed a wonderful opportunity for a typo: ROWS and CLOS :-)
<jackdaniel> borei: double evaluation is when you have symbol a in macro bound to (list 1 2 3), so if you put ,a twice in the body, you will have (list 1 2 3) evaluated twice
<phoe> and ending up two separate objects, in this case
<phoe> in other cases, you might have side effects executed twice
EvW has joined #lisp
<mfiano> the matrix argument is evaluated twice. If the user passes in a form which allocates an array, it would allocate 2 arrays just to get the subscripts of 1 intentional array
<mfiano> In this case I don't know if it is problematic, other than needlessly expensive
<mfiano> I really stoped looking at the code minutes ago
<jackdaniel> borei: workaround for that is using once-only macro which works like this:
<jackdaniel> (alexandria:once-only ((a '(1 2 3))) a) ;; -> expands to:: (LET ((#:A527 (1 2 3))) #:A527)
<jackdaniel> maybe this pictures that better: (alexandria:once-only ((a (list 1 2 3))) (cons a a))
<borei> holy !!!
<mfiano> borei: consider what would happen if the user passed in (make-array '(1000 1000)) or something stupid. Look at the expansion
<jackdaniel> borei: this may be a good lecture for you: http://www.gigamonkeys.com/book/macros-defining-your-own.html
<borei> it will exhaust memory in a fraction of second
<jackdaniel> it talks about various gotchas with macros (once-only and with-gensyms included)
<mfiano> This guy sums it up pretty nicely http://malisper.me/once-only/
mikecheck has left #lisp ["part"]
<phoe> borei: maybe not exhaust memory
EvW has quit [Ping timeout: 252 seconds]
<phoe> but it'll make the allocator and the GC spin like crazy
<mfiano> The point is it would allocate a copy of the array AGAIN
<borei> out of topic question - how many years it takes in average to cover lisp ecosystem to start build more or less ok code ?
<mfiano> regardless of size, that is wasteful
<mfiano> borei: Everyone learns at different paces. I am slow, so I will refuse to answer that question out of embrassment.
LocaMocha has joined #lisp
<borei> ok, im back to reading - variables, symbols and macroses
<mfiano> If you haven't read PCL in its entirety yet, I would start there, making sure you do the practical code-writing chapters, too. Macro writing is something that takes a bit of practice and learning from mistakes to really understand the gotchas involved.
<aeth> borei: it always takes years, the amount of years varies because there are too many variables
<aeth> although it might be doable in less than a year if you come from a very similar language (a Scheme?)
<borei> nah, not my case
<borei> seems like it will be Xen-way for me
<aeth> It could be shortened with better tools, better documentation, etc.
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
haruka1 has joined #lisp
haruka has quit [Ping timeout: 248 seconds]
<aeth> There are lots of things that I suddenly realize I can rewrite years-old things to use.
<aeth> And once you discover the right abstraction to use, you often find problems with the original.
<borei> ok, i gonna digest information,
<borei> thanks a lot for conversation !
hiroaki has joined #lisp
<aeth> (I suppose that the language could also be mastered in a short time if someone had a full time job in it.)
mishoo has quit [Ping timeout: 276 seconds]
sabrac has quit [Ping timeout: 252 seconds]
sabrac has joined #lisp
marusich has quit [Ping timeout: 240 seconds]
Tobbi has joined #lisp
marusich has joined #lisp
sjl has joined #lisp
hiroaki has quit [Ping timeout: 256 seconds]
sjl has quit [Ping timeout: 248 seconds]
learning has quit [Remote host closed the connection]
manualcrank has joined #lisp
Oddity has quit []
scymtym has quit [Ping timeout: 260 seconds]
mishoo has joined #lisp
hiroaki has joined #lisp
Oddity has joined #lisp
chens has joined #lisp
chens is now known as Guest35886
<fouric> mfiano: i wrote a short guide on getting set up with emacs/slime/quicklisp:
<fouric> it's not nearly as complete as what you were probably thinking of, but it's a start, and it can be mutated
damke has joined #lisp
<mfiano> fouric: While nice, it doesn't solve the problem I am constantly faced with, and that's explaining why it's important not to use an _editor_ to write Common Lisp, and also transitioning a newcomer to Emacs (or Spacemacs, or even Vim with slimv, vlime, etc) is a task and a half.
<fouric> oh, sorry
<fouric> i misunderstood the problem
<mfiano> Most people new to Lisp are never even introduced to why it's important. They pick up [insert CL book here] and open their text editor to follow along.
vlatkoB has joined #lisp
<shrdlu68> mfiano: Most Lisp books do address that.
damke_ has quit [Ping timeout: 264 seconds]
smurfrobot has quit [Remote host closed the connection]
<mfiano> Can you name one that explains how to set up SLIME/Sly, paredit/etc, a modern implementation, and Quicklisp?
<shrdlu68> mfiano: Oh, seen the backscroll, sorry.
<mfiano> and bonus points for how to use them
spiaggia has joined #lisp
<sigjuice> mfiano portacle should make the "set up" part go away
safe has quit [Read error: Connection reset by peer]
<fouric> TIL about portacle
<sigjuice> fouric linedit is gone from the latest quicklisp, btw
<mfiano> sigjuice: Yes it helps greatly, but there is no book or lecture that mentions it, and it takes persuading users away from their favorite Sublime Text editor, etc, which is difficult...if I even notice they are using them...again, there are too many people that do not know how to start using a Common Lisp environment when they pick up a Common Lisp book or take a Common Lisp course.
<fouric> i saw D:
* fouric hasn't really had the time to update the post
nullman has quit [Ping timeout: 276 seconds]
<sigjuice> mfiano agreed
fikka has quit [Ping timeout: 276 seconds]
nullman has joined #lisp
<shrdlu68> mfiano: Perhaps it's because most authors assume the implementation's RELP will be enough, and don't intend to complicate things too early.
smurfrobot has joined #lisp
<mfiano> I feel that mistake was repeated too many times
<mfiano> For any other language I can understand skipping the tooling process
<shrdlu68> "The Land of Lisp", for example, seems to assume the the CLISP REPL will be enough for learning purposes, at least initially.
<shrdlu68> I understand that, both from the author's and new learner's perspective.
<shrdlu68> Of course, once the learner progresses beyond a certain point some effort should be made to creating a suitable environment.
welle has joined #lisp
flamebeard has joined #lisp
<mfiano> I'm not suggestion an in-depth walkthrough of configuring Emacs or setting up Quicklisp. Just a mention that they will not be getting the full language experience by a mile without eventually looking into [list of tools].
<mfiano> I see quite a few people decide CL is not right for them, and I wonder if this is part of the reason after my experience helping newcomers.
milanj has joined #lisp
<shrdlu68> I doubt it is - most learners would be smart enough to incrementally adapt their environment to their immediate needs.
<sigjuice> if someone is reading PCL today, shouldn't it be possible to just substitute "Lisp in a Box" with Portacle?
panji has quit [Ping timeout: 268 seconds]
<sigjuice> though I'm not sure how much Emacs coverage is in PCL
<mfiano> Assuming they were aware of it, they weren't so attached to [traditional editor], and actually knew why it's needed for the full experience, I don't see any problem.
<mfiano> My point is most developers have grown attached to their traditional development editor/IDE which is unsuitable for Common Lisp, but they don't know any better.
angavrilov has joined #lisp
<sigjuice> true. I happen to be overly attached to Emacs
<mfiano> :)
<fouric> (spaaaaaaaaaaaacemacs)
* fouric is a fanboy of both lisp but also the vim modal editing interface
smurfrobot has quit [Remote host closed the connection]
<mfiano> I've used Vim for CL for about 8 years, switched to Emacs a couple years ago, switched to Spacemacs recently...and now I'm using vim again (in addition to Spacemacs on some devices)
marusich has quit [Ping timeout: 256 seconds]
<mfiano> fouric: Considering you are using Spacemacs, I have a favor to ask
<fouric> If I have time I'll do whatever
Cymew has joined #lisp
marusich has joined #lisp
krwq has quit [Remote host closed the connection]
<mfiano> fouric: I released this yesterday out of demand. A couple other people found it useful. If you want to try it out and report back, I'd appreciate it :) https://github.com/mfiano/common-lisp-sly
<fouric> oooh, I've had my eye on Sly for a while now
<fouric> I'll gladly hack with it for a few hours tomorrow and report back
<fouric> Thanks for assembling this!
<mfiano> Sure thing
<fouric> wait, what's `evil-cleverparens`
<fouric> ...is this a paredit-equivalent that knows about evil?
<mfiano> It allows "structually-safe editing"
<mfiano> No
<fouric> oh
<mfiano> You still use Spacemacs' builtin smartparens
<mfiano> This allows for example, deleting a line of a form while keeping parens balanced, etc
<mfiano> dd will not cause stray parens etc
<sigjuice> mfiano I too switched from vim to emacs from vim nearly 10 years ago. I tried evil, vimpulse etc. in the beginning but grew out of it eventually. I still end up typing j's and k's into my text once in a while.
smurfrobot has joined #lisp
welle has quit [Ping timeout: 260 seconds]
<mfiano> Ha
<fouric> mfiano: i've been looking for that for years
<fouric> i got started with paredit and evil-mode, and neither of them is aware of the other
<mfiano> fouric: It's actually builtin to Spacemacs 0.300 (technically not released yet, so you should be on the develop branch for this layer to work)
<fouric> oh, got it
<mfiano> Well builtin, but not enabled by default. You have to follow the README instructions for this layer to set it properly
<mfiano> under "Structurally Safe Editing"
* fouric is definitely pressing that button
<mfiano> I would encourage you to read the Sly documentation if you are curious about the few features it adds, such as my favorite, "stickers".
<mfiano> Basically you can attach a 'sticker' to any symbol, form, etc
<mfiano> and they show up in grey. you can add also add a sticker to a form/symbol within a sticker, and it'll show up as a darker shader of grey...
<mfiano> then you C-c C-c the defun or wherever they are defined to "arm" them, and they turn to shades of blue.
<mfiano> then you run your code, and each sticker captures every value that the stickers have seen, and you can cycle through the replay
<mfiano> inspecting their values or historical values etc
fikka has joined #lisp
<mfiano> basically print debugging, but non-intrusively, and able to inspect even past values
<mfiano> h and they turn from blue to green when they have captured something during execution
<fouric> that is *super* cool
<mfiano> It's an improvement on print/format debugging
smurfrobot has quit [Ping timeout: 260 seconds]
smokeink has quit [Ping timeout: 256 seconds]
<mfiano> There is one thing you may miss from SLIME if you use Sly though...it doesn't have a contrib for SBCL's statistical profiler
<mfiano> Other than that I haven't looked back for a couple years :)
fikka has quit [Ping timeout: 268 seconds]
<fouric> hm, i don't know what a contrib is
<fouric> i'm guessing it's a slime extension
<fouric> ...but that tells you how much i actually grok slime
<mfiano> Right
fikka has joined #lisp
* fouric has used SBCL's statistical profiler before but without said contrib
EvW1 has joined #lisp
<mfiano> Same, I actually haven't used SLIME outside of vim's client atop the CL swank server
<fouric> ...oh, that's right, there's a vim client for SLIME
<fouric> erm
<fouric> swank?
smurfrobot has joined #lisp
<mfiano> SLIME is a client and server.
<mfiano> in vim, you'd use the CL server part with one of the few vim client implementations rather than elisp
LocaMocha is now known as Sauvin
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
scymtym has joined #lisp
<sigjuice> there are also SLIME clients written in Common Lisp
<jackdaniel> sigjuice: you mean swank clients
<p_l> "Symbolics" appears to have a sale
<p_l> three LispMs on ebay
<jackdaniel> slime is a swank client meant for emacs
<fouric> got it
<fouric> ty
nowhereman has joined #lisp
nowhereman is now known as Guest37349
<sigjuice> jackdaniel touché
panji has joined #lisp
nowhere_man has quit [Ping timeout: 276 seconds]
varjag has joined #lisp
<mfiano> jackdaniel: Thanks
<spiaggia> jackdaniel: When McCLIM says that it couldn't use fontconfig to configure fonts and that I have to do it manually, does that mean that I have to install a program (named fontconfig)?
* spiaggia is really beach on a train from Bordeaux to Paris.
<jackdaniel> spiaggia: you can also provide path yourself
<jackdaniel> or you may push mcclim-ugly to features (don't remember exact name) to use native Xorg fonts
<spiaggia> I can imagine. But I don't know how.
<spiaggia> I am willing to try something other than the ugly fonts first.
<jackdaniel> spiaggia: check out Extensions/fonts/fontconfig.lisp
<jackdaniel> you have suspicious paths listed in *truetype-font-path*
<spiaggia> Will do, thanks.
<jackdaniel> maybe you don't have dejavu-fonts installed on your system
<Cymew> p_l: Probably the last ones in a long while, is what I've heard.
<spiaggia> I don't have the fontconfig program installed for one thing. Installing now.
<p_l> I'm assuming DKS is slowly cleaning the warehouse as means of supporting retirement
<jackdaniel> sigjuice: also afair swank client written in common lisp had a name "swine"
<jackdaniel> and was part of climacs project (don't know what's its status now): https://www.common-lisp.net/project/climacs/images/screenshots/old/swine-ss.png
<phoe> hahahah, swine
<sigjuice> also just discovered this one #<SYSTEM trivial-swank / trivial-swank-quicklisp-ab90d90f-git / quicklisp 2018-01-31>
<phoe> oh
makomo has joined #lisp
<jackdaniel> from other interesting bits of information, if you read into swank sources there are hints, that implementing more rich presentations was planned (i.e sending images etc)
<jackdaniel> but it is not implemented whatsoever, just comments
<spiaggia> jackdaniel: Installing the fontconfig program solved the problem.
<jackdaniel> \o/
smasta has quit [Ping timeout: 264 seconds]
<spiaggia> This train claims to run at 318 KM/H. Is that Kelvin Mega per Henry?
<jackdaniel> maybe we should bundle basic foss ttf set?
<phoe> spiaggia: that is #lispcafe material
<spiaggia> Sorry.
<phoe> jackdaniel: I think it would be sane
<jackdaniel> just in case system fonts can't be found (i.e are not installed)
<phoe> spiaggia: no problem (:
<spiaggia> The McCLIM question was on topic though.
<phoe> yes
<spiaggia> jackdaniel: That's an idea.
hhdave has joined #lisp
bjorkint0sh has quit [Remote host closed the connection]
bjorkint0sh has joined #lisp
<sigjuice> jackdaniel were you referring to this? https://github.com/slime/slime/blob/master/contrib/slime-media.el
gonewest818 has joined #lisp
<jackdaniel> sigjuice: close. I was referring to the comment in this empty file: contrib/swank-media.lisp
Patternmaster has quit [Ping timeout: 268 seconds]
<sigjuice> I don't recall the details, but I remember doing something that produced images in my *slime-repl sbcl* buffer.
oldtopman has quit [Ping timeout: 276 seconds]
mlf has quit [Quit: KVIrc 4.2.0 Equilibrium http://www.kvirc.net/]
oldtopman has joined #lisp
terpri has quit [Ping timeout: 248 seconds]
<pjb> To Paris, shouldn't that be plage; and to Roma spiaggia?
_cosmonaut_ has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<spiaggia> Damn! I knew I got it wrong.
EvW1 has quit [Quit: EvW1]
gonewest818 has quit [Remote host closed the connection]
_whitelogger has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
damke_ has joined #lisp
smurfrobot has quit [Remote host closed the connection]
damke has quit [Ping timeout: 264 seconds]
nirved has joined #lisp
thodg has joined #lisp
Guest35886 has quit [Remote host closed the connection]
<thodg> linear programming do not solve genetics
<thodg> does*
<thodg> we're fractal
<flip214> Is there anything that can circumvent the cleanup clause of an UNWIND-PROTECT?
<phoe> flip214: no
<Shinmera> Sure, lots of things. Power going off, the process dying or being halted by a debugger
bjorkint0sh has quit [Remote host closed the connection]
<phoe> ...well, these are drastic measures
<thodg> flip214: that is external to common lisp program
<flip214> phoe: so, getting back to my question of yesterday evening, how come the UNWIND-PROTECT in hunchentoots PROCESS-CONNECTION doesn't close the socket?
<thodg> flip214: this is probably UNIX lingering
<jdz> flip214: Are you sure it does not?
<flip214> Shinmera: in the first two cases the socket wouldn't still be active ON THIS MACHINE
<thodg> the socket remains in system to catch late packets
<flip214> and the third one would be done by me
<flip214> thodg: tcp 512 0 127.0.0.1:8123 127.0.0.1:42926 VERBUNDEN 28714/sbcl
<Shinmera> Who knows, maybe it's the NSA :tinfoil:
<flip214> thodg: the second-to-last means CONNECTED
<thodg> flip214: that's not it then
<flip214> Shinmera: I don't believe that they're bugging me on that level
<phoe> flip214: are you sure it is executed? can you print something inside that unwind-protect to make sure control flow reaches it, just to be absolutely sure?
<phoe> because if the control flow reaches the cleanup forms then the problem is elsewhere and most likely deeper
<jdz> Add a call to BREAK even!
<flip214> https://pastebin.com/5nmbABZf in case anyone's interested.
<phoe> break, sure thing
<jackdaniel> flip214: most obvious reason: destroy-thread
<jackdaniel> second most obvious reason: a thread without handler-case being its first form
smurfrobot has joined #lisp
<jdz> flip214: Did you close the browser window?
<jdz> Maybe it's the keepalive mechanism that keeps the sockets open.
<jdz> Just a wild guess.
<flip214> jdz: no. the QUUX acceptor stops working (as the child thread returns an unexpected error instead of :handler-done),
<flip214> and so everything breaks down.
<thodg> jdz: nope it would be in WAITING state
<flip214> But I'd like to understand what causes the unwind-protect to be skipped... jackdaniel's terminate-thread might be the reason, but I don't know lparallel good enough yet.
<thodg> jdz: keep-alive through unwind-protect ?
<jdz> thodg: by definiton.
<thodg> flip214: did you try to macroexpand it ?
<jdz> HTTP keeplalive, allows multiple requests to be served on the same connection.
<jdz> Can't do that if connection is closed after each request.
<thodg> jdz: yes but if he calls close in an unwind protect and be sure about it how would the socket remain open ?
<thodg> connected even
<thodg> that would not be common lisp to me
<jdz> I don't have the code, and it would be wrong to close the socket oneself because that's Hunchentoot's job.
<flip214> thodg: which part? QUUX, HT, LPARALLEL, ...?
<flip214> jdz: that's the problem, HT doesn't close it
<jdz> flip214: Maybe because it's not supposed to? That's my suggestion.
<flip214> jdz: the thread dies, the connection is lost in GC. why shouldn't it be closed?
<thodg> well if there is no data on the socket maybe the system will close it eventually
<thodg> send pacman he knows these things
<jdz> flip214: how do you know the connection is lost?
<phoe> flip214: "thread dies"
<phoe> connections are not closed when they are lost.
<thodg> you just never made connection again, but its not new
<thodg> right ?
<phoe> when you open a socket and then lose reference to it, it'll leak.
<thodg> i mean is it not a new socket ?
<phoe> a thread dying is not enough for Lisp to infer that it should close that socket.
attila_lendvai has joined #lisp
<thodg> that you went to create
<jdz> Also ending up in a debugger does not mean the thread dies.
<phoe> if anything, you could try to wrap a finalizer around it, calling close on the associated socket-stream.
<pjb> Unless you put a thread at exit function and close it explicitel from there.
<pjb> But bordeaux-thread doesn't provide this API AFAIR.
<phoe> just to make sure that when the GC runs to clean up the usocket, its associated stream is closed.
<phoe> pjb: TRIVIAL-GARBAGE provides finalizers.
<phoe> oh wait, at-exit functions.
<pjb> thread exiting is a differnt situation.
<phoe> BT doesn't have it.
<flip214> according to TRACE, BORDEAUX-THREADS::DESTROY-THREAD isn't called.
<jdz> The whole point of "thread pooling" is to have a pool of threads and reuse them instead of creating and destroying a thread for each connection.
<jdz> Or request even.
<thodg> jdz: well if the thread is not dead it might also close its socket on unwind-protect its true
<thodg> but that might not be the thread's job
<phoe> But if the thread is alive and its unwind-protect forms are *not* called, then it means the thread is still inside unwind-protect.
<pjb> it's pthread_cleanup_push(3)
<flip214> thodg: jdz: the thread is dead (killed by :transfer-error)
<jackdaniel> thodg: each lambda send should have body wrapped in handler-case
markong has joined #lisp
<jackdaniel> (even with no actual handlers)
<phoe> flip214: so it was killed but not by BT:DESTROY-THREAD?
<jackdaniel> because even if it is not killed by destroy-thread
<jackdaniel> you have no guarantee that thread is protected
<jdz> flip214: I'd just suggest to look at the implementation of thread-pooling-taskmaster.
<jackdaniel> so having error in such thread, if there is no top-level handler-case is equivalent to crash (or destroy-thread)
<pjb> But more seriously, the right CL way to do it, is: (bt:create-thread (lambda () (UNWIND-PROTECT (your-thread-code) (DO-YOUR-CLEANUP-HERE!))))
milanj has quit [Quit: This computer has gone to sleep]
<flip214> phoe: either that, or there's a bug that inhibits UNWIND-PROTECT doing the cleanup.
<flip214> jdz: that's what I'm doing for a week.
ludston has quit [Read error: Connection reset by peer]
<jackdaniel> pjb: that's not enough, it should be (bt:make-thread (lambda () (handler-case (…)))
<jdz> flip214: also remember you have hunchentoot:*catch-errors-p* set to nil.
<flip214> pjb: that's what HT does in the PROCESS-CONNECTION method
ludston has joined #lisp
<flip214> jdz: nonetheless the UNWIND-PROTECT should trigger.
<thodg> pjb: you're probably right
<pjb> The implementation should have a handler-error around calling the thread lambda.
<jdz> flip214: How exactly do you conclude that it is not triggered?
<thodg> i'm stuck
<jackdaniel> pjb: that's not guaranteed and in fact it doesn't happen on sbcl if you have --disable-debugger option and run standalone binary
<thodg> are there any good Lisp canons ?
<jackdaniel> we actually had a hard to find bug related to exactly that
<pjb> jackdaniel: then right it's always better to do your own handler-case.
jibanes has quit [Ping timeout: 256 seconds]
<pjb> Since the default handling is probably not what you want for your application anyways.
<jackdaniel> flip214: let me repeat: wrap your body in handler-case to be sure, that unwind-protect cleanup is executed in case of errors
<jackdaniel> (body of the thread lambda of course)
<thodg> i hate time
<jdz> UNWIND-PROTECT cleanup should always be executed, regardless of the presence of condition handling.
<flip214> okay, news at 11: the U-P is run.
<jdz> If the control-flow passes it, that is.
<schweers> jackdaniel: unwind-protect needs a handler-case around it?
<phoe> it is run. so the socket should be closed.
<jackdaniel> jdz: that's why we have ups, so unwind-protect will be always executed even on power loss
<jdz> There are quite a few issues being conflated here...
<jackdaniel> schweers: normally no, but if you have debugger disabled, then yes - otherwise such error may basically crash the thread (just as if you had called destroy-thread)
<jackdaniel> jdz: it is in ext package: (ext:ups :on)
<jackdaniel> :-0
<schweers> Oh. What if I only have one thread? Can this still happen? Does the standard say anything about this case?
<jdz> jackdaniel: I thought it's in the I-WANT-A-PONY package...
<jdz> schweers: the spec only assumes one thread.
<schweers> I know, but is is wrapped with a handler-case?
<jackdaniel> schweers: if your application doesn't have a debugger, then I guess it still can happen, yes. but I haven't checked it myself
<phoe> schweers: the spec says nothing about threads.
<flip214> that's interesting...
<flip214> Into HT:PROCESS-CONNECTION's cleanup clause I put a PROGN with a FORMAT.
<flip214> then it works as expected.
<schweers> huh, interesting. So much to learn
<flip214> when I "disable" the FORMAT via #+(or), the wrong behaviour is back - the socket stays open.
m00natic has joined #lisp
<phoe> flip214: are you sure that PROCESS-CONNECTION is not redefined anywhere else in the code?
<flip214> phoe: 99%, yes.
<phoe> I had a similar issue before, and found that I defined a method in two places. The latter redefined the former.
<jdz> 99%?
<flip214> and I just sent it to swank manually.
<phoe> ...
<phoe> when you disable the format, the socket stays open
<flip214> jdz: can you ever by 100% sure? bit flip on the way to the inferior lisp, and you're defining a different method...
<phoe> are you able to verify this on multiple implementations?
<jdz> flip214: Are you sure you're disabling just the FORMAT call?
<flip214> jdz: 100%
<flip214> ;)
<jdz> I've had quite a few non-productive discussions with people who are sure about something without checking their assumptions.
<flip214> jdz: yeah, I fully understand. I make mistakes all the time.
<flip214> (but at a high level! ;)
shka has joined #lisp
<shka> hello
<pjb> I/O has violent consequences on threading.
<shka> i need zip library that uses gray streams
<phoe> pjb: but a single FORMAT call should not be the difference on whether U-P cleanup forms are executed or not
<jdz> flip214: You don't have to put any cleanup forms in a PROGN in UNWIND-PROTECT.
<phoe> "...trivial-gray-streams for gray streams portability..."
<jdz> flip214: So could it be that you have a brainfart in your protected-form?
<thodg> it's real, more than no thread
<shka> phoe: it uses some zip-writer
<shka> and i can write-byte into that :/
<shka> AKA it does not uses gray streams as API
<flip214> how would I disassemble a method? the GF isn't interesting, and trying the method says
<pjb> The questions is whether kill-thread (or pthread_kill) will allow unwind-protect to run?
<phoe> pjb: I think not.
<pjb> calling format may allow another thread to get the CPU and to call pthread_kill.
<flip214> "The value #<standard-method ...> is not of type (or function symbol cons)"
<pjb> yes, methods are not functions.
<phoe> flip214: mop:method-function
<phoe> (disassemble (method-function method))
<jdz> flip214: You should show us the code that works as expected (with the FORMAT call), and the code that fails.
jibanes has joined #lisp
<thodg> its always easier to disassemble a function than a class
Patternmaster has joined #lisp
<thodg> how do they even coexist
<thodg> all this code seems so long
<thodg> i don't have so many fingers
zmt01 has joined #lisp
<flip214> jdz: perhaps I'm completely wrong?! the reproduce pasted above is for sure, please make your own (correct) conclusions.
oldtopman has quit [Ping timeout: 255 seconds]
<jdz> flip214: Am I missing something or there is no UNWIND-PROTECT in the paste you linked?
<thodg> jdz: isn't your expectation formalized the code itself ?
<thodg> all in all the code is the code
zmt00 has quit [Ping timeout: 264 seconds]
<thodg> but compilers always get excited to reject or run it
oldtopman has joined #lisp
<thodg> though at some point all random code would tend to be rejected
<thodg> lisp code throughout the web is very non-random code
<thodg> like a proof of work
<thodg> against a very non-linear standard ontology
<thodg> like an infinite scale of a programmer's might
<jdz> As opposed to some IRC chat which resemble randomly generated ramblings.
<thodg> well around common lisp is not not common lisp
<thodg> is what reality tells
<jdz> There is no reality that tells, there's only perceived reality, and subjects who perceive.
<jdz> And even that is controversial.
gorgor_ has joined #lisp
chocolait_ has joined #lisp
koenig1 has joined #lisp
cess11_ has joined #lisp
shaftoe_ has joined #lisp
khisanth_ has joined #lisp
<thodg> yes but i, wittgenstein and (caaar) have devised a way to not be alone
flip214_ has joined #lisp
flip214_ has joined #lisp
flip214_ has quit [Changing host]
TheReal_aijony has joined #lisp
<thodg> in a verifiable way
<thodg> non ambiguous
<Shinmera> Are you a markov bot in human form or something
burton` has quit [Ping timeout: 264 seconds]
ccl-logbot has quit [Ping timeout: 264 seconds]
koenig has quit [Ping timeout: 264 seconds]
mulk has quit [Ping timeout: 264 seconds]
cyberlard has quit [Ping timeout: 264 seconds]
shaftoe has quit [Ping timeout: 264 seconds]
drot has quit [Ping timeout: 264 seconds]
damke_ has quit [Ping timeout: 264 seconds]
nowolfer has quit [Ping timeout: 264 seconds]
aeth has quit [Ping timeout: 264 seconds]
Khisanth has quit [Ping timeout: 264 seconds]
aijony has quit [Ping timeout: 264 seconds]
cess11 has quit [Ping timeout: 264 seconds]
chocolait has quit [Ping timeout: 264 seconds]
gorgor has quit [Ping timeout: 264 seconds]
aeth has joined #lisp
flip214 has quit [Ping timeout: 264 seconds]
<thodg> haha a fpga repl my friend
aeth has joined #lisp
aeth has quit [Changing host]
nowolfer_ has joined #lisp
TheReal_aijony is now known as aijony
mulk has joined #lisp
damke_ has joined #lisp
<thodg> well interface definitions have that that they let you create virtual implementors and users of an interface
drot has joined #lisp
<thodg> even if implementors and users are other interface definitions
<thodg> its not exclusive with real programmers
cyberlard has joined #lisp
<thodg> in the sense of sunny light and good food waste
<thodg> except maybe
<thodg> i might be high impedance but even lispers need the sun right ?
<jdz> thodg: You're approximately 5 statements away from being kicked.
ccl-logbot has joined #lisp
<_death> C-x b stream-of-consciousness RET
dmiles has quit [Ping timeout: 240 seconds]
Xal has quit [Ping timeout: 240 seconds]
<thodg> jdz: its not because its written #lisp that you have to take us as compilers
<thodg> but enjoy your irc silence power if you please
<flip214_> any LPARALLEL wizards here?
Xal has joined #lisp
attila_lendvai has quit [Ping timeout: 256 seconds]
<flip214_> any OPTIMA maintainers available?
<shka> how can i make bidirectional in-memory stream?
dmiles has joined #lisp
<_death> you can define one using gray streams
sjl has joined #lisp
<shka> _death: define as: "It is already here use this nice lib", or as "you can write it yourself"
<_death> I'm not aware of the former, but it can be achieved by the latter
<shka> thanks
<_death> I suppose you can extend flexi-stream's in-memory-input stream
ccl-logbot has quit [Quit: Client terminated by server]
sjl has quit [Ping timeout: 240 seconds]
<shka> i can, but not now
<shka> i will look at it
schweers has quit [Ping timeout: 255 seconds]
<shka> i think it should be extreamly easy (like inherit just input and output in-memory stream)
orivej has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<_death> they need to use the same storage
<_death> but yes, it should be easy
dmiles has quit [Ping timeout: 264 seconds]
aeth_ has joined #lisp
ccl-logbot has joined #lisp
<shka> for now, i will just use separate input and output streams
<thodg> shka: cffi-unistd:pipe
<shka> thodg: ooh, cool, let me look at it
f32ff_ has joined #lisp
<thodg> shka: only works on unix os though
Amplituhedron has joined #lisp
python476 has joined #lisp
<shka> thodg: i don't care about anything else
terpri has joined #lisp
nika_ has quit [Quit: Leaving...]
hvxgr_ has joined #lisp
<thodg> might be the fastest way
benny- has joined #lisp
nowhere_man has joined #lisp
luis` has joined #lisp
damke has joined #lisp
aeth has quit [Ping timeout: 264 seconds]
benny has quit [Ping timeout: 264 seconds]
ircbrowse has quit [Ping timeout: 264 seconds]
luis has quit [Ping timeout: 264 seconds]
f32ff has quit [Ping timeout: 264 seconds]
hvxgr has quit [Ping timeout: 264 seconds]
micro has quit [Ping timeout: 264 seconds]
hhdave has quit [Ping timeout: 264 seconds]
damke_ has quit [Ping timeout: 264 seconds]
Guest37349 has quit [Ping timeout: 256 seconds]
<shka> thodg: it is pretty cool and useful lib, but i need gray stream api, so i stick to flexi-streams
cpape has joined #lisp
ircbrowse_ has joined #lisp
<shka> thanks for link anyway :-)
micro has joined #lisp
Mandus has quit [Ping timeout: 256 seconds]
attila_lendvai has quit [Ping timeout: 256 seconds]
smasta has joined #lisp
panji has left #lisp [#lisp]
Mandus has joined #lisp
<flip214_> so, issue closed. One PR for OPTIMA, one for QUUX.
<flip214_> not being tired helps a bit, too.
smasta has quit [Ping timeout: 256 seconds]
<flip214_> In case anyone wants to know the details: the "hanging" socket was a _new_ one, as Firefox helpful retries the request when there's no useful answer. but when QUUX handler crashed, it would just be accepted and then linger around.
damke_ has joined #lisp
benny- is now known as benny
damke has quit [Ping timeout: 260 seconds]
jmercouris has joined #lisp
_cosmonaut_ has quit [Ping timeout: 256 seconds]
<phoe> oooh.
<phoe> non-trivial!
<phoe> congrats!
attila_lendvai has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
<Shinmera> Modern browsers like to spam the shit out of servers with requests when one fails.
<Shinmera> It's really quite annoying during development.
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
smokeink has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
damke_ has quit [Ping timeout: 260 seconds]
wigust has joined #lisp
<flip214_> now let's hope that the maintainers merge soon, so that the next QL release already has the fixes, so that I can remove my checkouts
dmiles has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
smurfrobot has quit [Remote host closed the connection]
Achylles has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
epony has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
epony has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
smurfrobot has quit [Ping timeout: 255 seconds]
rumbler3_ has quit [Remote host closed the connection]
smurfrobot has joined #lisp
fikka has joined #lisp
<flip214_> beach: you're listed as maintainer for alexandria... would you like to take a look at https://gitlab.common-lisp.net/alexandria/alexandria/merge_requests? A few doc changes with little risk.
smurfrobot has quit [Ping timeout: 256 seconds]
devlaf has quit [Ping timeout: 240 seconds]
devlaf has joined #lisp
damke has joined #lisp
smurfrobot has joined #lisp
zkat has quit [Ping timeout: 255 seconds]
Kundry_Wag has joined #lisp
zkat has joined #lisp
JenElizabeth has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
papachan has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
scymtym_ has joined #lisp
attila_lendvai has joined #lisp
JenElizabeth has quit [Ping timeout: 256 seconds]
scymtym has quit [Ping timeout: 276 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
schweers has joined #lisp
willmichael has quit [Ping timeout: 268 seconds]
JenElizabeth has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
JenElizabeth has quit [Remote host closed the connection]
JenElizabeth has joined #lisp
smurfrobot has quit [Ping timeout: 255 seconds]
willmichael has joined #lisp
smurfrobot has joined #lisp
thodg has quit [Ping timeout: 248 seconds]
hiroaki has quit [Quit: Leaving]
rumbler31 has joined #lisp
Kevslinger has joined #lisp
nullman has quit [Remote host closed the connection]
nullman has joined #lisp
ssake has quit [Remote host closed the connection]
<MetaYan> beach: I keep getting 'Unknown &KEY argument: :WEAKNESS-MATTERS' when loading clim-listener (SBCL 1.4.4 on OSX); http://termbin.com/lipp (<- it almost got it right... ;)
ssake has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
JenElizabeth has quit [Ping timeout: 256 seconds]
<phoe> MetaYan: this seems like an issue with TRIVIAL-GARBAGE
<phoe> Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {10005505B3}>
<phoe> 0: (MAKE-HASH-TABLE :WEAKNESS :VALUE :WEAKNESS-MATTERS NIL) [more]
<phoe> 1: (TRIVIAL-GARBAGE:MAKE-WEAK-HASH-TABLE :WEAKNESS-MATTERS NIL)
smurfrobot has quit [Remote host closed the connection]
smasta has joined #lisp
<phoe> MetaYan: what is your version of trivial-garbage?
<phoe> if you ran it from quicklisp, go (ql:update-all-dists) and recompile
<phoe> because (trivial-garbage:make-weak-hash-table :weakness :key :weakness-matters :nil) works on my machine
<shka> MetaYan: what cl implementation you are running?
<phoe> shka: SBCL 1.4.4 on OSX, read up
smasta has quit [Ping timeout: 252 seconds]
tankrim has quit [Remote host closed the connection]
tankrim has joined #lisp
<shka> phoe: yeah, right
<AeroNotix> can someone make the argument for anaphoric macros to me? It seems like unnecessary magic to me
<AeroNotix> I get that "omg so rad" but in reality (where most of us should reside) they're annoying and magic
smurfrobot has joined #lisp
<shka> AeroNotix: i share your sentiment
<phoe> AeroNotix: some people like to put (print it) once in a while in their code
comborico has joined #lisp
<AeroNotix> yes literally debugging some elisp shite that uses `it`
<phoe> but I don't use anaphores myself. never found them useful.
<AeroNotix> ok so anaphoric macros BANNED
<AeroNotix> it has been decreed
Kevslinger has quit [Ping timeout: 240 seconds]
<AeroNotix> haha need to go check if I've ever used them in my CL
<shka> nedless to say, anaphoric macros are indeed controversial
<shka> i almost never use those myself
<AeroNotix> dash.el has map--
<AeroNotix> or --map sorry which is literally just an anaphoric version of map
<pjb> There's no need to ban them: it all depends on you DSL!
Kundry_Wag has quit [Remote host closed the connection]
<AeroNotix> pjb: as I requested-- make the case for anaphoric macros! :)
<AeroNotix> e.g. code which is improved with anaphors
<AeroNotix> honestly they seem like one day someone, somewhere realised "huh, that's possible" and here we are
<pjb> AeroNotix: I don't know about code. But if "it" exists in natural languages, it must serve some purpose!
<pjb> I didn't say it depended on you DSC, but on your DSL!
<Xach> paul graham uses them as useful examples of good macros
<AeroNotix> I speak with several people on a daily basis who have different native languages and you wouldn't believe how often anaphora cause issues
<AeroNotix> Xach: paul graham is wrong
<AeroNotix> fight me
<Xach> About something else; on this we agree.
<phoe> Graham is as controversial as anaphoric macros are.
<phoe> If not more.
<pjb> But in a way, references such as "it" will always add some ambiguity, since they're implicit references. Therefore this may be something you want to remove from code. But then, how much implicit referencing do you have in your code really? More than you think in general!
<shka> Xach: thank you for Salza2!
smurfrobot has quit [Ping timeout: 260 seconds]
<AeroNotix> take a look at this
<pjb> The thing with implicit vs explicit, is that implicit is something that is hidden thru abstraction. So the question is whether rendering the reference named by "it" implicit is a good abstraction or not.
<AeroNotix> it's just a useless abstraction
<AeroNotix> (car it)
<AeroNotix> where is it? What is it?
<phoe> (fsck it)
<AeroNotix> lots of editors won't realise that they should jump to the anaphoric macro if you're looking for where `it' is defined.
<pjb> If your scope is small and well delimited (as it generally is with lisp macros), then it could work.
<AeroNotix> it's not even that much more code to make a regular macro
<pjb> (binding-when (it (= a b)) (print it))
<Xach> shka: no problemo. how are you using it?
<pjb> (anaphoric-when (= a b) (print it))
<pjb> Yes, binding-when is probably better.
<AeroNotix> in fact, it's LESS CODE to make it a regular macro
<AeroNotix> that --map function should be named something which describes how to access the element currently being mapped
<AeroNotix> and it just takes that accessor (like car)
<AeroNotix> instead of it taking an expression which operates on `it'
<AeroNotix> argh, whatever.
<pjb> AeroNotix: you can make a good case for binding macros where the user specifies the variable instead of using it.
Kundry_Wag has joined #lisp
l1x has quit [Ping timeout: 255 seconds]
<AeroNotix> pjb: yes, I have no problem with that.
<AeroNotix> I assume you mean things like LET, LET*
<pjb> yes.
<AeroNotix> if the user specifies the variable, the code is fine
<pjb> (binding-when (foo (expression) (print foo))) -> (let ((foo (expression))) (when foo (print foo)))
<AeroNotix> yes, totally makes sense
<pjb> But we are programmers. "Users" may want it.
sveit_ has quit [Ping timeout: 240 seconds]
smurfrobot has joined #lisp
l1x has joined #lisp
<shka> Xach: compressing sparse data, works great! If only, i wish I could have grey stream interface for compressor
sveit has joined #lisp
<shka> i may even think about writing just that
<Xach> shka: that would be cool
<shka> could be small enough and interesting project
attila_lendvai has quit [Read error: Connection reset by peer]
dlowe has quit [Ping timeout: 255 seconds]
dlowe has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
Kevslinger has joined #lisp
<Xach> shka: i think a library might already do that though. maybe a zip library?
Denommus has quit [Quit: ERC Version 5.3 (IRC client for Emacs)]
Meow-J_ has quit [Ping timeout: 255 seconds]
Kundry_Wag has quit [Remote host closed the connection]
mishoo has quit [Ping timeout: 240 seconds]
Meow-J_ has joined #lisp
learning has joined #lisp
<shka> Xach: not sure, It failed once i attempted to write-byte into their stream, not sure if implementation is incomplete, or it is not gray stream
<shka> they have some zip-write functions, so i assume the second option
damke_ has joined #lisp
damke has quit [Ping timeout: 260 seconds]
<_death> you should also know that the gray stream protocol is incomplete (it lacks a stream-file-length function)
Bike has joined #lisp
<shka> oh
<shka> i don't think i will even need this
wxie has joined #lisp
warweasle has joined #lisp
EvW1 has joined #lisp
<shka> Xach: also, i spent quite some time yesterday to figure out why no library offers that
<Xach> shka: compressed stream?
hhdave has joined #lisp
smurfrobot has quit [Remote host closed the connection]
milanj has joined #lisp
<shka> Xach: gray stream, to be precise
<comborico> I'm reading Practical Common Lisp, and there is an oversight that I'd like to get straightened out. What is the apostrophe before the parens called, and what
<comborico> Is it used to denote a list?
<phoe> comborico: oh boy
<Bike> you mean a quotation mark?
<Bike> '(a b c)?
<comborico> I'm not sure. '( )
<phoe> it's called a quote, and it's one of the very basics of Lisp.
<pjb> 'x -> x
<pjb> itself.
<phoe> comborico: do you know what evaluation is?
<comborico> The dude forgot to mention it. So far the book is very good (page/link 2)
<pjb> comborico: you should note that actually, the lisp reader interprets most characters going thru a table, the *readtable* and calling functions named reader macros, that return the "read" sexp.
<phoe> I kinda doubt that gigamonkey would forgot to mention that a quote is.
<comborico> A step in REPL?
<pjb> comborico: in the case of 'x what is actually returned by the reader macro, is (CL:QUOTE x)
<phoe> comborico: yep. But do you know the general rules of evaluation?
<pjb> comborico: and CL:QUOTE is a special opeartor that returns its argument itself.
<comborico> Phoe, check for yourself. '( ) is first used in second link with function REMOVE-IF-NOT.
Xal has quit [Ping timeout: 248 seconds]
<Shinmera> comborico: I'm quite sure he elaborate how it works and what it means. Maybe just be a bit more patient with the book. There's a good reason he does not delve into things that are rather complicated to explain too early.
<pjb> comborico: for example, the reader macro for ( reads a list. If that list is empty as in ( ) or as we usually write: (), then it actually returns the symbol CL:NIL
smurfrobot has joined #lisp
<Bike> that's chapter three. quotation is explained a few paragraphs later, at latest.
<phoe> comborico: which page of http://gigamonkeys.com/book/ ?
<pjb> so '() is actually read as (CL:QUOTE CL:NIL) and this, when evaluated, returns CL:NIL.
<phoe> comborico: in other words: (a b c) most likely means a function call, function A is called with the values of B and C as arguments.
<pjb> this is different of nil, which when read in the CL package, reads directly CL:NIL, and when evaluated, returns its value, which happens to be CL:NIL itself, so that's also what's returned, but there's it's a more complex evaluation process, since we go look for the value of a variable here.
<phoe> where '(a b c) means data, a list of three elements.
fisxoj has joined #lisp
<comborico> Phoe, practical simple database
<pjb> (eval '(a b c)) means that (a b c) will be interpreted by the evaluator as an operator application.
<phoe> comborico: yes, I see it.
<pjb> a should be the name of a function, a macro, or a special operator.
Xal has joined #lisp
<schweers> I’m skimming said chapter, I think he really didn’t mention what quoting entails.
<schweers> comborico: Don’t worry, it is all explained in later chapters.
<comborico> Shinmera, I'm one of those types that has a burning desire to understand each character in the code. And because technical writings are notorious for oversights and typos, I thought it best to understand quote before progressing.
<phoe> comborico: PCL isn't really a book like that.
<comborico> Yeah, so far I'm impressed.
<phoe> it's basically two books intertwined with each other.
<phoe> "practical" chapters are code first. you first write code, then are expected to understand it.
smurfrobot has quit [Ping timeout: 240 seconds]
<phoe> the other chapters actually explain what's going on.
<phoe> so if you don't know what a thing is, relax and just roll with it. it'll be explained later.
<Xach> there are other books with other styles, too
<comborico> Alright.
<Shinmera> It's also heavily advisable to try things out at the REPL vigorously
<Shinmera> Play around with the snippets the book gives you
<comborico> Xach, yup, thanks! I found three others, i believe.
<pjb> But don't take it for godspel, the CLHS is the reference (apart from where it has bugs, such as prog2).
<phoe> also what Xach said; I myself started with the book ANSI Common Lisp by Paul Graham, and I consider it decent for learning the basics of Lisp.
__rumbler31 has joined #lisp
<Shinmera> In other news, ELS registration is now done! It's not online yet, but hopefully (up to Didier) within a few days.
<phoe> It also has a more theoretical approach up front, and doesn't throw you straight into application writing like PCL does.
<phoe> Shinmera: yay!
<comborico> Phoe, ah excellent! I definitely appreciate book recommendations.
<phoe> It also has Paul Graham who has a few pretty damn controversial views on Lisp's various parts
<phoe> but then again, you'll figure it out after just using enough Lisp and asking enough questions afterwards.
<comborico> You guys ever read a book by Deitel?
<phoe> comborico: like which one?
<Shinmera> And: it's not too late yet to give me harsh, soul-crushing feedback about my paper submission. https://github.com/Shinmera/talks/blob/master/els2018-glsl-oop/paper.pdf
<pjb> comborico: anything about Common Lisp? I guess not.
<comborico> Phoe, any of them.
<comborico> Pjb, sadly, no.
learning has quit [Remote host closed the connection]
<tfb> pjb: what's the CLHS prog2 bug (not a rhetorical question!)
<pjb> clhs prog2
<tfb> oh, doh
<tfb> someone coppied and pasted prog1
smurfrobot has joined #lisp
<tfb> thx
<phoe> yes
<phoe> I think it's the most famous CLHS oops
<comborico> Shinmera, are you talking to me?
fisxoj has quit [Quit: fisxoj]
<comborico> About female
learning has joined #lisp
<Shinmera> What?
<comborico> Lol about feedback (using phone)
<Shinmera> I'm talking to everyone in the channel
<comborico> Gotcha. The "and" part threw me off, which isn't difficult to do in my learning condition
<Shinmera> Ah, I was and-ing my previous post, which was also about ELS.
FreeBirdLjj has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
<comborico> Ah, i see. Yup, i missed that.
willmichael has quit [Ping timeout: 260 seconds]
mishoo has joined #lisp
Arcaelyx has joined #lisp
willmichael has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
FreeBirdLjj has quit [Ping timeout: 255 seconds]
EvW1 has quit [Ping timeout: 276 seconds]
<comborico> Phoe, was that a "yes, I've read a book from Deitel"?
<phoe> comborico: no, it was a "yes, someone copypasted prog1"
<phoe> I haven't read a Deitel book
<_death> phoe: no loss there
<comborico> How dare you! (Joking)
<schweers> comborico: why do you ask?
Kundry_Wag has joined #lisp
<comborico> They have a reputation for being slow-moving and redundant, but I've found that style is the best for me.
<comborico> schweers, in book recommendations, if the recommender was aware of my preference, it would greatly aid in a proper recommendation.
Kundry_Wag has quit [Remote host closed the connection]
epony has quit [Remote host closed the connection]
<schweers> I see; I don’t have any recommendations for you, apart from PCL, but I can tell you that you might have a hard time with grahams books. On the other hand, at least On Lisp is not directed at the newcomer anyway.
smokeink has quit [Ping timeout: 256 seconds]
<comborico> Thanks for acknowledging what i said was true, by the way. (No mention of quote upon its first use)
* schweers never had the pleasure of reading Grahams ANSI Common Lisp though
Kundry_Wag has joined #lisp
<pjb> comborico: perhaps you'll like: Common Lisp: A Gentle Introduction to Symbolic Computation http://www.cs.cmu.edu/~dst/LispBook/ http://www-cgi.cs.cmu.edu/afs/cs.cmu.edu/user/dst/www/LispBook/index.html
<comborico> "On Lisp" you like this one?
<phoe> "On Lisp" is Graham's
<phoe> and it's more advanced.
raynold has quit [Quit: Connection closed for inactivity]
<schweers> No, he has a book called “On Lisp“”
<schweers>
<comborico> Pjb, thank you! I'll add it to the list!
Kundry_Wag has quit [Remote host closed the connection]
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
mareskeg has joined #lisp
fikka has joined #lisp
<comborico> The cover of that 1990 book is so Orwellian
xristos has joined #lisp
scymtym__ has joined #lisp
stacksmith has joined #lisp
scymtym_ has quit [Ping timeout: 255 seconds]
epony has joined #lisp
oldtopman has quit [Ping timeout: 276 seconds]
tankrim has quit [Remote host closed the connection]
tankrim has joined #lisp
<schweers> comborico: sorry, I just realized I misunderstood your question about “On Lisp”. Yes, I kind of like it, but it covers fairly advanced and is kinda weird.
damke has joined #lisp
SamSkulls has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
juan-reynoso has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
damke_ has quit [Ping timeout: 260 seconds]
<comborico> Schweers, i see.
smurfrobot has joined #lisp
<MetaYan> phoe: trivial-garbage / trivial-garbage-20150113-git / quicklisp 2018-01-31 (was away from keyboard)
<phoe> MetaYan: huh
<phoe> really weird
<MetaYan> phoe: Sorry - got to run again - can check more later
<phoe> I have the same version and the :WEAKNESS-SOMETHING keyword is *not* passed to the CL:MAKE-HASH-TABLE.
stacksmith has quit [Ping timeout: 256 seconds]
<comborico> Out of curiosity, for explicit calling of functions #'( ), I wonder why #( ) is not sufficient. In other words, I'm wondering why that quote is necessary.
attila_lendvai has quit [Read error: Connection reset by peer]
<phoe> comborico: #() is array notation
<phoe> or, to be precise
<comborico> Very good. Thank you n
<phoe> #' is the reader macro for functions
<phoe> #( is the reader macro for arrays
dieggsy has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
<phoe> comborico: also, #clnoobs might interest you
<phoe> it's a channel specialized for learning Lisp.
<comborico> Ah, thanks!
<phoe> #lisp is good for these questions as well, but it might be better to ask there if #lisp has traffic at the moment. and such times happen.
mareskeg has quit [Ping timeout: 240 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
<comborico> I see. Thank you for the friendly clarification.
<phoe> comborico: no problem, good luck and high five
<comborico> Remember the days when noobie was spelled newbie?
<comborico> Haha
<phoe> comborico: hah, yes. the name of that channel isn't too pleasant perhaps.
<comborico> It's fine.
attila_lendvai has joined #lisp
oldtopman has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
cpape has quit [Ping timeout: 265 seconds]
csaurus has joined #lisp
mareskeg has joined #lisp
Kundry_Wag has joined #lisp
JenElizabeth has joined #lisp
mareskeg has quit [Client Quit]
haruka1 has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Ping timeout: 256 seconds]
haruka has joined #lisp
milanj has joined #lisp
makomo_ has joined #lisp
Arcaelyx has joined #lisp
makomo has quit [Ping timeout: 240 seconds]
makomo_ has quit [Ping timeout: 264 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 255 seconds]
Murii has quit [Ping timeout: 255 seconds]
willmichael has quit [Ping timeout: 240 seconds]
dddddd has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
fikka has joined #lisp
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
rjeli_ has quit [Quit: ZNC 1.6.3 - http://znc.in]
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
rjeli has joined #lisp
mlf has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
makomo_ has joined #lisp
koenig1 is now known as koenig
klltkr has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Client Quit]
mareskeg has joined #lisp
shoogz has joined #lisp
smurfrobot has joined #lisp
voidlily_ has quit [Ping timeout: 252 seconds]
wigust has quit [Ping timeout: 255 seconds]
voidlily_ has joined #lisp
mareskeg has quit [Client Quit]
<tazjin> are different quicklisp libraries allowed to have overlapping package names, as long as the system names are unique?
<fe[nl]ix> no
<tazjin> thought so, thanks
smurfrobot has quit [Ping timeout: 256 seconds]
al-damiri has joined #lisp
mareskeg has joined #lisp
stacksmith has joined #lisp
<Shinmera> In effect they do though.
<Shinmera> At least some systems out there today have conflicting names.
klltkr has quit [Ping timeout: 248 seconds]
flamebeard has quit [Quit: Leaving]
thodg has joined #lisp
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
smurfrobot has joined #lisp
mareskeg has quit [Quit: mareskeg]
smasta has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
<Shinmera> conflicting package names I mean
smurfrobot has quit [Ping timeout: 264 seconds]
thodg has quit [Ping timeout: 260 seconds]
cpape has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
haruka has quit [Ping timeout: 264 seconds]
haruka1 has joined #lisp
ski has quit [Quit: Lost terminal]
varjag has joined #lisp
fikka has joined #lisp
damke_ has joined #lisp
Murii has joined #lisp
schweers has quit [Ping timeout: 255 seconds]
Cymew has quit [Remote host closed the connection]
Cymew has joined #lisp
damke has quit [Ping timeout: 264 seconds]
nowhereman has joined #lisp
nowhereman is now known as Guest53399
parjanya has joined #lisp
parjanya is now known as esb`
JenElizabeth has quit [Read error: Connection reset by peer]
nowhere_man has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 264 seconds]
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 255 seconds]
fikka has quit [Ping timeout: 265 seconds]
Karl_Dscc has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
smurfrobot has joined #lisp
aeth_ is now known as aeth
smurfrobot has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
Amplituhedron has quit [Ping timeout: 260 seconds]
<fe[nl]ix> tazjin: actually I misread that. it can happen and there are actually a few systems that offer simple compatibility for other libraries
Kaisyu has quit [Quit: Connection closed for inactivity]
dieggsy has quit [Ping timeout: 276 seconds]
raynold has joined #lisp
jmercouris has quit [Ping timeout: 260 seconds]
hhdave has quit [Ping timeout: 268 seconds]
side_track has quit [Quit: Leaving]
m00natic has quit [Remote host closed the connection]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
learning has quit [Remote host closed the connection]
mareskeg has joined #lisp
smurfrobot has joined #lisp
vxqw has joined #lisp
mareskeg has quit [Client Quit]
thodg has joined #lisp
mareskeg has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
mareskeg has quit [Client Quit]
learning has joined #lisp
mason has quit [Remote host closed the connection]
CrazyMonkey201 has joined #lisp
raynold has quit [Remote host closed the connection]
raynold has joined #lisp
LiamH has joined #lisp
python476 has quit [Ping timeout: 268 seconds]
tankrim has quit [Remote host closed the connection]
mason has joined #lisp
tankrim has joined #lisp
python476 has joined #lisp
drewc has quit [Ping timeout: 240 seconds]
drewc has joined #lisp
warweasle has joined #lisp
inaimathi has joined #lisp
<inaimathi> Hello; I wrote a thing to give me some cross-implementation generic-function introspection https://github.com/inaimathi/cl-mop/pull/1/files
<inaimathi> Can anyone give me a quick head check on it?
<inaimathi> (Also, I've only got access to clisp, sbcl and ccl locally, so I'm hoping a Lispworks/Allegro/CMUCL user can give me a rundown on how to extend this for those lisps)
<Bike> are you aware of closer mop?
<Bike> i don't know why you'd want these functions that operate on both methods and generic functions
<Bike> since specializer-object only works on eql specializers, specializer-objects-of is not going to work on anything with any methods that have any specializers other than eql ones
zooey has quit [Ping timeout: 255 seconds]
juan-reynoso has quit [Ping timeout: 240 seconds]
<inaimathi> It looks like `closer-mop` does the cross-platform imports I'm looking for here. Thanks!
juan-reynoso has joined #lisp
zooey has joined #lisp
<inaimathi> (`specializer-object` works on anything; it returns the object of eql-specializers and the identity of other specializers (which should be a class reference))
zooey has quit [Remote host closed the connection]
<Bike> oh, i misread
<Bike> the name is wrong then
<makomo_> are there any other languages that have 2-argument versions of rounding functions such as FLOOR, CEILING, ROUND, etc.?
whatsupdoc has joined #lisp
<makomo_> it's a pretty neat feature
zooey has joined #lisp
<makomo_> excel also has a 2-argument version of CEILING for example, but the second argument is the "singificance" rather than the divisor
<makomo_> significance*
<whatsupdoc> Is there a lisp help channel?
<whatsupdoc> For beginners?
<Bike> #clnoobs i think
<whatsupdoc> thanks
fikka has quit [Ping timeout: 256 seconds]
whatsupdoc has left #lisp ["Closing Window"]
arbv has quit [Ping timeout: 256 seconds]
jmercouris has joined #lisp
damke has joined #lisp
arbv has joined #lisp
jmercouris has quit [Remote host closed the connection]
damke_ has quit [Ping timeout: 264 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
fikka has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
flip214_ is now known as flip214
<sigjuice> fe[nl]ix just curious, what is the reason iolib has its own grovel code?
inaimathi has left #lisp ["Killed buffer"]
attila_lendvai has joined #lisp
<aeth> Other languages probably optimise floor(x/y) to do the same thing as (floor x y) in CL (assuming that / is defined similarly to CL's)... but most (all?) CLs don't optimize (floor (/ x y)) because (floor x y) exists.
attila_lendvai has quit [Read error: Connection reset by peer]
<aeth> what's great, though, is that (1) it's explicit and (2) you have plenty of options (floor, ffloor, ceiling, fceiling, truncate, ftruncate, round, fround)
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
Jesin has joined #lisp
<pjb> And that they return 2 values, so you don't need to call two functions to get the quotient and the remainder.
attila_lendvai has quit [Read error: Connection reset by peer]
Cymew has joined #lisp
<aeth> But if you do want just the latter, you have both mod and rem available, which is rare. Check out the table to see comparable languages: https://en.wikipedia.org/wiki/Modulo_operation#Remainder_calculation_for_the_modulo_operation
willmichael has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<aeth> of the notable languages, basically just CL, Scheme, Fortran, and Ada
<pjb> Yep, the only languages worth using.
jmercouris has joined #lisp
<jmercouris> rme: seems like the logging is working again, did you fix it?
smasta has quit [Ping timeout: 248 seconds]
Cymew has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 255 seconds]
Cymew has joined #lisp
fikka has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
knicklux has joined #lisp
shrdlu68 has quit [Ping timeout: 256 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
Cymew has joined #lisp
attila_lendvai has joined #lisp
shrdlu68 has joined #lisp
Sauvin has quit [Ping timeout: 255 seconds]
fikka has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
Cymew has quit [Ping timeout: 248 seconds]
Cymew has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
zaquest has quit [Quit: Leaving]
smasta has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
Cymew has quit [Ping timeout: 248 seconds]
voidlily_ has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
vultyre has joined #lisp
Jesin has quit [Quit: Leaving]
Cymew has joined #lisp
wxie has quit [Ping timeout: 255 seconds]
stacksmith has quit [Ping timeout: 268 seconds]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
Jesin has joined #lisp
Cymew has quit [Ping timeout: 264 seconds]
vultyre has quit [Quit: Leaving]
fikka has quit [Ping timeout: 264 seconds]
Achylles has quit [Ping timeout: 256 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
vibs29 has quit [Ping timeout: 260 seconds]
voidlily_ has joined #lisp
glv has joined #lisp
vibs29 has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
fikka has joined #lisp
attila_lendvai has joined #lisp
smurfrobot has joined #lisp
smasta has quit [Ping timeout: 240 seconds]
smasta has joined #lisp
Lycurgus has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
marusich has quit [Ping timeout: 240 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
mareskeg has joined #lisp
marusich has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
marusich has quit [Ping timeout: 248 seconds]
marusich has joined #lisp
glv has quit [Quit: Leaving]
<jasom> bah, the first two xml libraries I tried for parsing xml had the same bug
attila_lendvai has quit [Read error: Connection reset by peer]
smasta has quit [Ping timeout: 255 seconds]
<flip214> jasom: did you report it?
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
fikka has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
<jasom> I'm going to
<jasom> writing up a test-case now
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<jasom> ooh, this is interesting, cxml with klacks does it wrong, but cxml with sax does it right...
troydm has quit [Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset]
esb` has quit [Ping timeout: 256 seconds]
troydm has joined #lisp
vxqw has quit [Quit: leaving]
attila_lendvai has quit [Read error: Connection reset by peer]
angavrilov has quit [Remote host closed the connection]
sysfault has joined #lisp
sz0 has joined #lisp
milanj has joined #lisp
lnostdal has joined #lisp
sysfault has quit [Quit: Leaving]
sysfault has joined #lisp
EvW has joined #lisp
Jesin has quit [Quit: Leaving]
sysfault has quit [Client Quit]
Jesin has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
lnostdal has quit [Ping timeout: 255 seconds]
sysfault has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has quit [Read error: Connection reset by peer]
mareskeg has quit [Quit: mareskeg]
lnostdal has joined #lisp
scymtym__ has quit [Ping timeout: 265 seconds]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
haruka1 has quit [Ping timeout: 255 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
<Bike> Is an implementation allowed to define documentation for things automatically if the user doesn't?
<Bike> like for example, (defun foo (a b) ...), and then (documentation 'foo 'function) => "Function FOO (a b)" or something.
haruka has joined #lisp
smasta has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
Karl_Dscc has joined #lisp
<phoe> Bike: the standard does not specify this.
lnostdal has quit [Ping timeout: 255 seconds]
fikka has quit [Ping timeout: 248 seconds]
<phoe> An implementation may drop docstrings at any time... but the spec is silent about the implementation *supplying* them at any time.
SamSkulls has joined #lisp
<pjb> it may supply them thru the documentation accessor. See also description
<phoe> I believe that your implementation may call #'(SETF DOCUMENTATION) as a part of its DEFUN, DEFVAR, DEFGENERIC, ... with default values if no user-provided value is specified.
combo1611 has joined #lisp
<pjb> Bike: notice that documentation is an accessor.
<phoe> oh wait.
<phoe> it doesn't need to set anything.
<phoe> the accessor itself might decide to resort to some kind of default value when there is no user-specified documentation set.
<jasom> aha, I found the bug in klacks. Bindings get pushed on to a stack, but never popped.
<jasom> one line fix
smasta has quit [Ping timeout: 248 seconds]
<jasom> Xach: here's a pie-in-the-sky feature request: a single command to generate a diff from what is currently in the directory for a project from what QL would put there if downloading it fresh
<jasom> so when I do M-., fix bug, test I can generate a patch automagically
fikka has joined #lisp
<pjb> For used defined objects, I feel that if the user didn't specify a documentation then documentation should return nil.
shrdlu68 has quit [Ping timeout: 260 seconds]
shrdlu68 has joined #lisp
damke_ has joined #lisp
<jasom> Bike: usually implementations show what you suggest with DESCRIBE not with DOCUMENTATION
<Bike> that's why i'm wondering, as it happens
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<Bike> whether i can avoid having another slot in the environment by putting it in the docstring instead
<pjb> You would have to compute it anyways? Why not compute it from describe?
Achylles has joined #lisp
damke has quit [Ping timeout: 264 seconds]
<Bike> Compute it based on what information, though.
<jasom> function-lambda-expression ?
<Bike> that means storing the lambda list in the function object. which is fine.
<Bike> but there's also deftype and defstruct and such.
lnostdal has joined #lisp
attila_lendvai has quit [Ping timeout: 255 seconds]
<jasom> well you'll need to know the names of function slots and such for debugging, right?
pagnol has joined #lisp
<Bike> What?
<pagnol> larsen, hi there!
bjorkintosh has joined #lisp
<Shinmera> jmercouris: There's always http://irclog.tymoon.eu for logs too
<Shinmera> jasom: Does plump get it wrong?
smasta has joined #lisp
smurfrobot has joined #lisp
CrazyMonkey201 has quit [Quit: Leaving.]
orivej has joined #lisp
stacksmith has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
mishoo has quit [Ping timeout: 240 seconds]
smurfrobot has quit [Ping timeout: 268 seconds]
JenElizabeth has joined #lisp
quazimodo has quit [Ping timeout: 256 seconds]
smurfrobot has joined #lisp
jmercouris has quit [Ping timeout: 264 seconds]
vlatkoB has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
<combo1611> Having troubles installing Alegro CL on Ubuntu. bunzip2 is loaded and is extracting, but even with sudo, I am getting mkdir permission denied error.
<fe[nl]ix> sigjuice: I was experimenting with outputting C++ files instead of C
<fe[nl]ix> I should merge that into CFFI
<phoe> combo1611: you should ask on the Franz support forums. #lisp@freenode is mostly about FOSS Lisp implementations.
<phoe> Franz websites should be able to help you better - there'll be more ACL users there.
rippa has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
borei has quit [Quit: Leaving.]
<combo1611> Oh, I'm not sure I even want Alegro, then. I'll search this FOSS term, thank you.
<phoe> combo1611: go grab yourself a SBCL.
<combo1611> ha
<phoe> FOSS means "free and open source software".
<combo1611> sbcl?
<phoe> Steel Bank Common Lisp, a Common Lisp implementation that is open source and put in the public domain.
<phoe> Used pretty often around here.
<combo1611> Oh, I thought it was a joke. Heh.
<combo1611> Alright, thanks!
<phoe> Nope. (:
<aeth> I would recommend trying SBCL, CCL, and ECL in that order, which is also the order of popularity on Quicklisp when you skip CLISP (no stable release in nearly 8 years!), ABCL (the JVM is in its own world), and the commercial implementations (LispWorks and Allegro). http://blog.quicklisp.org/2018/02/quicklisp-implementation-stats-for-2017.html
EvW has quit [Ping timeout: 255 seconds]
jmercouris has joined #lisp
<jmercouris> Shinmera: so many tymoon services of your own, do you enjoy making them?
<Shinmera> Sometimes.
<Shinmera> Mostly I do things because I don't like what's out there.
<jmercouris> did you write the IRC logger?
<Shinmera> Not just for my webservices, just in general
<Shinmera> Yes
<jmercouris> I see, so that's probably why you like Lisp
<jmercouris> or at least a part of it
<Shinmera> :shrug:
<jmercouris> what do you use for provisioning your VMs?
<jmercouris> do you set them up manually?
<Shinmera> Which VMs?
<jmercouris> are your servers bare metal?
<jmercouris> I assumed you were running some VPS type deal for *.tymoon.eu
<combo1611> aeth: Thanks!
<Shinmera> I own a root server, which is set up with several lxc containers. But this is getting offtopic.
EvW has joined #lisp
scymtym has joined #lisp
<combo1611> If I'm running Kubuntu, do I download Linux or Debian GNU architecture for SBCL?
<combo1611> Nermind, I think that is a silly question. I guess I'm just thrown off by the newest version not available for Debian.
<Bike> do you mean "Debian GNU/kFreeBSD"
<combo1611> It included that yes.
<jmercouris> combo1611: apt-get install sbcl
<Bike> because the FreeBSD part indicates a different kernel and shouldn't be elided
<phoe> combo1611: depends on which debian you use
<phoe> if you want to go for sid, it should already have a decently new SBCL.
<phoe> at least 1.4.3 from what I last checked.
knicklux has quit [Remote host closed the connection]
fikka has joined #lisp
igemnace has joined #lisp
smasta has quit [Ping timeout: 260 seconds]
<combo1611> What is the name of the shell to put in Bash?
whoman has joined #lisp
<aeth> in 1.4.3: "bug fix: fixed heap exhaustion bug when consing millions of small objects" <- I think I might have encountered this before
<jmercouris> combo1611: what? what is the question?
<phoe> combo1611: what do you mean, name of the shell to put in bash?
<combo1611> What do I type into bash to get the REPL?
<phoe> `sbcl`
<phoe> without the `s
attila_lendvai has quit [Ping timeout: 264 seconds]
<combo1611> heh, thanks!
<phoe> but don't really depend on the bash REPL.
whoman has quit [Client Quit]
<combo1611> Yay!
<phoe> go for an emacs+slime+quicklisp setup.
<combo1611> Roger that!
<phoe> it'll be *much* *much* *much* nicer to use.
whoman has joined #lisp
<phoe> if you're up for a ride, install spacemacs with a common-lisp layer.
<phoe> it's an emacs distribution that integrates a lot of things.
<combo1611> So I've read. I love me my Emacs. What a wonderful program.
<combo1611> Alright. Thank you.
<phoe> Oh.
<phoe> If you're already an emacs user, then you might prefer to set up your own environment from bits and pieces.
<combo1611> I don't know it well enough to have customized much.
csaurus has quit [Ping timeout: 256 seconds]
<phoe> then backup your ~/.emacs.d and try spacemacs.
<combo1611> spacemacs is for VIM users, eh?
<whoman> isnt spacemacs like vim ?
<phoe> not really
<phoe> it started as a distribution for VIMers who were trying to get over to emacs
<combo1611> Heh. I'll watch this video about it later.
<whoman> where's the one for emacs users that's more like emacs
dieggsy has joined #lisp
<phoe> but I have 0% vim background and I learned to use and like it.
<phoe> ...well, okay, 1%, I know :wq
<whoman> that could be said for learning VIM itself, phoe .
<combo1611> I want to get to this REPL, go back in the book, and redo all I've read.
<whoman> install slime, paredit, good to go
<phoe> combo1611: you have one more option, Portacle.
<phoe> which is Lisp-in-a-box.
shifty has joined #lisp
<phoe> download, run, you have a preconfigured Emacs+Slime+SBCL+Quicklisp+Git.
<jmercouris> phoe: I think something like portacle is much more suited
<jmercouris> or even that may be too much, maybe a lispworks trial ide
<phoe> I don't do lispworks. :P
<combo1611> Mmm, I'll probably stick with the method in Practical CL -- besides the Allegro part.
<jmercouris> There's no requirement to use allegro from PCL
<combo1611> It's not required. He just used it.
<combo1611> phoe: I see. That does sound like a nice download to have all that. Very helpful.
<Shinmera> if I remember correctly PCL wants you to use lispbox, which is outdated and has been superseded by Portacle
<jmercouris> you are remembering correctly
<whoman> what about Lisptick ?
<phoe> yes, lispbox is ancient. so is lispstick.
<combo1611> Shinmera: He described it as "lisp in a box", I believe.
<whoman> such a good name. needs resurrecting
<Shinmera> whoman: lispstick is also superseded by Portacle
<whoman> yeh i've already replied with that knowledge
<jmercouris> whoman: I just looked through the logs, I don't see that anywhere
<whoman> resurrecting the name lisptick , right after phoe said its ancient
<whoman> hm.
shifty has quit [Ping timeout: 248 seconds]
attila_lendvai has joined #lisp
Murii has quit [Ping timeout: 240 seconds]
Amplituhedron has joined #lisp
<combo1611> Dang! What a slick install Portacle was. SBCL was also very easy. Bravo CL community.
<combo1611> Sadly, I must now go do some errands. Thanks for all the help, #cl.
<phoe> Portacle doesn't need an external SBCL
<whoman> hehe. i've been trying to install ghc/haskell since last night
<phoe> it bundles its own one
<combo1611> err.. you know #lisp
<whoman> i think he meant the one that comes inside it.
<Shinmera> combo1611: Glad to hear! :)
<combo1611> Installs have always been tough for me. I'm starting to get the hang of tarballs.
* Shinmera likes hearing bravos
<combo1611> Bye!
<combo1611> Heh
combo1611 has quit [Quit: Konversation terminated!]
<whoman> tarballs are the easiest since two decades yet =)
<whoman> all these installers and managers and builders agh
<jmercouris> yeah, just use the very obvious flags -zxvf
<whoman> yes
<jmercouris> I can't imagine what it is like getting into Linux as a new user
<jmercouris> must be a nightmare
<whoman> and some autogen if its real involved, which is super trivial
<jmercouris> "trivial" and "always" works
<whoman> hehe. but a good nightmare for tinkering hobbyist nerds
Achylles has quit [Ping timeout: 256 seconds]
<whoman> sometimes it feels that the software we made to help us version stuff is when versioning became a problem
__rumbler31 has quit [Ping timeout: 260 seconds]
Bike has quit [Ping timeout: 260 seconds]
sz0 has quit [Quit: Connection closed for inactivity]
lnostdal has quit [Ping timeout: 255 seconds]
lnostdal has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
Lycurgus has quit [Quit: Ex Chat]
shoogz has quit [Quit: shoogz out]
Achylles has joined #lisp
comborico has quit [Ping timeout: 255 seconds]
jstypo has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
quazimodo has joined #lisp
attila_lendvai has quit [Ping timeout: 248 seconds]
arrsim has quit [Ping timeout: 252 seconds]
arrsim has joined #lisp
<learning> do you guys have any js irc channels, forums, or communites you'd recommend?
<jmercouris> learning: I imagine most JS stuff is done in slack or discord
<Shinmera> I recommend not doing JS if possible, so the answer is none :^)
<Shinmera> (Besides being off-topic)
<learning> dont we all have to use js lol
<learning> that's interesting
<dTal> the JS people probably talk on some flashy web-based thing that uses 80% of your CPU and will be broken in 6 months
<learning> damn kids and their discord
<jmercouris> no, we can use parenscript :D
<learning> XD
motersen has joined #lisp
tankrim has quit [Remote host closed the connection]
<Shinmera> parenscript is just JS in disguse. Don't fall for its trickery!
<jmercouris> yeah it is...
<dTal> the idea that javascript, an admittedly impressive 3-week hack from someone who was told "Java" and wanted "Scheme", could actually be a serious programming language decades later, is a sign of computing culture's completely bankrupt engineering philosophy
<phoe> #lispcafe
<jmercouris> I think we should encourage off topic conversation, it's part of keeping the community healthy and alive
<Shinmera> This channel is more than alive enough without o/t
<phoe> we encourage it
<phoe> that's why #lispcafe exists
<jmercouris> Yeah, nobody is on that channel, no need to fragment things
<dTal> remember when we all collectively regarded javascript accurately? When we are all like "oh, that warty language that runs in web browsers"? Remember that?
<jmercouris> if someone wishes to find a snippet of information, they can easily search
<phoe> jmercouris: if someone wants to listen to offtopic, they join #lispcafe.
<phoe> if they don't, then they don't.
<Shinmera> dTal: And then you remember CSS was going to be Lisp at some point too.
<jmercouris> Ah yes, the day that never came
smasta has joined #lisp
<learning> dTal it's more that it's just that programming is really new
<jmercouris> programming is over 50 years old
<pjb> Yeah, a tad over 50 years old…
<dTal> and it used to be better!
<learning> that's really really new compared to math
* dTal waves a stick
Naergon has quit [Remote host closed the connection]
<jmercouris> also programming the way we know it, interactively, is I guess much newer- to be fair
<learning> plus you got 75% of people who will say two lines are the same length if everyone else does first. and those 75% of people will defend bad design.
Bike has joined #lisp
<dTal> Or rather, history is filled with languages that, while not perfect, were clearly on the right track, and were then completely abandoned
<learning> the interface to programming makes no god damned sense
oleo has quit [Quit: Leaving]
<learning> no user would ever put up with that interface
<pjb> jmercouris: officially, it's Ada Lovelace who was the first programmer (1842/43).
<jmercouris> learning: what? how so?
<jmercouris> pjb: "officially", there is no authority
<dTal> learning: the dichotomy between "user" and "programmer" is itself the enemy
<learning> if you released a program that had a UI as bad as programming no one would use your program
<learning> yeah, just type the command to go to that link
<pjb> jmercouris: sure, theres even a day of the year for her: https://www.daysoftheyear.com/days/ada-lovelace-day/
<learning> oh yeah, you didn't spell it right
<learning> try it again
Naergon has joined #lisp
<dTal> learning: that, and a great many other programming annoyances, are solved problems
<dTal> the solutions to which are ignored
<learning> have you seen inventing on principle?
<whoman> parenscript !
<learning> completely agreed, but i think its just because programming is new
<whoman> needs elisp port.
<dTal> the trouble is that the computing world does not regard ergonomics a top priority, and programming barely regards it at all
<learning> this guy gets it: https://vimeo.com/36579366
<whoman> we come from hobbyist nerd shops, its a boys club, its not meant to be pretty
<dTal> hell, Python invented the revolutionary idea that maybe a language shouldn't totally suck to use, and look at it now even though it's slow and warty and unprincipled
<learning> nerds make all of the coolest shit.
jdz has quit [Ping timeout: 256 seconds]
<learning> i dont buy into that
Tobbi has quit [Read error: Connection reset by peer]
<whoman> dTal: um BASIC
<learning> python is really interesting
<whoman> learning: wait what ? lol.
<dTal> whoman: is the predecessor, yes, and was also incredibly popular
<learning> you're never going to beat the familiarity of x = 5
Tobbi has joined #lisp
<learning> anyone can look at that and know what it means
<whoman> what about 5 = x
<dTal> I loved BASIC when I was starting out, though I find it hilariously limiting now
<pjb> dTal: Python sucks big time.
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<learning> you can do it lisp, but we dont. for good reasons, but you can't discount the value of familarity and simplicity in python
<dTal> now Python pisses me off tremendously but it's almost always the path of least resistance
<pjb> Indeed, you'd go at least as far as Basic to find a language that sucks as much as Python.
<whoman> about "nerds make the coolest shit" - no one is selling that. just saying that if you want ergo, pay money
<whoman> hobbyist == free time. nerd shops == interest groups.
<pjb> Granted, there was worse, like perl.
<learning> those are the same people who made all the video games dude
<whoman> yes exactly.
<dTal> Python sucks and does not suck. You have to admit it does something right, or it would not be so popular.
<dTal> (Hint: it's the same thing Lisp gets wrong_
<pjb> But it wasn't worth the pain to make a new language and a whole new ecosystem to such that much really! What a shame. Even Ruby which sucks a lot, sucks way less than Python!
oleo has joined #lisp
<whoman> video games arent exactly "the coolest shiz" after reaching a certain level of maturity
<learning> well i think part of being a lisper is looking at other languages for inspriation because you know you can do it in yours
<pjb> dTal: McDonalds and shit is popular too.
<pjb> 500 billion flies can't be wrong!
<whoman> =P
<dTal> that's undisguised elitism
<learning> i haven't used ruby since i learned lisp
<learning> i bet it would be a breath of fresh air compared to js and python
<pjb> the social problem of lisp is that way => (google it!)
<_death> oh, you learned lisp?
smurfrobot has joined #lisp
<whoman> in bible times babylon worshipped 'baal' aka "the lord of the flies" because their "sacrifices" (garbage) would be accepted based on flies/maggots/etc
<learning> learning lol
<whoman> heh
<whoman> observing the last couple of months, i think lisp promotes being social, at least online. i dont think that is a "problem
<pjb> Those languages, ruby, python, clojures, etc, are just me-too languages that have had success.
<whoman> " whereas JS or python devs kind of are in healthy competition
<pjb> Thanks to the Internet. Without Internet, they would have remained me-too languages.
<learning> me-too languages lol
<whoman> the more "ego-centric" or "ego-filled" languages are easier for the flies to be attracted to and identify with.
<whoman> if your whole town is cheering for a sports team, what will you do?
attila_lendvai has quit [Ping timeout: 248 seconds]
<whoman> be an alien, exiled? =)
<dTal> whoman: social in the sense of talking about Lisp, but not neccesarily in the sense of writing code that works together
<pjb> whoman: I flee!
jdz has joined #lisp
<whoman> sometimes it doesnt matter if the team loses or wins. its about togetherness ^_^
<whoman> dTal: oh! definately agree, then. its way out of balance in that regard/respect =)
<learning> i think we write quite a bit of code if you think of how many of us there are
<learning> what are there 1,000 lispers in the world?
<dTal> A big problem in the programming language world is how fans of a language embrace their chosen language's shitty parts in a tribalistic way
<pjb> Probably a little more.
<whoman> another good point; but crowds are indeed a force to be reckoned w/
<dTal> possibly the biggest problem
<pjb> But that's about the order of magnitude I would say.
<learning> ye
<whoman> dTal: they were conditioned to believe that way, i think =)
<learning> maybe 10,000
smurfrobot has quit [Ping timeout: 256 seconds]
<pjb> Not at a given time. But this may be the number programmer who have used lisp seriously at one time or another.
<pjb> (professionnaly or not).
<whoman> for myself personally, i like to draw the parallel of the meditating and chanting monks of the world -- compared to 'regular' people -- righteousness is more concentrated or whatever, but i like to think it holds up the world.
<dTal> For example APL variants should be vastly more influential than they are. They aren't because APL fans are addicted to unreadable syntax. It makes them feel clever.
<pillton> The biggest problem in the programming language world is that the runtime environments don't compose. This causes this conversation to occur over and over again.
<_death> why not concentrate on languages instead of people
<pjb> However unicode should help APL, recentering on the glyp-based notation. J was really to wild for me. :-)
<whoman> dTal: people get that way with spoken language too. i see it often, where a person excludes themselves further from their immediate family/neighborhood/culture by using more private and meaningful-only-to-me language
<whoman> _death =)
<dTal> Lisp fans defend cdaddr and caddar and cddddr and caaddr
<phoe> I don't defend them
<whoman> ur not a fan
<phoe> They serve a good function - shortcuts for quick, hacky code.
<dTal> pillton: Racket seems like the best effort in that direction
<_death> dTal: are you a Lisp fan
<phoe> In production code, they are meant to be eliminated, and the people who put them in there are meant to be shot.
<dTal> _death: you got me, I'm a fan of many aspects of Lisp but I'd hate to use it for my daily work
jmercouris has quit [Ping timeout: 256 seconds]
<whoman> maybe its like religion - we serve a higher purpose, whatever that is. stepping back from our personal persuits - for sports fanatics, wearing their team's color, i wonder how many decide its their favorite color(s), or wear them despite/inspite of?
<phoe> geez, now this is 100% lispcafe discussion
<_death> dTal: ok, then understand that you're an outlier here
<dTal> don't get me wrong
<dTal> My perfect language would be something like Axiom - a strongly typed, highly symbolic, syntax-heavy language written in Lisp
<whoman> link
<dTal> Lisp, or something very like it, should definitely be the implementation language for everything else
<dTal> the Racket guys get it
<whoman> depends what it is, i think; languages are tendencies toward certain mental concepts
<whoman> ie. erlang made from prolog
<whoman> ocaml from [s]ml
<dTal> whoman: the most maintained Axiom fork is FriCAS: fricas.sourceforge.net
<pillton> dTal: There has to be a common binary calling convention.
<whoman> dTal: ok i believe you, cant search for examples right now - looked at the API, seems cool. makes me think of Clean/Curry/Mercury/Coq
<whoman> pillton: pillton asm exec? =)
Tobbi has quit [Quit: Leaving]
whoman has quit [Read error: No route to host]
whoman has joined #lisp
motersen has quit [Ping timeout: 248 seconds]
pierpa has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
comborico1611 has joined #lisp
jtroseme has joined #lisp
wheelsucker has joined #lisp
Tobbi has joined #lisp
attila_lendvai has quit [Ping timeout: 240 seconds]
comborico1611 has quit [Quit: comborico1611]
wheelsucker has quit [Remote host closed the connection]
comborico1611 has joined #lisp
comborico has joined #lisp
smurfrobot has joined #lisp
z3t0 has joined #lisp
<pfdietz> sbcl, abcl, and ecl support package local nicknames. cmucl, ccl, and clisp do not. I don't know about Allegro CL or Lispworks.
haruka has quit [Remote host closed the connection]
jtroseme has quit [Remote host closed the connection]
jtroseme has joined #lisp
<pillton> whoman dTal: There is precedent here with COM. The fundamentals of COM are incredibly simple. The COM specification did give rise to a marketplace of language independent components. I don't know why people stopped using those fundamentals.
smurfrobot has quit [Ping timeout: 248 seconds]
<whoman> pillton: heh, i tried some COM stuff, it seemed very complex; idl interface files and whatnot
<whoman> then there's CORBA ...
<_death> pillton: I guess because they're satisfied with http or message queues nowadays..