doanyway has quit [Remote host closed the connection]
pierpal has joined #lisp
fikka has joined #lisp
<MichaelRaskin>
Does this format even contain anything below seconds?
yangby has joined #lisp
mathZ has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
warweasle has joined #lisp
yangby has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
Kundry_W_ has quit [Remote host closed the connection]
yangby has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
clintm has quit [Remote host closed the connection]
yangby has quit [Quit: Go out for a walk and buy a drink.]
markong has quit [Ping timeout: 264 seconds]
<Bike>
doesn't look like it. so nanoseconds just gives it a scaling factor, easy
Kundry_Wag has joined #lisp
<MichaelRaskin>
Of course, nanoseconds eat quite a bit of bits. But 64-bit number should still be able to represent entire 21st century. And 22nd too, if unsigned
<Bike>
that's enough centuries for anybody.
schjetne has joined #lisp
JuanDaugherty has joined #lisp
<MichaelRaskin>
So said Mayas; look at all the panic when their notation ran out.
Kundry_Wag has quit [Ping timeout: 248 seconds]
doanyway has joined #lisp
Kundry_Wag has joined #lisp
<Bike>
it didn't run out, just had to go to the next highest digit
Kundry_W_ has joined #lisp
<MichaelRaskin>
That's true, but that digits seems to be underspecified enough
<MichaelRaskin>
I mean, Unix time also doesn't run out in 2038, it's just that some systems store it in a way with not enough space for the next digit
<Bike>
well, they should have more bits for the next b'ak'tun
Kundry_Wag has quit [Ping timeout: 240 seconds]
damke_ has joined #lisp
d4ryus1 has joined #lisp
damke has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 240 seconds]
wlemuel has joined #lisp
d4ryus has quit [Ping timeout: 255 seconds]
FreeBirdLjj has joined #lisp
energizer has quit [Quit: Leaving]
pierpa has joined #lisp
fikka has joined #lisp
t0adst00l has quit [Ping timeout: 255 seconds]
fikka has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
schjetne has quit [Ping timeout: 268 seconds]
<Fare>
MichaelRaskin, the problem with nanosecond encoding of something defined up to one-second adjustments is... what happen at leap seconds?
<Fare>
(That said... it's the time encoding I use in Gerbil's clan/utils/date.ss so who am I to cast any stone?)
wlemuel has quit [Quit: My Baby has gone to sleep. ZZZzzz…]
wlemuel has joined #lisp
schjetne has joined #lisp
sz0 has quit [Quit: Connection closed for inactivity]
FreeBirdLjj has quit [Remote host closed the connection]
warweasle has quit [Quit: Leaving]
Kundry_W_ has quit [Remote host closed the connection]
schjetne has quit [Ping timeout: 256 seconds]
Kundry_W_ has joined #lisp
Kundry_W_ has quit [Client Quit]
damke_ has quit [Ping timeout: 264 seconds]
dddddd has quit [Remote host closed the connection]
damke_ has joined #lisp
foojin has quit [Quit: leaving]
amerlyq has joined #lisp
sz0 has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
amerlyq has quit [Quit: Quit]
eli_oat has joined #lisp
arescorpio has joined #lisp
nika has joined #lisp
schjetne has joined #lisp
schjetne has quit [Ping timeout: 260 seconds]
jason_m has quit [Quit: Leaving]
fikka has joined #lisp
wlemuel has quit [Quit: My Baby has gone to sleep. ZZZzzz…]
fikka has quit [Ping timeout: 260 seconds]
ChrisOei has quit [Quit: ChrisOei]
fikka has joined #lisp
Josh_2 has quit [Remote host closed the connection]
sauvin has quit [Ping timeout: 264 seconds]
sauvin_ has joined #lisp
Arcaelyx has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 240 seconds]
schjetne has joined #lisp
fikka has joined #lisp
wlemuel has joined #lisp
doanyway has quit [Remote host closed the connection]
arescorpio has quit [Quit: Leaving.]
Pixel_Outlaw has quit [Quit: Leaving]
Arcaelyx has joined #lisp
schjetne has quit [Ping timeout: 240 seconds]
sauvin_ is now known as Sauvin
Arcaelyx has quit [Read error: Connection reset by peer]
Arcaelyx has joined #lisp
Arcaelyx has quit [Read error: Connection reset by peer]
<beach>
Good morning everyone!
varjag has joined #lisp
<iqubic>
Morning Beach.
Arcaelyx_ has joined #lisp
sjl has joined #lisp
igemnace has joined #lisp
sunshavi has joined #lisp
<theemacsshibe[m]>
afternoon, beach
hjek has quit [Ping timeout: 256 seconds]
varjag has quit [Ping timeout: 260 seconds]
shka_ has joined #lisp
pierpa has quit [Quit: Page closed]
schoppenhauer has quit [Ping timeout: 240 seconds]
schoppenhauer has joined #lisp
eli_oat has quit [Quit: Leaving.]
schjetne has joined #lisp
doanyway has joined #lisp
wlemuel has quit [Quit: My Baby has gone to sleep. ZZZzzz…]
schjetne has quit [Ping timeout: 240 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
pierpal has quit [Read error: Connection reset by peer]
terpri has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
schjetne has joined #lisp
pierpal has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
<White_Flame>
the WHEN passes if there are no NILs in the lisp
<White_Flame>
*list
<loke>
Ah yes. of course.
<White_Flame>
so '(1 2 3 4 5) will pass, '(1 2 nil 4 5) will fail
<loke>
If all elements in the list are empty sequences.
<White_Flame>
of course, there would be a few ways to collapse that lambda to make it shorter
<loke>
No wait... it counts if _any_ elements are nil
<White_Flame>
and instead of count, do a simpler exists check
<loke>
so it's equivalent to (some #'null X)
<White_Flame>
ah, right
<loke>
No wait
<White_Flame>
it's still not a simple UNLESS
<loke>
the opposite
<White_Flame>
can you tell from the context what it's trying to do semantically?
<loke>
It contains a list of lists of poitns to be plotted in a graph
<loke>
;; Compute points to plot for each element of FUN. ;; If no plottable points are found, return immediately from $PLOT2D.
<White_Flame>
ok, so the WHEN is an abort clause
<White_Flame>
if it's a list of NILs, or empty, bail
<White_Flame>
well, if it's a list of generalize boolean falses, or empty :-P
<loke>
Ok, so it's (every #'null LISTS)
<loke>
Maxima is really old code, and it's still maintained to support every Lis under the sun. They still maintain GCL compatibility.
<loke>
Perhaps some implementation doesn't support #'IDENTITY
<aeth>
seems like you could make that more efficient
damke has joined #lisp
wlemuel has joined #lisp
fikka has joined #lisp
iqubic` has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
wooden_ has joined #lisp
ukari has joined #lisp
iqubic has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 264 seconds]
Karl_Dscc has quit [Remote host closed the connection]
vlatkoB has joined #lisp
Fare has quit [Ping timeout: 240 seconds]
megalography has joined #lisp
schjetne has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
stardiviner has joined #lisp
stardiviner has quit [Client Quit]
stardiviner has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
hvxgr has quit [Ping timeout: 264 seconds]
shka_ has quit [Ping timeout: 240 seconds]
megalography has left #lisp [#lisp]
Quetzal2 has joined #lisp
<blep-on-external>
i've finally hit the point where i can write cl-who macros without making mistakes c:
<blep-on-external>
maybe i should generalise my macros now
ealfonso has joined #lisp
<MichaelRaskin>
Fare: trust me, the problem also exists when you just use the number of seconds
stardiviner has quit [Quit: WeeChat 2.1]
<ealfonso>
I was told by someone here that by using cl-json instead of jonathan, I could avoid the hack of adding '("application" "json") to drakma:*text-content-types*... does that person know what cl-json method I should be using?
<beach>
dim: Yes, I follow it pretty closely. Especially page 13 where they explain how the expectations are violated in various situations.
<beach>
dim: The authors are very experience programmers and very experienced Lispers. I find it insulting when some much less experienced person claims that their advice is without merit.
<DemolitionMan>
beach: stylistic? is that a matter of fashion ?
<dim>
beach: +1
<beach>
DemolitionMan: Are you trying to be witty?
<dim>
DemolitionMan: read the document I've linked and then decide for yourself, the paper is very good at explaining why it's important
<DemolitionMan>
dim: I read it long ago
<shka>
i like beach style guide
python47` has joined #lisp
<beach>
DemolitionMan: Anyway, I take your remark to mean that you do not want such feedback.
<shka>
it is reasonable short, at least
<DemolitionMan>
beach: thanks
<dim>
there was another document that I liked very much about programming style, from the Erlang community, which insisted on showing your intentions
makomo has joined #lisp
<dim>
in the example they gave they ended up with mostly one-line function bodies and very long function names, and reading the code, it was pretty obvious what they wanted to happen
<beach>
Sounds like good advice.
<dim>
so my main programming style focus is “make your intention obvious”
<jackdaniel>
you can embed executable CL (with some limitations, JSCL is incomplete) in your blogpost
<beach>
Anyway, I find it, let's say "interesting" when people ask for help with some code, i.e. they want others to read, understand, and help fix it. But then they can't be bothered to respect even the most basic conventions about code layout and other stylistic rules.
<jackdaniel>
to be fair many newcomers fix the indentation and patiently wait for further advices
<beach>
dim: Several indentation problems: Body of MAKE-ARRAY in the first example. Argument of POSSIBLE-VALUES.
<flip214>
dim: find-position-with-fewest-possibilities: how about using (ITERATE ... (MINIMIZE ...)?) Not sure whether LOOP has MINIMIZE, too.
<shka>
hmmm, norvig guide is very informative
<beach>
dim: Useless newline after LOOP, probably because you weren't using SLIME-INDENTATION at the time.
<beach>
dim: The line starting with IN in the LOOP should be indented to show that it is not a separate clause. SLIME-INDENTATION will do that.
<beach>
dim: Use of (+ ... 1) and (- ... 1) should be replaced by 1+ and 1-. The rule is to use the most specific construct that will work.
schweers has joined #lisp
<shka>
redirecting trace-output to file looks like usefull trick
<beach>
dim: I personally never use WITH-SLOTS because I consider slots to be an implementation detail. I use WITH-ACCESSORS instead.
<beach>
dim: I also don't put blank lines in the middle of function bodies.
<beach>
dim: The naming convention for predicates in Common Lisp is to end the name with `P' rather than `?' as in VALUE-IS-SET-P.
<dim>
beach: normally the indentation is all done with Emacs/SLIME, I rarely overrule it… in the case of the article, I wonder how much of it is a rendering issue
nowhere_man has quit [Remote host closed the connection]
<beach>
It could be, especially if you allow Emacs to use TABs.
jmercouris has joined #lisp
nowhere_man has joined #lisp
<beach>
dim: There is a flag you can set in Emacs so that it always uses spaces.
shrdlu68 has quit [Ping timeout: 240 seconds]
<beach>
dim: The LOOP problem is very likely the lack of SLIME-INDENTATION though.
<dim>
thanks for spending time on my article by all means!
<beach>
Anytime.
<dim>
beach: using #'1-, I can't read that easily still, so I avoid it
<beach>
The argument to POSSIBLE-VALUES seems to be a TAB problem.
<beach>
dim: I see. But here is the reason for those...
<dim>
I liked what pjb had to say about that, that 1+ and 1- are very good when used as function arguments, not so much for computation
<dim>
with-accessors, I'll have a look at that
<dim>
I seldom use with-slots in “real” code, but it sometimes comes in handy
<beach>
dim: If you have (- <very-long-expression> 1) you don't see that it is 1 that is subtracted until much later. So the person reading the code must "push that on the stack" until the second argument of #'- is available. If #'1- is used instead, no additional memory is needed on the part of the person reading the code.
<dim>
good point
<dim>
nowadays I've found myself writing (+ -1 ...) more and more often
<beach>
The same thing is true for many of the other instances of the rule "use the most specific construct that will work".
<dim>
I find it so much easier to then hack around when you have off-by-one bugs or other adjustments to make
<beach>
I can see that.
<dim>
I feel a little stupid each time I write (+ -1...), but I thank myself each time I have to revisit such written code
angavrilov has joined #lisp
<beach>
dim: Interestingly, that particular version has the same property that I just mentioned about #'1-.
<beach>
dim: I.e. once you get to the ... part, you already know that 1 is going to be subtracted.
<dim>
it does
<dim>
except that I'm never sure what happens with 1-
<beach>
You'll learn.
<dim>
like #'/, I find it hard to read, so I'd rather use truncate
<beach>
Many non-native speakers of English find the use of UNLESS problematic. That was the case for me in the beginning.
<beach>
But it is well worth getting used to.
<LdBeth>
then you have #'COMPOSE to do tacit programming to avoid nesting
shrdlu68 has quit [Ping timeout: 260 seconds]
<dim>
unless has a special place in my mind, because I used to despise those forms in perl and I really like them in lisp, and I did need some thinking to realize that Perl allowing them after the statement is what I don't like
<dim>
do stuff or die "trying";
<dim>
(unless ... (do ...)) ; that I can read easily ;-)
shrdlu68 has joined #lisp
<beach>
dim: Oh, yes, I understand completely.
<dim>
LdBeth: I don't much care about avoiding nesting, let's optimize for code READING, nesting is a good hint; and if you have too much nesting anyway then just split the code into more “units” (functions, usually)
<beach>
dim: That's making it hard to read BY DESIGN.
<dim>
yeah well that's Perl, what did you expect? ;-)
<LdBeth>
That’s why I think LOOP macro improves readability
<shka>
well, it is difficult to build style by solo programming
<shka>
and honestly, that's what i do in the lisp land
<beach>
shka: Bah, just do what I do; submit your code here for people to read. You will get ample feedback that way.
<dim>
hehe
<dim>
it's easy to get reviews on code style on a 10 lines snippet
ealfonso has quit [Ping timeout: 255 seconds]
<dim>
it's not as easy to get architecture feedback on complete systems
<dim>
which is fine
<beach>
True 'dat.
<dim>
I'm just more interested in the latter
<dim>
in the past by mentioning problems I had with some pgloader code I got enough incentive to rewrite subsystems entirely, which is good already
<beach>
shka: Yes, that's part of the learning experience. Same thing when learning a foreign language. The most efficient way is to start talking and writing, being ridiculed, and then using that feedback to improve.
foojin has joined #lisp
<beach>
dim: Norvig and Pitman would disagree with (IF ROW...
igemnace has quit [Quit: WeeChat 2.1]
<beach>
dim: Same with (WHEN PG-VECTOR-ROW...
<beach>
dim: And you LOOP body is still badly indented, suggesting you are still not using SLIME-INDENTATION.
<beach>
dim: You can save one level of indentation by replacing (loop for ... (let ((<var> ...)) by (loop for ... for <var> ... ...
<beach>
dim: Useless PROGNs in COND clauses. COND has an implicit PROGN in each clause.
scymtym has quit [Ping timeout: 256 seconds]
<LdBeth>
A static syntax checker would be helpful
<beach>
LdBeth: Sounds like you found yourself a good project.
<dim>
beach: I tend to use useless progn for indentation hints in Emacs :/
<dim>
I'll need to re-read the style's guide then
<beach>
dim: But you don't do it consistently.
scymtym has joined #lisp
<beach>
dim: So that makes the person reading your code think that there is some subtle difference between different clauses. Perhaps you grep for progn in some other tool, or perhaps you have a code walker that treats the PROGN clauses differently.
energizer has quit [Quit: Leaving]
<dim>
the pgloader project is old enough that my style changed in the way I guess
<beach>
Sure, but you see what I am saying, right?
<dim>
yeah
<dim>
I'm not sure I want to fix Emacs/SLIME display of cond clauses so that I don't have to use progn to get the visuals that help me though...
<dim>
in that case, progn doesn't bring anything on the table I'm afraid
python47` has quit [Ping timeout: 240 seconds]
fourier has joined #lisp
shrdlu68 has quit [Ping timeout: 248 seconds]
<beach>
dim: Also, I use #.(format nil ...) for documentation strings that span several lines. That way I can use the ~@ FORMAT directive so that I can align all lines with the first.
shrdlu68 has joined #lisp
<beach>
dim: I find it very distracting to have documentation strings in column 0, and in fact, Emacs doesn't handle that situation very well either.
<beach>
dim: Oh, and you can save yet another level of indentation by replacing (LET ((LENGTH ...) (STRING ...)) (LOOP FOR... with (LOOP WITH LENGTH = WITH STRING = FOR.
<loke>
beach: That graph I shared really shows that we need xrender for drawing lines
<loke>
Another alternative is to write a new backend that uses Cairo
<beach>
loke: I think we should use xrender for everything, if possible.
<loke>
beach: Yeah
<beach>
That way, we will be closer to what other backends such as OpenGL would do.
<loke>
I have had a hard time finding an example (in C, even) how to draw a simple polygon using xrender
<loke>
It was easier to find one for text, which is where I started when I did the new text renderer.
<beach>
Yeah, it is very poorly documented. Adding a CLX layer on top makes it even harder.
<beach>
Hell, I can't even understand the protocol specification, even though I have tried many times.
<loke>
That's fine for me acutally. I had to dig into that when I was doing text with xrender.
<loke>
It's not that complictaed.
<beach>
Good. Then it would be great to make the CLX documentation independent of the xlib and protocol specifications.
<loke>
beach: We'd need to use Cairo for that then
<beach>
Why?
<loke>
beach: Goign to cairo pretty much means implementing a new backend.
<beach>
Why do we need Cairo?
<loke>
Because Xrender is still very much CLX level
<beach>
Sure. I just meant the CLX documentation.
<loke>
So if you want to be independnt on CLX, we need a higher level API, and that's Cairo.
<beach>
No, no.
<beach>
Not independent of CLX.
<beach>
I want the CLX documentation to be self contained.
<beach>
Not requiring the reader to understand C xlib or the protocol specification.
<loke>
beach: Hmm...
<beach>
I totally hate documentation that requires the reader to read and understand some other documentation and to do some mental translation between them.
<loke>
I'd really prefer to see a cairo backend actually. Cairo has so much stuff that I'd like to be able to use, instead of having to rebuild it from scratch, poorly.
<loke>
beach: Right, but you need to be able to do circles, ellipses, bezier curves
<beach>
Those are not too hard either.
<loke>
The paper addresses the issue of ensuring that the stroke width is consistent
<beach>
I see.
<loke>
That's not entirely trivial
<beach>
I can believe that.
<loke>
(at least if you want it to be fast)
<loke>
This is a problem for my graphs as well, since just drawing a thick line using a rectngle will create very ugly effects near the joins.
fourier has quit [Ping timeout: 240 seconds]
<loke>
The algorithm in the paper seems to do the right thing.
<beach>
OK, good. Keep reading, then!!! :)
<loke>
I am, but even though I do understand a bit of sthis stuff (having done grasterised graphics effects since the 80's) but I really would like to be able to leverage existing libraries. :-)
<beach>
I fully understand.
<loke>
beach: I'd really love it if someone else could implement this thing. :-)
<DemolitionMan>
beach: solved!
<beach>
loke: You may be out of luck.
<beach>
DemolitionMan: Congratulations.
Satou has quit [Quit: Cya soon guys!]
<DemolitionMan>
beach: not ar all
shrdlu68 has quit [Ping timeout: 240 seconds]
shrdlu68 has joined #lisp
<DemolitionMan>
beach: not at all, only an half joy due to poor style of my programs
Kaisyu has quit [Quit: Connection closed for inactivity]
<beach>
DemolitionMan: The purpose was not to give you a hard time, but to give you a chance to improve.
<DemolitionMan>
beach: this wasn't a complain, I know, I know
<DemolitionMan>
beach: anyway, a lot of people that wrote common lisp code for packages (even in quicklisp repository) are worse than me
damke_ has joined #lisp
damke has quit [Ping timeout: 264 seconds]
<beach>
DemolitionMan: Sure, that is entirely possible. But that's no excuse to rest on your laurels.
<DemolitionMan>
beach: yes, definitely - the problem is the time
shrdlu68 has quit [Ping timeout: 240 seconds]
<DemolitionMan>
beach: you know, programs have to be ready before specifications, most of the times :)
shrdlu68 has joined #lisp
<DemolitionMan>
beach: having more time, it would be nice to talk with you about the code I posted... Seriously
<beach>
DemolitionMan: Whenever you want (or nearly so).
<DemolitionMan>
beach: ok
<DemolitionMan>
beach: do you think design patterns are useful? Can you suggest a common lisp book on patterns?
<LdBeth>
Any recommendations on plain text typesetting tools?
pjb has joined #lisp
<schjetne>
Maybe if there was a need to rapidly on-board a large number of Common Lisp developers there would be a market for such a book.
<DemolitionMan>
jdz: thanks!
<DemolitionMan>
jdz: are design patterns more suited for such programming languages that lacks some features?
<DemolitionMan>
jdz: like higher order functions?
fikka has quit [Ping timeout: 260 seconds]
<LdBeth>
I can’t tell a few “modern” programming languages that doesn’t support higher old functions yet.
<DemolitionMan>
c
<LdBeth>
You have C++
<DemolitionMan>
which is not c
<LdBeth>
Which is usually considered as successor of C
<aeth>
tell that to Linus
playful-owl has joined #lisp
<DemolitionMan>
LdBeth: c++ is more than a monster of its own than a successor
<edgar-rft>
Common Lisp as a "programmable programming language" is a language to *write* programming languages. Therefore Common Lisp *has* no design patterns, instead you *write* design patterns with it. What kind of these design patterns that may be is *your* choice. That's a major difference to other programming languages.
light2yellow has joined #lisp
<theemacsshibe[m]>
> Any recommendations on plain text typesetting tools?
<theemacsshibe[m]>
TeX?
<theemacsshibe[m]>
Markdown? Restructured Text?
<edgar-rft>
cl:format
<LdBeth>
no-defun-allowed: I just wonder if I can have something other than troff
<theemacsshibe[m]>
edgar-rft makes a good point
<theemacsshibe[m]>
I'd go for TeX then.
fikka has joined #lisp
<LdBeth>
TeX doesn’t make plain text outputs
<theemacsshibe[m]>
Oh, I see.
<theemacsshibe[m]>
cl:format doesn't sound too bad then.
<shrdlu68>
"c++ is to C as lung cancer is to lung" - from the Unix-haters handbook.
JuanDaugherty has quit [Quit: Ex Chat]
<DemolitionMan>
shrdlu68: ehehe
<DemolitionMan>
shrdlu68: are you still involved with colored spheres, cones, cubes and so on?
<theemacsshibe[m]>
Rust is to C as JavaScript is to Java.
<shrdlu68>
DemolitionMan: I just picked the name coz I like that era of AI. Shoulda gone with LogicTheorist instead.
<theemacsshibe[m]>
Actually no, Java is already pretty bad.
<LdBeth>
Well, then, I admit C++ sucks and don’t want to spend much time talk about it. And it might be my fault to bring that into discussion since I had some sort of foreseeing the result.
<DemolitionMan>
shrdlu68: :) nice
Lycurgus has joined #lisp
<DemolitionMan>
LdBeth: I programmed c++ for a long time :) don't worry
* theemacsshibe[m]
makes an AbstractLanguageComparisonJokeFactory
varjagg has joined #lisp
<DemolitionMan>
theemacsshibe[m]: you mean the myAbstractLanguageComparisonJokeFactory
fikka has quit [Ping timeout: 255 seconds]
<theemacsshibe[m]>
Of course. How could I forget?
<DemolitionMan>
theemacsshibe[m]: why do they use "my" on everything?
<DemolitionMan>
is that a sort of fetishism?
<theemacsshibe[m]>
I'm gonna port that and make a Joke<Comparison<ProgrammingLanguage>> iterator now.
<LdBeth>
Both Java and JS are heavily inspired by lisp
<theemacsshibe[m]>
Cause the default implementation sucks probably.
<theemacsshibe[m]>
That doesn't mean they can't be bad.
<LdBeth>
And Lisp is not that perfect
<shrdlu68>
Blasphemy!
<DemolitionMan>
theemacsshibe[m]: fetishist!
<LdBeth>
GG
<theemacsshibe[m]>
Who's got more brackets now, DemolitionMan?
<DemolitionMan>
as doctor who's archenemies should say: "Do not blaspheme!"
<DemolitionMan>
sorry
varjagg has quit [Ping timeout: 240 seconds]
<LdBeth>
We can definitely change brackets into, emm, something like two lambda symbols in CL
<DemolitionMan>
as doctor who's archenemies should say: "Do not swear!"
<theemacsshibe[m]>
A friend made Ñ-expressions.
<theemacsshibe[m]>
( is &, ) is #
<theemacsshibe[m]>
& and \ come to think of it
<LdBeth>
あ-expressions
<theemacsshibe[m]>
Stupid markdown. & and *
<theemacsshibe[m]>
=ω=expressions
fikka has joined #lisp
<theemacsshibe[m]>
The less bad Emojiscript.
python476 has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
<flip214>
no need for all that. ASCII plus unicode has, what, about 20 kinds of parenthesis pairs? <> () [] {} «» ... enough to differentiate between LET and LAMBDA and PROGN and IF and COND and ...
scymtym has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
``Erik has joined #lisp
dddddd has joined #lisp
<theemacsshibe[m]>
I'm gonna write some Rust. Here goes.
SaganMan has quit [Read error: Connection reset by peer]
fikka has joined #lisp
hvxgr has joined #lisp
<edgar-rft>
theemacsshibe[m], you could write some rust-converter in CL
<jackdaniel>
please skip the offtopic (or move it to ##lisp which is better suited for lisp-in-spirit discussions)
<theemacsshibe[m]>
I'm done with the joke. Sorry.
<jackdaniel>
sure, thanks
* theemacsshibe[m]
walks off the #lisp Bad Joke Night stage and sits back down blushing
megalography has joined #lisp
<theemacsshibe[m]>
How do implementations of CL make their hash-tables? Binary trees seem like a simple solution but I'm sure there's more magic in it.
fikka has joined #lisp
<theemacsshibe[m]>
I can't see much about IRC operators and stuff on Matrix, so what do you do around here jackdaniel? Just curious.
<jackdaniel>
it varies. I suspect ABCL uses whatever Java provides, SBCL has implementation written in Common Lisp, ECL has implementation written in C
<jackdaniel>
I don't know what Matrix is in this context
pierpal has quit [Read error: Connection reset by peer]
<jackdaniel>
I'm CL programmer and I hang with kindred spirits
pierpal has joined #lisp
<jackdaniel>
if you wonder whenever I'm channel operator it happens that I am (though I think I've never used the privilige)
<theemacsshibe[m]>
Oh um, matrix is like an overengineered IRC clone
<pjb>
DemolitionMan: said otherwise, lisp has had design patterns (done correctly) since 1964, while people working with other programming languages had to work 30 years (with teachers, students, "research", PhD, books, editors, and so on, a whole cottage industry, working to archieve… nothing (well, something that was known since 1964, good work guys!)).
<pjb>
DemolitionMan: of course, in our capitalistic system, all this increases the GDP, so everybody is happy. In the meantime, we're still waitting on our flying "cars", and Moon and Mars bases…
<pjb>
theemacsshibe[m]: I notice that org-mode has better -to-pdf results (since it goes thru LaTeX, the output is nicer).
johnvonneumann_ has joined #lisp
<schweers>
pjb, theemacsshibe[m]: Org Mode can export to all sorts of formats.
<DemolitionMan>
pjb: :)
<pjb>
theemacsshibe[m]: I like reStructuredText, but when you write it to generate PDF, you have to add a lot of not-nice "tagging". So I think I'm converting to org-mode.
shrdlu68 has quit [Ping timeout: 248 seconds]
shrdlu68 has joined #lisp
shrdlu68 has quit [Client Quit]
<pjb>
theemacsshibe[m]: myThing comes from perl (AFAICS). It's a convention used to denote local variables.
<p_l>
I have seen mThing in Java
<p_l>
for class member private variables
Guest26840 has quit [Ping timeout: 276 seconds]
<pjb>
yes, this comes from C++, where variable members are often prefix with m (or sometimes _).
<pjb>
This is to avoid shadowing the members by parameters foo(int p){ _p=p; } instead of this->p=p;
<foojin>
BTW does learning design patterns give one a sort of "architectural insight" into software design?
<flip214>
schweers: pjb: pandoc can convert RST <=> org <=> Markdown etc., good enough for most uses.
<schweers>
is there a proper (i.e. academic) term for this kind of scoping?
<foojin>
I often find myself unable to come up with ways everything should fit together, even though I'm quite capable of writing and refactoring functions. Maybe that's one of the reasons I'm still stuck with fixing someone else's code.
<flip214>
foojin: did you ever solve some middle-sized problem from start to end?
<flip214>
perhaps you're just lacking overview?
<dim>
pjb: yeah, thanks to pandoc I'm using Markdown for my PDF needs nowadays
<pjb>
foojin: yes, reading the GoF book is not a bad idea. But as lisper, take it as a good exercise to write the macros corresponding to each design pattern.
<schweers>
to clarify, I mean the sort of scoping that OO languages often introduce by introducing member variables into the scope of methods. Now that I’ve written this, I realize that this is nothing more than lexical scope. So ignore my question ;)
<pjb>
dim: also, my point here is that org-mode doesn't need any external too :-)
<pjb>
schweers: well this is a good question. In CL it's solved with with-slots and with-accessors. It doesn't need to be automatic. So it probably has a name.
<schweers>
well it is basically lexical scope, but then again, OO languages often have ways to clarify which foo is meant. If `foo' is a member variable, then foo may refer to something different than this.foo. or this.that.something_other.foo
<foojin>
schweers: IMO in languages like Python, where you can just add members at runtime and have them visible, lexical scoping doesn't really cut it. I think it just uses a dict there.
<schweers>
python uses a dict, but that is supposedly(?) subject to change.
<p_l>
does python actually have a proper lexical scope?
<foojin>
flip214: I tried to do that several times but it always ends up with me finding the result too ugly to improve. Lisp macros seem like a nice solution to my problems, so I'll definitely try to write something with it.
<schweers>
p_l: as far as I know, it does, but didn’t always have it
Kevslinger has joined #lisp
* p_l
always got the feel that for supposedly hating monkey patching, python is most full of it
<foojin>
schweers: The point is, it's neither lexical, nor dynamical.
pierpal has quit [Remote host closed the connection]
<foojin>
*dynamic
<pjb>
↻foo↺ ⇽foo⇾ ⎏foo⎐ ⟃foo⟄ ⦦foo⦧ ⦨foo⦩ ⫍foo⫎ there are a lot of left/right pairs in unicode:
<pjb>
It's funny how some fonts don't have symetrical glyphs. eg.: ⬱⇶
ebrasca` is now known as ebrasca
ravi has quit [Ping timeout: 268 seconds]
* edgar-rft
wishes pjb back into the time of cuniform writing
Colleen has quit [Ping timeout: 240 seconds]
scymtym has joined #lisp
Colleen has joined #lisp
nowhere_man has quit [Remote host closed the connection]
<flip214>
pjb: +1 ;)
<flip214>
thanks for the proof.
nowhere_man has joined #lisp
ravi has joined #lisp
<flip214>
and now, please do the same with UP and DOWN, so that multi-line forms like "(PROGN" and ")" can be properly framed ;)
<pjb>
flip214: notice already that there are the vertical left/right. I used them once in C programs (with compose in emacs, to substitute for {}). ︠︡︢︣︤︥︵︶︷︸︹︺︻︼︽︾︿﹀﹁﹂﹃﹄﹇﹈
<pjb>
I mean, since a lot of C style put a single bracket on a line, using ︷ and ︸ made sense…
jmercouris has joined #lisp
Guest52421 has left #lisp [#lisp]
kolb has joined #lisp
<flip214>
don't you long for ⌌PROGN (foo)⌟
jmercouris has quit [Remote host closed the connection]
<flip214>
Or even ⏠PROGN (foo)⏡ (top|bottom TORTOISE SHELL BRACKET)
<foojin>
Given the complexity of Unicode, there should be special tools that check the source code for things like "invisible" characters.
<foojin>
It's only a matter of time before someone gets a nasty surprise past a code review.
raynold has quit [Quit: Connection closed for inactivity]
fikka has joined #lisp
orivej has joined #lisp
<pjb>
foojin: this is something you could write as a small extension to emacs. Scan buffers for homographs.
Hello_ has joined #lisp
<foojin>
pjb: And try to convince people to use Unicode only in comments.
<pjb>
Not necessarily. The source can be written by russians in cyrillic, or japaneses, or chineses.
<pjb>
You just want to check for consistency.
Lycurgus has quit [Quit: Exeunt]
<pjb>
Perhaps innоcuous can be forbidden, but write-борщ should be ok.
Satou has joined #lisp
megalography has joined #lisp
<foojin>
I still think that it has no place outside comments and string literals. It's only a small step from an agreed-upon programming language to an agreed-upon naming convention.
<foojin>
It boils down to "make it right" vs "make it work" in my opinion.
fikka has quit [Ping timeout: 248 seconds]
Murii has quit [Read error: Connection reset by peer]
fikka has joined #lisp
<schweers>
I wonder whether russian and/or asian programmers use non-english names in programming.
Fare has joined #lisp
Murii has joined #lisp
<foojin>
schweers: Of course. I tried to port an emulator written by someone like that from JS to C and found out that only clang is capable of compiling it.
rumbler31 has joined #lisp
<schweers>
because of unicode names?
<schweers>
does C allow non-ascii characters outside of comments or string literals?
<foojin>
Yep. I still haven't really touched most of his code, save for operator substitutions, so it would take a while to make it build under GCC.
<schweers>
sounds fun
<foojin>
It taught me to compile with different compilers just to see the warnings produced though.
Fare has quit [Ping timeout: 264 seconds]
EvW1 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
smokeink has joined #lisp
mejja has joined #lisp
pierpal has joined #lisp
playful-owl has quit [Quit: leaving]
Bike has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
johnvonneumann__ has joined #lisp
chens` has joined #lisp
sword``` has joined #lisp
argoneus_ has joined #lisp
pierpal has joined #lisp
ft_ has joined #lisp
krkini has joined #lisp
mikaelj_ has joined #lisp
joga_ has joined #lisp
phadthai_ has joined #lisp
mrm_ has joined #lisp
vert2_ has joined #lisp
nuxdie has joined #lisp
damke has joined #lisp
vibs29_ has joined #lisp
<pjb>
schweers: even latin-based natural language writers may have difficulties mixing their language with english-based programming languages.
ircbrowse_ has joined #lisp
mood_ has joined #lisp
inoperable_ has joined #lisp
luis` has joined #lisp
<schweers>
which is why all my code has english identifiers
fiddlerwoaroof_ has joined #lisp
<pjb>
schweers: as a French, I prefer in general using only English in my programs, to keep the consistency with the English keywords and the user identifiers.
<schweers>
same here, but german
vutral_ has joined #lisp
butterthebuddha_ has joined #lisp
<pjb>
However, there are circumstances, where it would be preferable to use native language identifiers.
spaceplu- has joined #lisp
epsyloN- has joined #lisp
johnvonneumann_ has quit [*.net *.split]
damke_ has quit [*.net *.split]
makomo has quit [*.net *.split]
chens has quit [*.net *.split]
nuxdie_ has quit [*.net *.split]
ft has quit [*.net *.split]
Naergon has quit [*.net *.split]
eschatologist has quit [*.net *.split]
edgar-rft has quit [*.net *.split]
luis has quit [*.net *.split]
vert2 has quit [*.net *.split]
vibs29 has quit [*.net *.split]
vutral has quit [*.net *.split]
borodust has quit [*.net *.split]
alandipert has quit [*.net *.split]
ircbrowse has quit [*.net *.split]
fouric has quit [*.net *.split]
drastik has quit [*.net *.split]
samebchase1 has quit [*.net *.split]
epsyloN has quit [*.net *.split]
spacepluk has quit [*.net *.split]
fiddlerwoaroof has quit [*.net *.split]
sword`` has quit [*.net *.split]
inoperable has quit [*.net *.split]
phadthai has quit [*.net *.split]
joast has quit [*.net *.split]
mood has quit [*.net *.split]
argoneus has quit [*.net *.split]
kini has quit [*.net *.split]
butterthebuddha has quit [*.net *.split]
mrm has quit [*.net *.split]
mikaelj has quit [*.net *.split]
joga has quit [*.net *.split]
vibs29_ is now known as vibs29
ft_ is now known as ft
<schweers>
although it can be problematic when people don’t know english well enough to give proper identifiers. I saw a variable once, which was supposed to hold a current value (of a measurement) which was named actual_something. In german the word „aktuell“ means „current“.
spaceplu- is now known as spacepluk
<schweers>
so you’ve got yourself a false friend there
alandipert has joined #lisp
eschatologist has joined #lisp
<pjb>
schweers: yes, like "delicious" :-)
butterthebuddha_ is now known as butterthebuddha
<schweers>
how so?
luis` has quit [Ping timeout: 240 seconds]
<pjb>
Macron said to the Austrian prime minister that his wife was delicious. But that doesn't mean exactly the same in French and in English :-)
<beach>
Heh!
<schweers>
oops
<schweers>
what might he have intended?
ravi has quit [Ping timeout: 240 seconds]
* schweers
doesn’t speak french beyond very few words.
<schweers>
weird. I restarted the lisp image, same problem. moved it to the same package and now it’s fine.
<schweers>
Which is okay in this case, as it actually belongs in the package where it is used, but still ...
fikka has joined #lisp
fikka has quit [Read error: Connection reset by peer]
<schweers>
even works before the code is loaded, which I find weird
cage_ has joined #lisp
<jdz>
schweers: before the code is loaded I bet indentation is based on the name (starts with "with-").
<schweers>
oh right, thanks
<schweers>
but still, why would it suddenly behave that way?
<schweers>
anyway, I was thinking it may be well known. I guess it’s a little tricky to debug it now.
flamebeard has quit []
v0|d has joined #lisp
iqubic`` has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
fikka has joined #lisp
Quetzal2 has joined #lisp
Oladon has quit [Quit: Leaving.]
equwal has joined #lisp
Karl_Dscc has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
Karl_Dscc has quit [Remote host closed the connection]
sjl has quit [Quit: WeeChat 1.9.1]
asarch has joined #lisp
fikka has joined #lisp
ravi has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
CrazyEddy has quit [Remote host closed the connection]
ravi has quit [Ping timeout: 276 seconds]
ravi has joined #lisp
matijja has quit [Ping timeout: 260 seconds]
Fare has joined #lisp
<ukari>
it is a good idea to use (make-symbol "name") instead of (gensym) in defmacro for a better debug experience?
<Bike>
i find it a bit confusing in the case of e.g. nested macroexpansions, where they'll have distinct symbols that look the same
<Bike>
i just pass gensym a string instead (you can do that btw)
fikka has joined #lisp
heisig has quit [Quit: Leaving]
megalography has quit [Ping timeout: 260 seconds]
<phoe>
Ukari: (gensym "SOMETHING")
<phoe>
;=> #:SOMETHING827
ravi has quit [Ping timeout: 276 seconds]
rumbler3_ has joined #lisp
<ukari>
would it have a affect on efficiency?
<Bike>
no.
<ukari>
like more memory used for store string
<Bike>
nope
<ukari>
nice
<Bike>
the compiler is going to use way more memory than your puny little macro anyway
fikka has quit [Ping timeout: 256 seconds]
<shka>
Ukari: with-gensyms my friend!
<beach>
I once had a student who used only one-letter variables, thinking it would take up too much memory otherwise.
rumbler3_ has quit [Ping timeout: 255 seconds]
wigust has joined #lisp
FareTower has joined #lisp
<phoe>
I once read about a Russian who defined a C macro `#define RETURN(x) return x; }` - including the closing brace, thinking all the closing brackets would take up too much hard disk space otherwise.
<phoe>
So his functions looked like `int foo() { RETURN(42)`
<Bike>
i wonder how much memory that would actually save
<schweers>
When I started programming (in C/C++), I used the built-in smaller integer types whenever I felt they would be enough. So my code was riddled with 8 and 16 bit ints. On the stack, no less!
Fare has quit [Ping timeout: 276 seconds]
<Bike>
if you had a thousand functions, i guess like 2 KB
<schweers>
Err, I meant, a friend of mine did this ;)
<Bike>
the pushups thing might not be bad tho
<phoe>
Bike: I need to start doing this whenever I end up in the debugger.
Hello_ has joined #lisp
syncriix has joined #lisp
<syncriix>
Hey guys, am I alowed to ask for a small favor here?
<phoe>
syncriix: ask away
equwal has quit [Ping timeout: 264 seconds]
<phoe>
the worst kind of answer you can get for asking is "no", no matter the question
<syncriix>
I have a lot of tasks to sort in emacs, like a few thousand... and I want to sort them by TODO state, Priority and alphabetic order
<syncriix>
I have found a working script on stackexchange
fikka has quit [Ping timeout: 256 seconds]
<phoe>
syncriix: #emacs might be able to help you better if you're doing org-mode
<schweers>
isn’t there even a dedicated org mode channel?
<phoe>
elisp /= Common Lisp, and this topic is about the latter
<phoe>
schweers: I am not sure
<beach>
syncriix: This channel is dedicated to Common Lisp.
<schweers>
neither am I
<phoe>
oooh, #org-mode
<phoe>
TIL
<syncriix>
Aww, there goes my programming knowledge!
megalography has joined #lisp
<phoe>
syncriix: #org-mode is something I just found that should be able to help you
<syncriix>
I will hop over to the org channel then, thankyou guys!
rippa has joined #lisp
bigos has joined #lisp
zxcvz has joined #lisp
nika has quit [Quit: Leaving...]
Naergon has joined #lisp
hajovonta has quit [Quit: hajovonta]
fikka has joined #lisp
elfmacs has joined #lisp
pierpal has joined #lisp
rumbler31 has quit [Ping timeout: 276 seconds]
rumbler31 has joined #lisp
CrazyEddy has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
chens` has quit [Remote host closed the connection]
stardiviner has quit [Quit: WeeChat 2.1]
fare__ has joined #lisp
Satou has quit [Quit: Cya soon guys!]
fraya has joined #lisp
rumbler31 has quit [Ping timeout: 260 seconds]
fraya has left #lisp [#lisp]
smokeink has quit [Ping timeout: 256 seconds]
FareTower has quit [Ping timeout: 264 seconds]
nowhere_man has joined #lisp
syncriix has left #lisp [#lisp]
fare__ has quit [Ping timeout: 276 seconds]
megalography has quit [Ping timeout: 240 seconds]
bigos has quit [Ping timeout: 265 seconds]
borodust has joined #lisp
<jeosol>
bigos?
<jeosol>
morning guys
<beach>
Hello jeosol.
bigos has joined #lisp
<jeosol>
beach, I am doing ok. Finally was able to submit my challenge abstract, waiting for reply.
<beach>
Great.
bigos has quit [Client Quit]
<jeosol>
you guys were great help in resolving a bunch of issues, code runs steady, clean, with a lot less problems.
<jeosol>
This question is probably for the web channel if there is one. I am trying to now add a front end interface. I delved into angular 4 last few days and I almost lost my mind with the unnecessary complexity. I would prefer to stay in lisp
<jeosol>
Anyone here using Shinmera's radiance
<phoe>
jeosol: I bet #shirakumo has some users
<phoe>
perhaps also Shinmera himself
varjag has joined #lisp
<jeosol>
phoe: thanks
<jeosol>
I will head there.
fare__ has joined #lisp
Khisanth has quit [Ping timeout: 264 seconds]
megalography has joined #lisp
argoneus_ is now known as argoneus
rumbler31 has joined #lisp
damke has joined #lisp
CrazyEddy has quit [Ping timeout: 260 seconds]
damke_ has quit [Ping timeout: 260 seconds]
johnvonneumann_ has joined #lisp
rumbler31 has quit [Ping timeout: 256 seconds]
johnvonneumann__ has quit [Ping timeout: 260 seconds]
fare__ has quit [Ping timeout: 260 seconds]
puchacz has quit [Quit: Konversation terminated!]
pierpal has quit [Ping timeout: 260 seconds]
Khisanth has joined #lisp
EvW1 has joined #lisp
wigust has quit [Read error: Connection reset by peer]
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]
makomo has quit [Ping timeout: 248 seconds]
rixard has quit [Quit: (exit)]
ravi has joined #lisp
nullman has quit [Ping timeout: 240 seconds]
nullman has joined #lisp
fourier has joined #lisp
Satou has joined #lisp
elfmacs has quit [Ping timeout: 260 seconds]
pierpal has joined #lisp
EvW has joined #lisp
FreeBirdLjj has joined #lisp
EvW has quit [Ping timeout: 255 seconds]
pierpal has quit [Ping timeout: 260 seconds]
ebrasca has quit [Remote host closed the connection]
<ukari>
just simply use values could not handle this condition
python476 has quit [Ping timeout: 268 seconds]
cgay has joined #lisp
<Bike>
what are you actually trying to accomplish here
<Bike>
this is a mess
<Bike>
what results do you expect? what do you get? something
schweers has quit [Ping timeout: 260 seconds]
<ukari>
the result of (test-wanna-1) is what i want to get
<ukari>
test-bug-1 don't return a nil-ship, it returns no value
<foojin>
Ukari: So you want a list with a single ship when an empty one is returned?
<ukari>
yes!
shka_ has joined #lisp
<foojin>
Ukari: Do you have a special ship just for this? With nothing to map over, there's no way to create something sensible for a more complex definition of nil-ship.
<foojin>
Ukari: You just happen to have something which always turns out the same when constructed.
Josh_2 has joined #lisp
troydm has joined #lisp
puchacz has joined #lisp
<foojin>
Ukari: So I recommend describing the actual problem instead of oversimplifying to the point of the resulting example becoming useless even under its own constraints.
<ukari>
it is my fault, i don't like the code style in test-wanna-1 due to it need to do one more step to make a single element list. so i use (or (values may-nil) single) instead and find that it don't return multiple values anymore in this code style
<ukari>
and i want to find sth like `or` but which could returns multiple values
fikka has quit [Ping timeout: 240 seconds]
<foojin>
brb
nowhere_man has quit [Ping timeout: 240 seconds]
Karl_Dscc has joined #lisp
pierpal has joined #lisp
Bindler has joined #lisp
lnostdal has joined #lisp
<shka_>
yo guys
<shka_>
is there some neat little package to handle lambda lists?
<Bike>
"handle"?
<shka_>
i want function that will, after accepting full lambda list return me list of optional arguments, key arguments, aux arguments…
<foojin>
Ukari: First of all, why do you even bother with returning values if you end up collecting them in a list anyways?
<shka_>
basic stuff
<PuercoPop>
shka_: there is parse-lambda-list in alexandria
<shka_>
oooh, cool, let me check it
<PuercoPop>
Bike also has a library IIRC but I've never used it
<ukari>
i am trying to make a generator which needs to transform "return values" in generator function to "iterator objects", something like `function* a() {return 1}; a().next()` in javascript
jmercouris has joined #lisp
dented42 has joined #lisp
<shka_>
Ukari: i did something like generators, simply made syntax like clojure loop, but i save arguments in closure on recur and instead simply jumping to begin i return value
<shka_>
then next funcall have previously saved arguments
<shka_>
after a lot of tinkering this seemed like the most elegant approach
eli_oat has joined #lisp
Tristam has quit [Remote host closed the connection]
<shka_>
PuercoPop: alexandria did the trick, thanks!
<foojin>
Ukari: That doesn't look like what you can write in JS and Python (this probably can be done with macros), but if you don't care about keeping the style, it would do just fine.
<shka_>
cl-ds:xpr is such generator
<shka_>
it will walk over tree bound to data
<shka_>
stack is just stack, obviously
<shka_>
recur and send-recur are essentially keywords made to resembled recursive calls
defunkydrummer has joined #lisp
python47` has joined #lisp
pierpal has joined #lisp
<shka_>
traverse will work like (map nil ...), to take just one value you can use cl-ds:consume-front
<shka_>
it is not perfect, obviously, but it works for me
EvW has joined #lisp
fare__ has joined #lisp
asarch has quit [Quit: Leaving]
<shka_>
Ukari: any additional questions?
CrazyEddy has joined #lisp
dented42 has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
<ukari>
no
Kundry_Wag has joined #lisp
<shka_>
ok, cool
dented42 has quit [Client Quit]
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
Kundry_Wag has quit [Read error: Connection reset by peer]
pierpal has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
pierpal has joined #lisp
damke has quit [Ping timeout: 268 seconds]
damke has joined #lisp
dented42 has joined #lisp
hjek has joined #lisp
pfdietz2 has quit [Ping timeout: 240 seconds]
Kundry_W_ has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Ping timeout: 260 seconds]
nowhere_man has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
cage_ has quit [Quit: Leaving]
hvxgr has quit [Quit: leaving]
Kundry_W_ has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
aindilis has quit [Read error: Connection reset by peer]
MichaelRaskin has joined #lisp
mflem has joined #lisp
pierpal has quit [Ping timeout: 255 seconds]
makomo has joined #lisp
<flip214>
whoever had the idea for this symbol: hooray.
vlatkoB has quit [Remote host closed the connection]
vlatkoB has joined #lisp
nowhere_man has quit [Ping timeout: 276 seconds]
<dlowe>
it's to punish those without the virtuousness of tab completion
oleo has joined #lisp
<defunkydrummer>
flip214: i prefer verbose names; and BTW deprecated-function-style-warning-enable-asdf-binary-locations-compatibility-notified-p is still short for Java standards, comparatively
lnostdal has quit [Ping timeout: 240 seconds]
<defunkydrummer>
flip214: still much better than Java's InternalFrameInternalFrameTitlePaneInternalFrameTitlePaneMaximizeButtonWindowNotFocusedState
Kundry_Wag has quit [Remote host closed the connection]
<jackdaniel>
if commonQt works for you and McCLIM doesn't – go for it. I don't think there is much merit in picking wrong tools just for a sake of being lispy
Kundry_Wag has joined #lisp
dilated_dinosaur has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 260 seconds]
pfdietz2 has joined #lisp
klm2is has joined #lisp
<sunshavi>
jackdaniel: actually I am trying to check both (commonQt, and McCLIM). commonQt seems quite fine for this kind of layout. I just want to invest a couple of hours and see if I could come with something similar to that with McCLIM.
Mutex7 has joined #lisp
pierpal has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
pierpal has quit [Ping timeout: 260 seconds]
dilated_dinosaur has joined #lisp
klm2is has quit [Quit: Leaving]
fikka has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
<cantor>
I am getting really tired of all the downsides of Clojure, should I switch to Common Lisp? I am concerned about the enormity of the language and the situation around the build/packaging ecosystem
scottj has quit [Quit: leaving]
Kundry_Wag has joined #lisp
hjek has quit [Ping timeout: 260 seconds]
<cantor>
I dismissed racket because of the GIL
<cantor>
Scheme and ilk cause of lack of traction/mature ecosystem
JuanDaugherty has joined #lisp
fare__ has joined #lisp
stardiviner has joined #lisp
stardiviner has quit [Client Quit]
fikka has quit [Ping timeout: 248 seconds]
stardiviner has joined #lisp
Kaisyu has joined #lisp
<sukaeto>
cantor: you're in a channel about Common Lisp, so I imagine you'll get a very biased answer here
<cantor>
sukaeto: That's what I am hoping for :)
<sukaeto>
OK, then yes - you should switch to Common Lisp
<cantor>
i.e. people here use common lisp a lot, I want to see what they think of my concerns
<cantor>
sukaeto: reductive, doesn't address concerns elaborated post the question
<sukaeto>
a lot of us use Common Lisp professionally and are pretty happy with it, and neither the size of the language nor the tooling were deterrents for that
<sukaeto>
quicklisp makes packaging up an image pretty easy in most cases
Pixel_Outlaw has joined #lisp
<sukaeto>
and as far as "language size", I've never understood what the concerns were there.
<cantor>
the C++ syndrome
<cantor>
where each programmer uses a weird subset of the language
<cantor>
Also, what companies use Common Lisp professionally? Is there a list compiled somewhere?
<rme>
RavenPack and Rigetti are currently looking for Common Lisp talent, to name two.
<rme>
But there are many more organizations looking for Clojure, I have to admit.
<cantor>
rme: I knew of Rigetti, but last time I looked they had that "internship-like" program and the regular job descriptions were out of my league