amplituhedron has quit [Read error: Connection reset by peer]
Alloc has quit [Ping timeout: 240 seconds]
Alloc has joined #lisp
remexre has quit [Read error: Connection reset by peer]
smazga has quit [Ping timeout: 258 seconds]
remexre has joined #lisp
amplituhedron has joined #lisp
dyelar has joined #lisp
remexre has quit [Read error: Connection reset by peer]
nitrix is now known as nitrix-or-treat
jprajzne has quit [Quit: jprajzne]
remexre has joined #lisp
shifty has joined #lisp
jprajzne has joined #lisp
smazga has joined #lisp
dvdmuckle has joined #lisp
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
smazga has quit [Ping timeout: 272 seconds]
smazga has joined #lisp
dyelar has quit [Quit: Leaving.]
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
stoneglass has quit [Quit: stoneglass]
smazga has quit [Ping timeout: 260 seconds]
iissaacc has joined #lisp
amplituhedron has quit [Quit: Leaving]
smazga has joined #lisp
smazga has quit [Ping timeout: 272 seconds]
torbo has joined #lisp
smazga has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
smazga has quit [Ping timeout: 264 seconds]
jprajzne has quit [Quit: jprajzne]
smazga has joined #lisp
jprajzne has joined #lisp
drot has quit [Remote host closed the connection]
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
drot has joined #lisp
benjamindc has joined #lisp
benjamindc has left #lisp [#lisp]
smazga has quit [Ping timeout: 256 seconds]
smazga has joined #lisp
toorevitimirp has joined #lisp
quazimodo has joined #lisp
semz has quit [Ping timeout: 260 seconds]
smazga has quit [Ping timeout: 260 seconds]
smazga has joined #lisp
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
smazga has quit [Ping timeout: 260 seconds]
cer0 has joined #lisp
orivej has joined #lisp
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
Gerula has joined #lisp
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
igemnace has joined #lisp
aaaaaa has quit [Quit: leaving]
JessicaPurple has quit [Ping timeout: 240 seconds]
saganman has quit [Ping timeout: 260 seconds]
smazga has joined #lisp
smazga has quit [Ping timeout: 240 seconds]
torbo has quit [Remote host closed the connection]
paul0 has joined #lisp
_paul0 has quit [Ping timeout: 260 seconds]
Oladon has joined #lisp
lalilulelo has joined #lisp
shifty has joined #lisp
<beach>
Good morning everyone!
<cer0>
good night from where i am
<beach>
cer0: Are you new here? I don't recognize your nick.
<cer0>
beach: yeah, kinda new to the channel and to the land lisp 🤯️
<beach>
Great! Welcome!
Oladon has quit [Read error: Connection reset by peer]
<beach>
So is the plan to learn Common Lisp?
Oladon has joined #lisp
<cer0>
Thanks, actually, i'm about to finish reading the little schemer (:
<beach>
Oh! This is not the right channel then, I am sorry to say.
<cer0>
yeah ): ik, i'm starting with land of lisp, but my progress it's a little bit slow with that one.
<beach>
Ah, OK.
<cer0>
really interesting book tho
<beach>
For people who have programmed before, we also recommend PCL.
<beach>
minion: Please tell cer0 about PCL.
<minion>
cer0: look at PCL: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
<cer0>
do you use cl at work or somethig?
<beach>
Me?
<cer0>
thanks, minion
<beach>
minion: Thanks!
<minion>
np
<beach>
Sort of, yes.
<cer0>
anyone
shifty has quit [Ping timeout: 260 seconds]
<cer0>
cool, what for? if you donn't mind sharing
<beach>
I do research in programming-language implementation, and Common Lisp is both my target and my tool.
shifty has joined #lisp
<beach>
minion: Please tell cer0 about SICL.
<minion>
cer0: SICL: SICL is a (perhaps futile) attempt to re-implement Common Lisp from scratch, hopefully using improved programming and bootstrapping techniques. See https://github.com/robert-strandh/SICL
<cer0>
beach: oh, so is this what you're working on? :o
<beach>
Yes, among other things.
yk42bb has quit [Remote host closed the connection]
smazga has joined #lisp
frost-lab has joined #lisp
<cer0>
beach: that's cool, really cool. sorry i didn't recognized you, you seem to be really important among the lisp community ( :
<beach>
Thanks I don't think of myself that way, but I suppose some people do.
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
smazga has quit [Ping timeout: 260 seconds]
<cer0>
well, writing a re-implementation of cl must not be a easy task, and seems a lot of people found it useful
<beach>
Sure. There is no great point in doing only easy stuff. Not for a researcher anyway.
<cer0>
I barely wrote a lisp once, ahah, like, the last year i tried, but, my C skills are so bad. I was following this... buildyourownlisp.com
<cer0>
how did you ended up doing research?
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
<beach>
After my Masters degree, I worked in industry for a few years, and I noticed how insufficient the level of knowledge was in the developers. In fact, insufficiently low for the task at hand. So I quit and did a PhD. The rest is the "traditional" career path.
<beach>
Apparently, the situation is pretty much the same in the industry today.
<beach>
So, I looked at the first page of buildyourownlisp.com, and I am still amused by the fact that it is often assumed that you need a lower-level language in order to build a Lisp system.
shifty has quit [Ping timeout: 265 seconds]
<no-defun-allowed>
beach: I would highly advise against reading any of buildyourownlisp.
<beach>
Heh, OK. Good to know. Why is that?
<no-defun-allowed>
Legend has it #c said the code was terrible, and it manages to screw up evaluation and scoping in terrible ways.
shifty has joined #lisp
<beach>
I see.
<no-defun-allowed>
It uses something...sort of like fexprs in place of macros, but it wouldn't work with lexical scoping as there is no environment passed through.
<beach>
So both the C and the resulting Lisp code are bad.
<beach>
Wow, that does sound bad.
<cer0>
:O
<no-defun-allowed>
Oh, and LIST doesn't evaluate its arguments, leaving CAR and CDR to do that!
<beach>
Oh dear!
<beach>
Who is the author of that stuff?
<cer0>
good thing i never fished it :s
<no-defun-allowed>
The introduction says these changes are merely "different", and we're all old grimpy farts for complaining.
tel has joined #lisp
<no-defun-allowed>
We researched in #lispcafe, from memory someone that did a PhD in computer graphics, and works in game development.
<beach>
Let's hope that's not a trend. :)
<no-defun-allowed>
*grumpy rather. My phone felt like autocorrecting this morning, but not now.
<beach>
Sounds like a brilliant example of the Dunning-Kruger effect.
<ck_>
implementing a "lisp" and failing isn't uncommon I would say
<no-defun-allowed>
One should be terrified by a book that introduces macros before variables and functions.
<ck_>
while advertising the result as great, too
<beach>
ck_: But this one seems different. Apparently, the person feels successful.
<beach>
Ah, yes.
gravicappa has joined #lisp
<no-defun-allowed>
Well, he may be in computer graphics, and hopefully not while using C for it.
<beach>
cer0: Do you know some other programming languages already?
<cer0>
beach: basic python, ruby and medium/mediocre bash ):
<cer0>
tbh when i started with python and encountered Fibonacci recursive function my brain couldn't handle it, but now, i'm really comfortable with recursion (:
<no-defun-allowed>
If I could suggest one thing, it's to hold off writing an implementation of a (small) Lisp before writing some non-trivial code in it, because then you'll have an intuition for what's going on when you write the implementation and test it.
<beach>
cer0: Great! Recursion is not used much in Common Lisp, and certainly not for linear structures. It is mainly used for things like trees, where the depth is limited, and the alternative would make the code incomprehensible.
<beach>
no-defun-allowed: Sounds like good advice.
<cer0>
no-defun-allowed: thanks for the tip, i didn't knew it wasn't a good material for starting with cl or lisp in general.
<beach>
Yeah, good to know.
<no-defun-allowed>
I wrote a crappy compiler about two months in, because I was convinced Lisp implementations didn't compile as they don't dump images like batch compilers.
<beach>
You mean you wrote a compiler because you didn't think they existed already?
<cer0>
like, 4 years someone told me about lisp, and i tried to find a book or something to find out what it was, i guess i installed clisp, but that was it, my english reading skills weren't really good at that time, so, i ended up not reading the book, but i always feel like i wanted to learn lisp.
<no-defun-allowed>
Yes. And it was awful in many ways I don't feel like saying.
* Blukunfando
likes the picture of the library in that page.
<beach>
It is a common thing to confuse on the one hand interactive/batch and on the other hand interpreted/compiled.
<beach>
That's what was so strange about working in industry. There are all those professional developers who have completely insufficient knowledge about basic software techniques.
shifty has quit [Ping timeout: 260 seconds]
<cer0>
Oh. I see, do you recommend a book for learning that?
shifty has joined #lisp
<no-defun-allowed>
I would contradict what I said about getting a feel for the language if I suggested you read a compiler book now.
<beach>
minion: Please tell cer0 about LiSP.
<minion>
cer0: please look at LiSP: "Lisp in Small Pieces". This book covers Lisp, Scheme and other related dialects, their interpretation, semantics and compilation. To sum it up in a few figures: 500 pages, 11 chapters, 11 interpreters and 2 compilers. <http://pagesperso-systeme.lip6.fr/Christian.Queinnec/WWW/LiSP.html>
<beach>
But yeah, maybe put that off for now.
<beach>
cer0: But when you get around to it, it's a great book. And the English translation is an improvement on the French original :)
<beach>
They must have had an excellent translator.
<beach>
Though apparently, the author then wrote a new version of the book (also in French), that has not been translated into English.
<no-defun-allowed>
Now I work with two compilers: one compiling a Lisp-1 to an abstract machine I made, and the SICL compiler which I will use to compile Common Lisp to the Java virtual machine.
<cer0>
Sure. Thank you, I'll share this links with the people I know happen to like CL. (:
Alloc has quit [Ping timeout: 240 seconds]
mbomba has joined #lisp
<cer0>
Lisp, in general.
Alloc has joined #lisp
<no-defun-allowed>
Compiler hacking is quite fun, but it makes a lot more sense when you know what you would need to host the language, and how to build that from the features your target provides if you don't control that.
<cer0>
Well, It's getting late, see you around beach , no-defun-allowed , thanks for the information. I'll stay away from that buildyourownlisp page. (:
<beach>
Take care!
<no-defun-allowed>
Take care.
<cer0>
Same, be safe!
cer0 has quit [Quit: cer0]
saganman has joined #lisp
Oladon has quit [Quit: Leaving.]
tel has quit [Remote host closed the connection]
<no-defun-allowed>
Also, to be honest, I think it's silly the title insists it's "your" Lisp when the code you write is mostly copied verbatim from the book, and the rest are from fairly close-ended questions.
<no-defun-allowed>
"and the rest is from answering fairly close-ended questions".
<no-defun-allowed>
But I find it too easy to complain, so I'll just say that the last two chapters of SICP and all of LiSP is a much better resource. My abstract machine is quite similar to that of chapter 5 of SICP.
Alloc has quit [Ping timeout: 240 seconds]
smazga has joined #lisp
<beach>
Good advice.
shifty has quit [Ping timeout: 272 seconds]
igemnace has quit [Remote host closed the connection]
shifty has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
jprajzne has quit [Quit: jprajzne]
smazga has quit [Ping timeout: 264 seconds]
smazga has joined #lisp
jprajzne has joined #lisp
smazga has quit [Ping timeout: 272 seconds]
smazga has joined #lisp
_whitelogger has joined #lisp
ggole has joined #lisp
shifty has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
bocaneri has joined #lisp
smazga has quit [Ping timeout: 272 seconds]
jprajzne has quit [Quit: jprajzne]
shifty has quit [Read error: Connection reset by peer]
Alloc has joined #lisp
shifty has joined #lisp
jprajzne has joined #lisp
jprajzne has quit [Client Quit]
Alloc has quit [Ping timeout: 240 seconds]
jprajzne has joined #lisp
iissaacc has quit [Ping timeout: 260 seconds]
tamarindo has quit [Ping timeout: 240 seconds]
smazga has joined #lisp
iissaacc has joined #lisp
smazga has quit [Ping timeout: 240 seconds]
iissaacc has quit [Ping timeout: 246 seconds]
tamarindo has joined #lisp
shka_ has joined #lisp
mbomba has quit [Quit: WeeChat 2.9]
space_otter has joined #lisp
aartaka has joined #lisp
<MichaelRaskin>
no-defun-allowed: isn't it a pun on choose your own adventure style books?
<no-defun-allowed>
MichaelRaskin: There's nothing to choose from though.
<no-defun-allowed>
It may be, but it's pretty misleading.
<MichaelRaskin>
«answering a few questions with enumerated options» is exactly how choose your own adventure goes, it is a book with forks that re-converge anyway
<no-defun-allowed>
I would have to check how the "choose your own adventure" books I read when I was younger go, but there is basically one option for each question.
<MichaelRaskin>
OK, maybe the references I have seen, with forks and merges, were references to the best of class options
<no-defun-allowed>
And it's intended to be read linearly, so I still don't get it. But I'd rather not discuss it, because it depresses me that the book may have seen some success.
aartaka has quit [Ping timeout: 240 seconds]
aartaka has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
skapata has quit [Remote host closed the connection]
orivej has joined #lisp
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
daphnis has joined #lisp
<daphnis>
i get a warning from (if (boundp 'foo) foo bar) is this somehow bad?
pve has joined #lisp
<beach>
Sort of.
<beach>
The compiler can't know that you are testing whether FOO is bound before using it.
<beach>
Is FOO a special variable?
<beach>
daphnis: Are you still there?
<daphnis>
don't know what a special var is, but i guess not
<beach>
daphnis: If FOO is a special variable, it is badly named. It should have earmuffs on it.
<beach>
If it is a lexical variable, then you can't test it with BOUNDP.
<daphnis>
i have a macrolet macro that i want to use in- and outside a certain loop
<daphnis>
if inside, i want to use a loop var, otherwise something else
<MichaelRaskin>
Loop is also written by you?
<beach>
That sounds like a very strange design.
<daphnis>
yes
<MichaelRaskin>
You could macrolet something right around the loop, then let a macro check the presence of this macrolet and decide before expansion, not in runtime
<MichaelRaskin>
Or you could just save the external value into a different name using «with», and use the same name for the loop variable as you use outside
<MichaelRaskin>
Which is way less magic
<daphnis>
thanks!
Patzy has joined #lisp
shifty has quit [Ping timeout: 260 seconds]
shifty has joined #lisp
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
Alloc has joined #lisp
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
<daphnis>
MichaelRaskin: what's "with"? i used let.
<MichaelRaskin>
Loop has many keywords
<MichaelRaskin>
You probably use let, but there is also with to bind something once
shifty has quit [Ping timeout: 264 seconds]
shifty has joined #lisp
<daphnis>
MichaelRaskin: ah, a loop keyword.
<jackdaniel>
a precise phrasing would be loop has many loop keywords
<jackdaniel>
because loop keyword is not a keyword :-)
<MichaelRaskin>
I actually typically write them as keywords, though
Alloc has quit [Ping timeout: 240 seconds]
shka_ has quit [Quit: Konversation terminated!]
shifty has quit [Ping timeout: 256 seconds]
Alloc has joined #lisp
shifty has joined #lisp
<aeth>
yeah... most syntax highlighters highlight keywords in a special way, so LOOP's keywords make sense as keywords, at least if you don't expect syntax highlighters to support LOOP as a special case
<aeth>
they also stand out more in one-liners (e.g. for IRC)
<jackdaniel>
I don't think that code highlighting as it is now is very useful
<jackdaniel>
I mean -- I know that top-level defun defines a function, it doesn't need to be blue ;)
<beach>
aeth: That begs the question; why do you want LOOP keywords to be highlighted?
<beach>
... or Common Lisp keywords as well for that matter.
<aeth>
mainly for when :for clauses get really complicated
<jackdaniel>
one could argue, that trivial highlight of variables that are not lexical in the scope of a function would be far more useful
<jackdaniel>
however *foo* convention kind of solves that
<beach>
Yes, there are so many more useful ways of highlighting. But Emacs can't handle those ways in general.
<beach>
jackdaniel: It would be useful to highlight precisely when earmuffs are not used.
<jackdaniel>
right. my point is that syntax highlight is not useful for someone who knows the syntax, and for those who don't know it it won't help much
<jackdaniel>
yes
<aeth>
jackdaniel: maybe not useful for you, but it helps me visually distinguish between the parts of a long, complicated :for... which seems to happen all of the time in my LOOPs
<jackdaniel>
another useful thing (but only as an opt-in mode) would be marking how new the code is
<aeth>
even without the highlighting, the : helps, of course
<jackdaniel>
it is quite common that new additions/modifications are more error prone
<MichaelRaskin>
Or the old stuff has its bugs already worked around elsewhere…
<jackdaniel>
i.e green code is >1y, red code was modified yesterday, and a gradient in between
<beach>
aeth: I would work on those complicated FOR clauses if I were you.
<aeth>
They would be even more complicated if LOOP supported multiple values. :-)
<jackdaniel>
MichaelRaskin: sure, my point is that you have a visual marker what could have caused a regression you are investigating
ym has joined #lisp
shifty has quit [Ping timeout: 272 seconds]
shifty has joined #lisp
<jackdaniel>
(not necessarily because the new code is wrong, it might be that it has revealed undetected defect, still it is a useful clue)
<MichaelRaskin>
Yeah, sure. And also safer to fix than the old code
jprajzne has quit [Quit: jprajzne]
<aeth>
jackdaniel: oh, that's actually really easy, if you define "new" in terms of the git (or other) repository's data. I wouldn't be surprised if someone has already done that. It saves a step over something like magit-diff if you only care about the new half of the diff
jprajzne has joined #lisp
<aeth>
And in general, it's not too different from a simplified blame
<jackdaniel>
"that's actually really easy" are famous last words of programmers who died in pits of despair
smazga has joined #lisp
<aeth>
jackdaniel: "easy" in the Pythonic sense of "someone probably already wrote it" :-)
<jackdaniel>
either way, that's beside the point. I'm only arguing that color is very easy for the eye, so it is a waste to use it for syntax highlight
<aeth>
it's very similar to what magit-blame does
<aeth>
jackdaniel: one advantage of syntax highlighting is that you can instantly catch certain typos, especially if you have a string or block comment that's not properly closed (assuming the syntax highlighter understands the full string and comment syntax of the language)
<aeth>
It certainly can be overdone for other things, though.
<aeth>
Probably most other things...
<aeth>
Some syntax highlighters highlight almost everything
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
<jackdaniel>
mistyped things could be highlighted instead, or underlined
smazga has quit [Ping timeout: 260 seconds]
<MichaelRaskin>
Some people just like the rainbow!
<aeth>
how does the editor know what part should be in the string more than you know?
shka_ has joined #lisp
* jackdaniel
has voiced his opinion and dives back into pits of despair, because he is working on something what is actually really easy ;] ciao
<Nilby>
for me, colors are so I can scroll 110 km/h and barely read and still know what's up
<aeth>
or zoom out a lot and still see the comments
<aeth>
if you pick a nice color for your comments, it looks really cool
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
mfiano has quit [Quit: WeeChat 2.9]
mfiano has joined #lisp
mfiano has quit [Client Quit]
<beach>
Nilby: But we are discussion precisely the best way to show the user "what's up".
mfiano has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
<MichaelRaskin>
beach: the difference is that you assume the information from the text is easily available and Nilby wants the usecase when the colours are the only information
<Nilby>
I guess I only need a vauge idea, so coarse syntactic coloring is okay. If I need to really know, I'll slow down and read. I've tried doing the subtle shade thing to convey more precice info, but I usually don't see it.
<aeth>
if you really like colors at a glance... s-expressions probably make it easy to color entire expressions
<aeth>
defmethod? light blue. defclass? light green. defun? dark blue. etc.
<aeth>
maybe s-expression-aware highlighting could be the "killer app" of an Emacs competitor for CL programming
<aeth>
you could define your own highlighting rules for a macro
<Nilby>
also, sometimes I the environment only gives me 16 colors to use
<aeth>
Yeah, that's the real problem. Terminals don't offer you many colors, and they're usually a pretty bad selection (which could remove some colors just because of the combinations not going together)
<aeth>
That's one of the main reasons I use graphical Emacs
mfiano has quit [Quit: WeeChat 2.9]
mfiano has joined #lisp
<Nilby>
woe be upon my terminal colors when I try to run on windows, phones, and barren servers
<aeth>
I use a dozen different terminals so I'm constantly fighting colors.
jprajzne has quit [Quit: jprajzne]
shifty has quit [Ping timeout: 260 seconds]
shifty has joined #lisp
jprajzne has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
smazga has joined #lisp
aartaka has joined #lisp
shifty has quit [Ping timeout: 272 seconds]
shifty has joined #lisp
iissaacc has joined #lisp
random-nick has joined #lisp
epony has quit [Remote host closed the connection]
gaqwas has quit [Remote host closed the connection]
<daphnis>
how do i make *posix-argv* available to other packages than cl-user?
<Xach>
daphnis: symbol availability is managed through the package system. the tools in this case are defpackage, import, or use-package.
epony has joined #lisp
<Xach>
daphnis: you can also refer to it with a package prefix from other packages.
<no-defun-allowed>
It always is with a package prefix: sb-ext:*posix-argv*
<daphnis>
thanks!
Alloc has quit [Ping timeout: 240 seconds]
jprajzne has quit [Quit: jprajzne]
<Nilby>
there's also (uiop:command-line-arguments) and (uiop:raw-command-line-arguments)
jprajzne has joined #lisp
flazh has quit [Ping timeout: 240 seconds]
rippa has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
jprajzne has quit [Quit: jprajzne]
amb007 has joined #lisp
Alloc has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
shifty has quit [Ping timeout: 272 seconds]
shifty has joined #lisp
<daphnis>
how do i prevent sbcl from printing debugging information after ctrl-c?
jw4 has quit [Read error: Connection reset by peer]
<phoe>
what do you mean, printing debugging information?
<phoe>
if you Ctrl+C in the terminal, this sends a unix SIGINT to the process which usually causes SBCL to enter the debugger
<phoe>
what else would you like it to do?
jw4 has joined #lisp
<daphnis>
just quit without printing anything, like normal programmes do. i used --non-interactive, so it doesn't wait for input, but it still prints stuff
<Xach>
daphnis: if that's the case, i suggest not trying to build a standalone executable yet.
<Xach>
no-defun-allowed: that's a nice, simple option. for sbcl sb-ext:*invoke-debugger-hook* would be a nice variation.
<no-defun-allowed>
You can use C-d to tell SBCL to exit like C-c. Honestly, I would keep the debugger because it would be nice if "normal programs" broke into a debugger when they break.
<phoe>
Xach: trivial-custom-debugger exits for cross-implementation setting of invoke-debugger-hook or whatever it's called everywhere
<phoe>
exists*
gxt has quit [Remote host closed the connection]
<Xach>
That seems like an unnecessary complication early on,
gxt has joined #lisp
<phoe>
oh, yes
_jrjsmrtn has joined #lisp
flazh has joined #lisp
ramus has quit [Ping timeout: 240 seconds]
accusa7i0ns has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 240 seconds]
hendursa1 has quit [Remote host closed the connection]
hendursa1 has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
ramus has joined #lisp
iissaacc has quit [Ping timeout: 260 seconds]
accusa7i0ns has quit [Quit: Leaving.]
Alloc has joined #lisp
ramus has quit [Ping timeout: 258 seconds]
ramus has joined #lisp
shifty has quit [Ping timeout: 258 seconds]
shifty has joined #lisp
shifty has quit [Ping timeout: 260 seconds]
shifty has joined #lisp
Alloc has quit [Ping timeout: 240 seconds]
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
space_otter has quit [Remote host closed the connection]
Jesin has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
jonatack has quit [Ping timeout: 258 seconds]
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
dbotton_ has joined #lisp
smazga has quit [Ping timeout: 256 seconds]
dbotton has quit [Ping timeout: 260 seconds]
dbotton has joined #lisp
ym has quit [Quit: Leaving]
dbotton_ has quit [Ping timeout: 260 seconds]
shifty has quit [Ping timeout: 256 seconds]
shifty has joined #lisp
Nilby has quit [Read error: Connection reset by peer]
dbotton_ has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
dbotton has quit [Ping timeout: 272 seconds]
dbotton__ has joined #lisp
justHaunted has quit [Ping timeout: 260 seconds]
dbotton__ is now known as dbotton
<pve>
Hello! I'm thinking about a protocol, but have trouble deciding between two approaches. Which do you think is better? I'm leaning towards #1.
<Xach>
pve: i like unary predicates (and functions in general) if i intend to map them or do general higher-order programming with them to reduce the use of (lambda (token) (token-kind token 'foo)) vs #'token-foo-p
<pve>
Xach: thank you, good point
<Xach>
although sometimes i make something like (defun =token-kind (kind) (lambda (token) (eq (kind token) kind)) and do (remove-if (=token-kind 'foo) list)
<pve>
right
<phoe>
I also use (a:rcurry #'token-kind 'my-token) sometimes
<phoe>
where a stands for alexandria
<phoe>
also, if you want to go full CLOS, CHECK-VALID-TOKEN-KIND could be a generic function with the default method returning NIL and other methods, EQL-specialized on symbols, returning T
<phoe>
...and then I guess it should be VALID-TOKEN-KIND-P and be a predicate rather than an assertion
<pve>
phoe: sure, that could work
<phoe>
but that's just my $0.02
<pve>
the set of kinds is closed, which is why I let it be a function
<pve>
or rather, didn't spend much time thinking about it
<phoe>
oh, this way
<phoe>
if you intend it not to be user- extensible in any way, then I guess it could work
<phoe>
s/user- extensible/user-extensible/
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
<Xach>
i'd expect a function named check-<something> to signal an error rather than return nil
theBlackDragon has quit [Ping timeout: 256 seconds]
madage has joined #lisp
Jesin has joined #lisp
jayok has quit [Ping timeout: 240 seconds]
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
Alloc has quit [Ping timeout: 240 seconds]
JessicaPurple has joined #lisp
cer0 has joined #lisp
theBlackDragon has joined #lisp
yitzi has joined #lisp
miasuji has quit [Ping timeout: 260 seconds]
Inline has joined #lisp
lispbeginner has joined #lisp
dbotton has quit [Ping timeout: 260 seconds]
shifty has quit [Ping timeout: 256 seconds]
shifty has joined #lisp
miasuji has joined #lisp
sbodin has joined #lisp
<MichaelRaskin>
Does anyone know if there are any recent changes in how monolithic-compile-bundle-op is supposed to be used on recent ASDF (with SBCL on Linux)?
yitzi has quit [Quit: yitzi]
Lord_of_Life_ is now known as Lord_of_Life
Lord_of_Life has joined #lisp
Lord_of_Life has quit [Changing host]
dbotton has joined #lisp
shifty has quit [Ping timeout: 260 seconds]
shifty has joined #lisp
<MichaelRaskin>
Hmm. It feels like before it sorted dependency closure by inter-dependency, and now just takes the order in the top-level ASD file
corpix has joined #lisp
Bike has quit [Remote host closed the connection]
pi2 has joined #lisp
pi2 is now known as ariedro
shifty has quit [Ping timeout: 264 seconds]
yitzi has joined #lisp
yitzi has quit [Remote host closed the connection]
miasuji has quit [Remote host closed the connection]
miasuji has joined #lisp
Bike has joined #lisp
lispbeginner has quit [Ping timeout: 272 seconds]
corpix_ has joined #lisp
madage has quit [Ping timeout: 240 seconds]
corpix has quit [Ping timeout: 240 seconds]
gxt has quit [Ping timeout: 240 seconds]
toorevitimirp has quit [Ping timeout: 260 seconds]
daphnis has quit [Ping timeout: 265 seconds]
smazga has quit [Ping timeout: 240 seconds]
EvW has quit [Ping timeout: 240 seconds]
gjnoonan has quit [Ping timeout: 240 seconds]
billstclair has quit [Read error: Connection reset by peer]
billstclair has joined #lisp
gjnoonan has joined #lisp
moewe has joined #lisp
moewe is now known as samtineld
jealousmonk has joined #lisp
madage has joined #lisp
Josh_2 has joined #lisp
Inline has quit [Ping timeout: 272 seconds]
EvW has joined #lisp
<Josh_2>
Afternoon
bitmapper has quit [Quit: Connection closed for inactivity]
daphnis has joined #lisp
smazga has joined #lisp
<phoe>
hey
dbotton has quit [Ping timeout: 260 seconds]
smazga has quit [Ping timeout: 258 seconds]
cer0 has quit [Quit: cer0]
notzmv has quit [Ping timeout: 258 seconds]
jayspeer has joined #lisp
daphnis has quit [Ping timeout: 260 seconds]
cl-arthur has quit [Remote host closed the connection]
goldrin1227[m] has quit [Quit: Idle for 30+ days]
cer0 has joined #lisp
smazga has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
daphnis has joined #lisp
hnOsmium0001 has joined #lisp
miasuji has quit [Ping timeout: 260 seconds]
emacsomancer has quit [Ping timeout: 265 seconds]
dbotton has joined #lisp
smazga has quit [Ping timeout: 265 seconds]
sbodin has quit [Ping timeout: 265 seconds]
sbodin has joined #lisp
sbodin has quit [Max SendQ exceeded]
terpri_ has joined #lisp
jonatack has joined #lisp
terpri has quit [Read error: Connection reset by peer]
sbodin has joined #lisp
sbodin has quit [Max SendQ exceeded]
jonatack has quit [Ping timeout: 264 seconds]
jonatack has joined #lisp
sbodin has joined #lisp
sbodin has quit [Max SendQ exceeded]
sbodin has joined #lisp
sbodin has quit [Excess Flood]
sbodin has joined #lisp
sbodin has quit [Max SendQ exceeded]
sbodin has joined #lisp
sbodin has quit [Excess Flood]
sbodin has joined #lisp
sbodin has quit [Excess Flood]
sbodin has joined #lisp
sbodin has quit [Excess Flood]
sbodin has joined #lisp
sbodin has quit [Excess Flood]
smazga has joined #lisp
nicktick has quit [Ping timeout: 240 seconds]
smazga has quit [Ping timeout: 260 seconds]
emacsomancer has joined #lisp
Lycurgus has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
notzmv has joined #lisp
amb007 has joined #lisp
smazga has joined #lisp
rgherdt has joined #lisp
smazga has quit [Ping timeout: 258 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
dbotton has quit [Ping timeout: 260 seconds]
jayspeer has quit [Quit: rebooting because I'm messing with my system]
corpix has joined #lisp
jayspeer has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
torbo has joined #lisp
corpix_ has quit [Ping timeout: 240 seconds]
nicktick has joined #lisp
corpix_ has joined #lisp
jprajzne has joined #lisp
corpix has quit [Ping timeout: 240 seconds]
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
EvW has joined #lisp
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
Inline has joined #lisp
galex-713 has joined #lisp
smazga has joined #lisp
dbotton has joined #lisp
jprajzne has quit [Quit: jprajzne]
smazga has quit [Ping timeout: 260 seconds]
smazga has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
corpix has joined #lisp
amb007 has joined #lisp
Alloc has joined #lisp
corpix_ has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
aartaka has quit [Ping timeout: 256 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
smazga has quit [Ping timeout: 240 seconds]
nicktick has quit [Ping timeout: 272 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
dvdmuckle has quit [Ping timeout: 272 seconds]
smazga has joined #lisp
smazga has quit [Ping timeout: 260 seconds]
madage has quit [Ping timeout: 240 seconds]
skapata has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
madage has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
dbotton has quit [Ping timeout: 256 seconds]
amb007 has joined #lisp
dbotton has joined #lisp
dbotton_ has quit [Ping timeout: 246 seconds]
IPmonger has joined #lisp
dbotton_ has joined #lisp
aartaka has joined #lisp
IPmonger has quit [Client Quit]
rumbler31 has quit [Remote host closed the connection]
dbotton has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
IPmonger has joined #lisp
smazga has joined #lisp
corpix has quit [Remote host closed the connection]
dvdmuckle has joined #lisp
shifty has joined #lisp
Lycurgus has quit [Quit: Exeunt]
smazga has quit [Ping timeout: 260 seconds]
torbo has quit [Remote host closed the connection]
torbo has joined #lisp
jayspeer has quit [Quit: dozing off. Zzz...]
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
IPmonger has joined #lisp
shifty has quit [Ping timeout: 265 seconds]
epony has quit [Remote host closed the connection]
brainfunnel has joined #lisp
cl-arthur has joined #lisp
daphnis has quit [Ping timeout: 272 seconds]
epony has joined #lisp
smazga has joined #lisp
Jeanne-Kamikaze has joined #lisp
gxt has joined #lisp
gxt has quit [Client Quit]
smazga has quit [Ping timeout: 256 seconds]
bars0 has joined #lisp
gxt has joined #lisp
dbotton has joined #lisp
gravicappa has quit [Ping timeout: 256 seconds]
gravicappa has joined #lisp
Oladon has joined #lisp
<dbotton>
What is the best way to insure the type used matches what is expected, example - (defstruct choice (name (error "Must provide :NAME."))
<dbotton>
While compile time ideal even dynamically
<phoe>
you mean in DEFSTRUCT?
<dbotton>
In particular if there is some idiomatic way to do in CL
<dbotton>
well this is a struct (from your book ;)
<dbotton>
but I was curious if I had such a struct is there a way to insure what is put in it
<phoe>
(defstruct choice (name (error "Must provide :NAME.") :type symbol))
<dbotton>
of and for the function?
<phoe>
:type function I guess
<phoe>
but depends if you always put some function in there
<phoe>
you might want :type (or null function) if there might be a NIL in there
<dbotton>
ok, and is there a way to insure a specific signature of the function
<phoe>
nope
smazga has joined #lisp
<dbotton>
how would I test for that (i assume possible)
<dbotton>
I guess on sbcl can do a declare
<phoe>
actually, not really
<phoe>
the FUNCTION type cannot be used for discrimination
<dbotton>
hmmm
<phoe>
you could in theory (ql:quickload :trivial-arguments) and use that to grab lambda lists from function objects and check if the lambda list matches
<phoe>
but that's kind of a hassle
<dbotton>
ok, so nothing beyond honor system and hope doesn't explore :)
choegusung has joined #lisp
<phoe>
actually, if you call a function with a wrong number of arguments, a PROGRAM-ERROR should be signaled
<dbotton>
ok
<_death>
if you really wanted you could implement your own and have (defstruct typed-function argument-types return-types phase-of-the-moon lisp-function) etc.
<dbotton>
maybe eventually for now just trying to understand the lispy way
<_death>
the Lispy way is to not declare types if there's no good reason to
<dbotton>
I see it, just taking some getting used to. Is like wearing sandals after a life time of formal shoes
<_death>
what constitutes a "good reason" is something to be learned and is situation-specific
<phoe>
I guess that you could (deftype typed-function ...) and check the lambda list in a SATISFIES predicate internally
<phoe>
by using trivial-arguments:arglist
<phoe>
it would be a hack, but it would work
galex-713 has quit [Ping timeout: 272 seconds]
smazga has quit [Ping timeout: 260 seconds]
<dbotton>
In time I guess I'll see if necessary or how defensive I have to code
<phoe>
I just realized that TCLCS could be used as kind of a tutorial for building libraries in Common Lisp
<dbotton>
I am just used to the extreme sense of type as a protection from programmer error
<phoe>
if we can build a condition system from scratch then we could build other sorts of code from scratch too
* phoe
thinks
<phoe>
dbotton: usually one doesn't program this defensively in CL because the feedback loop is tiny and one can test code as it is written in the REPL
<phoe>
also unit tests are a thing and SBCL type inference is also a thing
galex-713 has joined #lisp
<phoe>
if you DECLARE TYPE then SBCL treats it as an assertion and will warn you if it detects a type mismatch somewhere in your code
<dbotton>
so I can use the declare type in a struct?
<dbotton>
I know can in clos
<phoe>
uhhh, in defstruct? you should use the :TYPE slot option
<phoe>
DECLARE TYPE is mostly a thing one uses in functions
<phoe>
like (defun foo (bar) (declare (type string bar)) ...)
<dbotton>
sorry that is what I mean, sorry didn't realize could use also in defstruct
<_death>
basically using a dynamic language/system requires a different mindset
<dbotton>
I see that, making the transition not so easy, but already pushing to always look from the perspective of the data no the container
<phoe>
well, Lisp is a language that empowers the programmer
<dbotton>
not sure I always trust those guys ;)
<phoe>
it means that "you shouldn't do that" in Lisp is usually merely a suggestion, whereas in other languages "you shouldn't do that" could cause your code to not even compile
<dbotton>
well that is not per se a negative
<phoe>
that is the case with e.g. modifying slots; there's no real "private" or "protected" modifiers like in Java or C++
<Josh_2>
if you want to make sure a function receives the expected type you can use the macro (check-type .. ) I use it quite a bit
smazga has quit [Ping timeout: 240 seconds]
bars0 has quit [Quit: leaving]
<dbotton>
(I really wish had started with list 10 or 20 yrs ago... maybe though was not mature enough then to appreciate)
<dbotton>
lisp not list
<phoe>
the tooling has improved since 2010
<dbotton>
all is what it is, I am only 3 weeks in
<Josh_2>
very cool dbotton :D
<dbotton>
getting beyond the idea of never placing programming logic in an exception already a shock
<dbotton>
:)
<phoe>
in an exception? what do you mean
<phoe>
in Lisp, you never place programming logic in exceptions
<dbotton>
using the condition system beyond handle-case
<phoe>
(mostly because in Lisp you have no exceptions)
<pve>
I'm not sure the tooling was that bad even before 2010, I still remember being blown away by Marco Baringer's slime video in like 2006 or something
<dbotton>
handler-case = see still working on getting it all in place
<dbotton>
in every other language it is an exception system not a condition system
<phoe>
shka_: actually you can't do that portably because ERROR is not required to be a standard-class
<phoe>
(define-condition exception (error) ...)
<shka_>
right
<shka_>
i
<shka_>
i really don't like this aspect of cl
epony has joined #lisp
<phoe>
which one do you mean
<shka_>
conditions not being standard-classes
<shka_>
it feels completely redundant
<phoe>
inorite
smazga has joined #lisp
ggole has quit [Quit: Leaving]
<aeth>
shka_: it's so you can use the condition system internally even before you have standard classes
<phoe>
only SBCL does it that way though
akoana has joined #lisp
<Bike>
the CL conditions system can be conceived of as an exception system plus extra bits
<Bike>
if you don't use restarts or handler-bind there ya go
<phoe>
or signal
<phoe>
error/handler-case/unwind-protect is literally throw/try/catch/finally
<Bike>
oh true
<shka_>
aeth: ok, this is an acceptable reason
gravicappa has quit [Ping timeout: 260 seconds]
<Bike>
under the hood it doesn't work much like C++ or anything (ask me about clasp! or don't, this part of it sucks) so there's a lie-to-children aspect
<dbotton>
but outside of that seems like handler-bind has some usage not related to exceptions at all
EvW has quit [Ping timeout: 260 seconds]
choegusung has quit [Quit: leaving]
<dbotton>
is there a reason not to use it in a design?
<phoe>
a design of what exactly?
<dbotton>
normal functionality of a program
<phoe>
yes, it's useful for hooks
<_death>
if conceived as such, it may shift pragmatics towards that common denominator
<shka_>
dbotton: you can do it, pcl describes it
<dbotton>
that is my point, no one is going to avoid it like the exception systems of every other language
<shka_>
but i personally don't find it to be a good idea
<dbotton>
why?
<phoe>
SIGNAL is a way of saying "hey, if you have dynamically provided me any code that matches this symbol, I will run it for you"
<phoe>
and HANDLER-BIND is a way of saying "here ya go mate"
<shka_>
because you can do the same with object in a bound to a dynamic variable
<shka_>
and more as well
<dbotton>
this though seems more "obvious" to the reader
<phoe>
(well, handlers are objects bound to a dynamic variable)
<phoe>
but yes, if you want or need to reinvent the handler subsystem for any reason then it's easy to do so
<shka_>
well, i don't think it is more obvious
<phoe>
TCLCS describes this case and the restart subsystem too
<shka_>
i would rather call a generic function then play around with different ways of selecting restarts
<shka_>
for error handling, sure condition system is perfect
epony has quit [Remote host closed the connection]
arbv has joined #lisp
epony has joined #lisp
<shka_>
but i think they are not the best option for the regular application logic
<shka_>
that's just my personal opinion though
<dbotton>
_death from that post "if you want the compiler to smack you in the face if you do it anyway, I'd say you have an attitude problem that needs readjustment" - I wonder what that says about me...
<dbotton>
I guess I have been a software control freak for most of my life :)
smazga has quit [Ping timeout: 240 seconds]
<phoe>
shka_: conditions are more or less extension points; they're equivalent to generic functions, especially with this approach that beach and scymtym have been using recently, e.g. inside eclector
<phoe>
where you have a client of sorts as an argument to each GF, and you can specialize on it to add your own functionality
<phoe>
and then you have a *client* dynavar that you can rebind to turn this functionality on or off
<_death>
dbotton: also check his next message in the thread (the one mentioning epistemological assumptions)
<dbotton>
I am still trying to collect my ego from its broken pieces on my floor.. soon
smazga has joined #lisp
<shka_>
phoe: in theory yes, but in practice i find them usually worse option for the extension
<phoe>
shka_: find who usually worse option?
<shka_>
i can't parse the above sentence
<phoe>
if it's conditions, then to be honest, so do I - the GF approach is cleaner wherever you know what your code should do at a given moment
<phoe>
shka_: "in practice i find them usually worse option for the extension"
<phoe>
in the above sentence, the variable THEM is unbound
<shka_>
yes, i meant that i find condition system to be less practical as an extension point
<scymtym>
that's more modularity than extensibility, though
<shka_>
scymtym: eh, not really
<shka_>
i mean, it is okish
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<shka_>
but once you start threads things become more complicated
<shka_>
and sure, dynamic variables must be reestablished in the new thread
<shka_>
but that's handier then transferring conditions over threads
EvW has joined #lisp
smazga has quit [Ping timeout: 256 seconds]
sbodin has joined #lisp
sbodin has quit [Excess Flood]
<shka_>
overall, i think that condition system is pretty much specialized tool that can be pressed into service for other tasks
<shka_>
but it does not make it ideal
<phoe>
the condition system is handy when your code doesn't have full information about how it should act
<scymtym>
shka_: sure, but i didn't find the complications from threads problematic in practice. more like a cost paid once for being able to report progress of operations from anywhere in the code (and having the same code work fine if progress notification are not handled)
smazga has joined #lisp
<phoe>
if you don't have really exceptional situations then standard control flow is enough in all cases, by definition
<shka_>
scymtym: sure, but the same can be done with (defvar *handler*) and just let
<shka_>
or even
<shka_>
(defvar *handler* nil) and simply do nothing if NULL
sbodin has joined #lisp
sbodin has quit [Excess Flood]
<phoe>
shka_: the handler subsystem *is* defvar + let, so no doubt it can be done :D
<shka_>
well, yes
<phoe>
just a bit more complex than a single dynavar
<shka_>
i just propose to skip the extra crust for things that are not exceptional situations
<shka_>
and benefit from your standard CLOS spice
<phoe>
sure, the only real practical advantage there is that HANDLER-CASE and SIGNAL are already built-in so you don't need to define your own dynavar and use it
<shka_>
i am not even sure if this is an advantage honestly
sbodin has joined #lisp
sbodin has quit [Excess Flood]
<phoe>
one custom symbol less to import; some people like it this way
<shka_>
because dynavars are totally part of protocols
<shka_>
and i kinda like my protocols explicit
<dbotton>
is seems a bit more readable then a dynavar but that could be because I am not used to seeing it
terpri_ has quit [Read error: Connection reset by peer]
<shka_>
arguably one of the most important features of lisp languages
dzaster has joined #lisp
smazga has quit [Ping timeout: 260 seconds]
sbodin has joined #lisp
sbodin has quit [Excess Flood]
<dbotton>
I think this shows the colossal failure of trying to translate c/ada/pascal etc -> lisp they are way to different
arbv has joined #lisp
shifty has joined #lisp
<shka_>
hmmm
<dbotton>
I still keep adding notes to myself, but there is clearly reason no one has done a simple chart like between c <-> pascal etc
dzaster has left #lisp [#lisp]
jonatack has quit [Quit: jonatack]
sbodin has joined #lisp
sbodin has quit [Excess Flood]
jonatack has joined #lisp
sbodin has joined #lisp
sbodin has quit [Excess Flood]
<shka_>
dbotton: my tip is following
<shka_>
cl is actually not that difficult to learn, and the only major obstacle is that it is different
epony has quit [Quit: so much fun, that.. more tests are needed - documentation is the best for irc]
<shka_>
however, cl fundamentally has not-that-many features
sbodin has joined #lisp
sbodin has quit [Excess Flood]
<dbotton>
It isn't that I see, you first though have to dump everything you ever learned
<shka_>
secondly, features usually work together really well
<shka_>
thirdly, it is actually coherently designed language
epony has joined #lisp
<shka_>
so the learning curve has large delta near the start
<shka_>
but it flattens quickly
<phoe>
dbotton: you can learn lisp in one day
sbodin has joined #lisp
sbodin has quit [Excess Flood]
<shka_>
and then it really is a normal, well designed, pleasant language
<phoe>
unless you know C or C++ or Java or any other similar language
<dbotton>
lol
<phoe>
because then it is three days
<dbotton>
I obviously am getting the basics, but mastery like all things takes time, and changing the pattern of software design is the more difficult part
<dbotton>
that does not happen in a day
<shka_>
i am sleepy
<shka_>
good night
<phoe>
yes, as I said, it happens in three days
<phoe>
shka_: good night
<dbotton>
thank you shka_
<dbotton>
appreciated
<dbotton>
_death "I actually think C++ is ideal only for programmers without any ethics." ..... ugh....
smazga has joined #lisp
<phoe>
Naggum Content™
sbodin has joined #lisp
sbodin has quit [Excess Flood]
sbodin has joined #lisp
sbodin has quit [Excess Flood]
<dbotton>
This has been one of those moments between those two posts and today to realize that I just flew to a foreign land and foreign customs and "patients grass hopper" said to me by some ancients many times
<shka_>
naggum is one of the best programming trolls
<shka_>
or was
sbodin has joined #lisp
sbodin has quit [Excess Flood]
shifty has quit [Ping timeout: 246 seconds]
<dbotton>
i guess someone with a name - nag them would be
<dbotton>
he is not around anymore?
<p_l>
phoe: Scheme is literally, at its base, a language you're supposed to learn in one university lecture
<MichaelRaskin>
Not all revision counts are suitable for that, though
sbodin has joined #lisp
sbodin has quit [Excess Flood]
<phoe>
dbotton: he is not around anymore, correct
<p_l>
MichaelRaskin: the core language as used by SICP, that's the part, yes
<p_l>
I don't know how often 6.001 lectures happened
<p_l>
but you're given only one lecture to learn Scheme enough to follow the later ones
<MichaelRaskin>
I think SICP needs neither of the Scheme's more gotcha-heavy parts
sbodin has joined #lisp
sbodin has quit [Excess Flood]
<dbotton>
Have to go teach, thank you all for the help
<phoe>
good luck
dbotton has quit [Remote host closed the connection]
sbodin has joined #lisp
sbodin has quit [Excess Flood]
loli has quit [Quit: WeeChat 2.9]
shka_ has quit [Ping timeout: 258 seconds]
smazga has quit [Ping timeout: 260 seconds]
loli has joined #lisp
smazga has joined #lisp
shikamaru has joined #lisp
shikamaru has quit [Client Quit]
ealfonso has joined #lisp
smazga has quit [Ping timeout: 272 seconds]
ealfonso has quit [Remote host closed the connection]
dbotton has joined #lisp
daphnis has joined #lisp
dbotton_ has quit [Ping timeout: 264 seconds]
daphnis has quit [Ping timeout: 272 seconds]
aartaka has quit [Ping timeout: 264 seconds]
ealfonso has joined #lisp
smazga has joined #lisp
smazga has quit [Ping timeout: 260 seconds]
daphnis has joined #lisp
pve has quit [Quit: leaving]
daphnis has quit [Ping timeout: 264 seconds]
JessicaPurple has quit [Quit: Leaving]
MichaelRaskin has left #lisp [#lisp]
smazga has joined #lisp
bitmapper has joined #lisp
amb007 has quit [Ping timeout: 240 seconds]
smazga has quit [Ping timeout: 240 seconds]
Nilby has joined #lisp
space_otter has joined #lisp
Nilby has quit [Read error: Connection reset by peer]
elflng has quit [Ping timeout: 240 seconds]
elflng has joined #lisp
Lord_of_Life has quit [Read error: Connection reset by peer]
Oladon has quit [Quit: Leaving.]
Lord_of_Life has joined #lisp
Lord_of_Life has quit [Changing host]
Lord_of_Life has joined #lisp
ealfonso has quit [Ping timeout: 260 seconds]
Oladon has joined #lisp
gaqwas has quit [Ping timeout: 260 seconds]
smazga has joined #lisp
smazga has quit [Ping timeout: 240 seconds]
Inline has quit [Ping timeout: 272 seconds]
dbotton has quit [Read error: Connection reset by peer]
daphnis has joined #lisp
cer0_ has joined #lisp
dbotton has joined #lisp
cer0 has quit [Ping timeout: 265 seconds]
cer0_ is now known as cer0
joast has joined #lisp
smazga has joined #lisp
cer0 has quit [Client Quit]
dbotton_ has joined #lisp
smazga has quit [Ping timeout: 260 seconds]
dbotton has quit [Ping timeout: 240 seconds]
Jeanne-Kamikaze has quit [Ping timeout: 272 seconds]
karstensrage has joined #lisp
karstensrage is now known as Guest44653
dbotton_ has quit [Read error: Network is unreachable]
dbotton has joined #lisp
Guest44653 has left #lisp ["Leaving"]
daphnis has quit [Ping timeout: 260 seconds]
smazga has joined #lisp
Nilby has joined #lisp
dbotton has quit [Ping timeout: 260 seconds]
smazga has quit [Ping timeout: 240 seconds]
Jeanne-Kamikaze has joined #lisp
frgo has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
frgo has joined #lisp
amb007 has quit [Read error: Connection reset by peer]