wwtrmc has quit [Remote host closed the connection]
varjag has quit [Ping timeout: 260 seconds]
aindilis has joined #lisp
KevinJiang has quit [Quit: Page closed]
comborico has quit [Ping timeout: 256 seconds]
<jeosol>
I hope I am not the only one seeing the crap posted by wwtrmc
<SlashLife>
jeosol: Vice versa I'd hope I was the only one, because at least I know that I can ignore stuff like that. :)
karlosz has joined #lisp
Arcaelyx has quit [Ping timeout: 260 seconds]
sjl_ has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
sjl has quit [Ping timeout: 248 seconds]
xh4 has quit [Remote host closed the connection]
fikka has joined #lisp
xh4 has joined #lisp
markong has quit [Ping timeout: 260 seconds]
<aeth>
pillton: I have an idea for an option for defspecialization. :default-type foo. Saves repetition if everything or almost everything is of the same type. So it will interpret "defspecialization (foo :default-type vec3) (x y z (u single-float))" as "defspecialization foo ((x vec3) (y vec3) (z vec3) (u single-float))"
FreeBirdLjj has joined #lisp
<aeth>
I just added that to my typed variant of defun so I wouldn't make my code more verbose by switching functions to the typed variant of defun.
<aeth>
(I can also refactor a simple define-function into a defspecialization just by switching the name of the macro and adding a defspecialization return type, at least for trivial cases. I currently do not handle typed keywords/rest/optional and the actual options passed in are mostly different.)
FreeBirdLjj has quit [Ping timeout: 252 seconds]
<aeth>
(Actually, I could probably add an option to my define-function that could switch what's being defined to a defspecialization or a defgeneric, giving it a unified syntax and making refactoring between the three even simpler.)
manualcrank has joined #lisp
RebelCoderRU has quit [Remote host closed the connection]
<on_ion>
OH IRC GRAPHICS !! one hour later, no mods ? =P
<aeth>
IRC is like email. Once written, it cannot be undone
sjl_ is now known as sjl
smurfrobot has joined #lisp
eli_oat has joined #lisp
<on_ion>
maybe i should have reversed the caps. because its still on screen, and the perp is still in the channel ?
<on_ion>
"xyz is like life", one done, cannot be undone
Nikotiini has quit [Ping timeout: 276 seconds]
LiamH has quit [Quit: Leaving.]
Nikotiini has joined #lisp
comborico1611 has quit [Quit: Konversation terminated!]
clog has quit [Ping timeout: 260 seconds]
d4ryus1 has joined #lisp
d4ryus has quit [Ping timeout: 252 seconds]
octobanana has joined #lisp
megalography has quit [Ping timeout: 245 seconds]
EvW has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
<Lord_Nightmare>
on_ion: we need a bot with ops which autobans anyone who uses the term "#SUPERBOWL" or "#L0D3", iirc its all russian botnet related, possibly an extenstion of the old russian botnet seen back in the obama election days
<Lord_Nightmare>
er, i THINK its russian botnet related at least
<jeosol>
hmm, is that so?
<jeosol>
hopefully this site doesn't get messed up like comp.lang.lisp. I used to frequent there a lot and gotten a lot of help early on, till I started seeing hateful, racist stuff, and had to pack it ...
<on_ion>
Lord_Nightmare: also the Nword
<Lord_Nightmare>
I'm pretty sure the irc text spam (which is all over freenode) is russian botnet related and used the n-word to incite people
<on_ion>
jeosol: racist stuff in a lisp place ? was it spam as well?
<jeosol>
I meant at comp.lang.lisp, not here
<on_ion>
jeosol: yes i know. i said "lisp place". answer Q?
Kundry_Wag has quit [Ping timeout: 245 seconds]
<jeosol>
yes
<jeosol>
lisp place
<on_ion>
why do you render my question invalid or unapplicable , i was just asking if that hateful racist stuff you mentioned, was spam, or actual lisp stuff in a lisp place. dont worry if cant process
<jeosol>
lol. sorry about that. it is probably a mixture of both
ioa_ has joined #lisp
ioa has quit [Read error: Connection reset by peer]
kolb has quit [Read error: Connection reset by peer]
mrottenkolber has joined #lisp
<jeosol>
in comp.lang.lisp, sometimes, a bunch of arabic stuff, drugs for sale, and some posters have footers that have controversal statements. That said, some lispers there have called them out for it
mrottenkolber is now known as Guest26880
dented42 has joined #lisp
<on_ion>
ahh, i see. i havent seen much newsgroups for quite a while =)
FreeBirdLjj has joined #lisp
megalography has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
tomsen has quit [Ping timeout: 252 seconds]
<jeosol>
I have a google alert, so I was getting daily updates, but the negativity somethings is just distracting
mflem has quit [Ping timeout: 245 seconds]
kmurphy4 has joined #lisp
asarch has joined #lisp
jason_m has joined #lisp
isBEKaml has quit [Ping timeout: 245 seconds]
elderK has joined #lisp
xh4 has quit [Remote host closed the connection]
xh4 has joined #lisp
raynold has joined #lisp
karlosz has quit [Quit: karlosz]
megalography has quit [Ping timeout: 268 seconds]
Oladon has quit [Read error: Connection reset by peer]
<loke>
Basically they use PROG2 to invoke a side-effect used for the next COND clause
SenasOzys has joined #lisp
xh4 has quit [Remote host closed the connection]
fyodost has quit [Quit: Leaving]
xh4 has joined #lisp
<pillton>
It made perfect sense at the time.
<pillton>
...probably
asarch has quit [Quit: Leaving]
kbtr has joined #lisp
<loke>
pillton: Well, it's not _illegal_. It's just very... 1970's :-)
<pillton>
The indentation is pretty weird, so it is hard to evaluate the entire block.
SenasOzys has quit [Remote host closed the connection]
<pillton>
Who invented the tab character?
<on_ion>
george washington
<loke>
pillton: I reindented it, try reloading
<aeth>
loke: If it was written in any way like how I write CL it probably went like this: "This is ugly but I'll write it in a fairly straightforward way so I can refactor it, perhaps with a nice macro, later." Except the next day, it turns out it wasn't very straightforward at all and it was probably written at the very end of the day or something. And "the next day" might be two years later because big applications are big.
<pillton>
loke: Thank you.
<loke>
Not much different hough
<on_ion>
reinventation
<pillton>
loke: The use of setq in the test forms is pretty harsh.
<loke>
aeth: Possibly. But also remember that the Maxima was started in the 60's, and this is part of the function definition code which is likely that old.
<loke>
pillton: Indeed
<aeth>
pillton: Efficiency! We're competing with Fortran here!
<aeth>
(Of course, today's compilers probably would be more efficient if you wrote it in a more straightforward way.)
<aeth>
loke: Assuming defmacro dates to the 1960s, the thought process was probably very similar. If anything, they probably relied more on macros in old Lisp than today's Lisp.
<loke>
For even more interesting stuff, look at this... In particular the top comment:
pierpal has quit [Read error: Connection reset by peer]
blep-on-external has joined #lisp
sukaeto has joined #lisp
noffle has joined #lisp
manila[m] has joined #lisp
katco[m] has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
pierpal has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
smurfrobot has joined #lisp
stux|RC-- has quit [Quit: Aloha!]
stux|RC has joined #lisp
fikka has joined #lisp
pierpal has quit [Ping timeout: 260 seconds]
milanj has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
milanj has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
phenoble has joined #lisp
<phenoble>
Hi everyone,
fikka has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
<beach>
Hello phenoble.
<akkad>
re
<phenoble>
I am working through Seibel's `Practical Common Lisp`, and just encountered behaviour using SBCL different from the book. I wonder why this is.
<beach>
Let's hear it.
<phenoble>
So, Seibel explains that appending lists using append does not append copies of the passed lists, but essentially re-uses their memory.
<beach>
Only the last one.
<phenoble>
Such that, if any of those lists is changed afterwards using e.g. setf, the appended ...
<phenoble>
That effect must've been responsible for my observation then.
<phenoble>
beach: thank you for clearing that up, sorry for the confusion!
<beach>
No problem.
damke has quit [Ping timeout: 252 seconds]
octobanana has quit [Read error: Connection reset by peer]
jmarciano has joined #lisp
damke has joined #lisp
damke_ has joined #lisp
test1600_ has joined #lisp
test1600 has quit [Ping timeout: 252 seconds]
<phenoble>
Related question: is the rationale for having append behave in this way performance considerations that come to play in scenarios where the last element contains another cons cell (that links to another cons cell, ..and so on)?
raynold has quit [Quit: Connection closed for inactivity]
<phenoble>
Because why else would one construct append to behave in this (otherwise odd?) way, I suppose?
damke has quit [Ping timeout: 252 seconds]
<phenoble>
Asking because I am still a little uncertain regarding these list structures lisps use internally..
<TMA>
phenoble: APPEND is very old. by sharing as much as possible, you conserve memory (which was neither plentiful nor cheap those days)
fikka has quit [Ping timeout: 248 seconds]
<TMA>
phenoble: absent mutation, there is no natural way to tell, whether the last list is shared or not.
<phenoble>
Yes, but apparently things are shared only then, when dealing with "cons cells lists" I suppose (the way I use that term might reveal my lack of knowledge, sorry). Because in a scenario of e.g. (append (list ..) (list ..) (list ..)), only the last element is shared - which does not seem efficient.
milanj has quit [Read error: Connection reset by peer]
<phenoble>
TMA: noted, thanks
milanj has joined #lisp
<TMA>
phenoble: [[well, I am lying a bit. you can compare the conses for EQ, but from the point of what the list _contains_ there is no difference]]
palmtree has joined #lisp
<TMA>
phenoble: in general, you cannot share the non-last lists, because that would entail modyfying them
damke has joined #lisp
<TMA>
phenoble: NCONC does the modification. given your definitions of X Y, try (progn (defparameter q (nconc x y)) (values x y q))
<phenoble>
TMA: yes, I am starting to understand the details I think. This is essentially about how to deal with linked lists in different ways.
<phenoble>
hmm, when I pass a "list" as an argument to a function, I'd assume that only the first cons-cell is copied. Is that correct?
<phenoble>
...but, if that was true, why can I not change a list inside functions, I wonder.
jmarciano has quit [Ping timeout: 260 seconds]
<phenoble>
Though I would be surprised if that was not true, because from that it'd follow that the whole list is copied, would it not?
fikka has quit [Ping timeout: 240 seconds]
<phenoble>
mhn, I miss C++'s verbosity concerning these matters (pointers,references,lvalues,rvalues) - its explicit use of these concepts does make it explicit what is happening
Kundry_Wag has joined #lisp
<TMA>
phenoble: only the pointer to the first cell is passed to the function
python476 has quit [Ping timeout: 260 seconds]
Kundry_Wag has quit [Ping timeout: 276 seconds]
<phenoble>
TMA: yes, and hence you can actually change a list in a function.
milanj has quit [Read error: Connection reset by peer]
<TMA>
phenoble: there is no pass-by-value -- everything is passed by reference (well, the implementation is free to do as it pleases, as always)
milanj has joined #lisp
fikka has joined #lisp
<phenoble>
TMA: I am starting to see why lisp is referred to as much as it in the context of functional programming. It's a good fit for it w.r.t. performance.
xh4 has quit [Read error: Connection reset by peer]
flazh has quit [Quit: flazh]
flazh has joined #lisp
flazh has quit [Client Quit]
shrdlu68 has joined #lisp
flazh has joined #lisp
scymtym_ has joined #lisp
hajovonta has quit [Ping timeout: 245 seconds]
bendersteed has quit [Remote host closed the connection]
daniel-s has quit [Read error: Connection reset by peer]
scymtym has quit [Ping timeout: 260 seconds]
hajovonta has joined #lisp
hajovonta1 has joined #lisp
hajovonta has quit [Ping timeout: 252 seconds]
hajovonta1 is now known as hajovonta
Kevslinger has joined #lisp
tomsen has quit [Ping timeout: 268 seconds]
milanj has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
pierpal has quit [Client Quit]
pierpal has joined #lisp
EvW1 has quit [Ping timeout: 276 seconds]
margeas has joined #lisp
EvW has joined #lisp
markong has quit [Ping timeout: 256 seconds]
margeas is now known as markong
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
ryanwatkins has quit [Ping timeout: 245 seconds]
Bike has joined #lisp
damke_ has joined #lisp
damke has quit [Ping timeout: 252 seconds]
<beach>
phenoble: Common Lisp uses what I call "uniform reference semantics" which means that every object is manipulated through a reference to it. The calling convention uses call-by-value uniformly, in that arguments are evaluated before they are passed to a function, but the value obtained is a reference.
<beach>
phenoble: Nothing in Common Lisp is ever implicitly copied.
<beach>
This convention turns out to be the only sane one in a language with automatic memory management. It is much faster than what is possible in a language such as C++, which is why I frequently say that "it is possible to write a C++ program that is both fast and modular".
<beach>
Er,
<beach>
"it is NOT possible"
* jackdaniel
halts typing in the terminal `c++-ide' halfway through
pierpal has quit [Read error: Connection reset by peer]
test1600_ has quit [Quit: Leaving]
<beach>
To quote Paul Wilson: "liveness is a global property". So, in a C++ program, to make sure that you know the number of references to an object, you must either 1. break modularity so that you know it that way 2. introduce reference counters which makes things orders of magnitude slower, or 3. always copy objects so that you know that each one has a single reference, which is also disastrous for performance.
<beach>
jackdaniel: Er, what?
EvW has quit [Ping timeout: 265 seconds]
EvW1 has joined #lisp
<jackdaniel>
beach: that was a joke. A: XXX *is* good. B: <hurrs with preparations to use XXX>. A: is NOT*. B: <halts the preparations>.
<beach>
Ah, got it.
<beach>
I guess I must be tired. Sorry about that.
<jackdaniel>
no worrie
<jackdaniel>
worries*
Kundry_Wag has joined #lisp
* LdBeth
lol
hajovonta1 has joined #lisp
hajovonta has quit [Ping timeout: 240 seconds]
hajovonta1 is now known as hajovonta
<LdBeth>
Want some help with cl-pdf
<LdBeth>
How does it determine the font name? Seems it’s neither by postscript name nor file name of TTF/OTF font.
<shka>
because you are implementing garbage collector
<shka>
or something
<jackdaniel>
how is this related to the implicit copying in some languages?
<Bike>
well, C++ copies a lot because it puts things on the stack, so like if you return a complicated object from a function, it has to be copied
<shka>
usually copied
<Bike>
and it puts things on the stack because there's no way for it to put them on the heap itself
<shka>
it is even more complicated
<shka>
i think that implicit copying in CL is essentially invisible
palmtree has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Bike>
pretty much.
<shka>
as long as you don't use eq, only compiler programmers need to worry about it
<Bike>
eq is in kind of a weird semantic place because it can distinguish objects that nothing else in the language does, in implementation dependent ways
<LdBeth>
shka: probably you can print objects out to look up address
<beach>
shka: "Nothing is ever implicitly copied" is what is known as a "pedagogical lie". And "Uniform reference semantics" has an emphasis on "semantics", i.e. it is AS IF every object is manipulated through a reference, simply because there is no portable way a programmer can determine whether it is true or not.
<beach>
... other than EQ, I guess.
<shka>
i consider this to be not-a-problem in CL, really
<beach>
Yet, you brought it up.
<shka>
i regret this action
<beach>
Fair enough.
eli_oat has joined #lisp
<shka>
anyway, I was looking for small forth interpreter of FORTH written in easy to understand CL code
rumbler31 has quit [Remote host closed the connection]
xaotuk has joined #lisp
hajovonta has quit [Quit: hajovonta]
makomo has quit [Ping timeout: 260 seconds]
xristos has joined #lisp
Quetzal2 has joined #lisp
Arcaelyx has joined #lisp
igemnace has joined #lisp
oleo has joined #lisp
DonVlad has joined #lisp
oleo is now known as Guest31417
Guest31417 has quit [Changing host]
Guest31417 has joined #lisp
fyodost has joined #lisp
igemnace has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 248 seconds]
DonVlad has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Remote host closed the connection]
DonVlad has joined #lisp
Kundry_Wag has joined #lisp
igemnace has joined #lisp
<phenoble>
beach: Just reading your comments on our earlier discussion - thanks. I'll definitely keep your reference to memory management in mind in further study.
<phenoble>
beach: About C++ performance and modularity, though, I'm not sure I see the connection. I see C++ to be so flexible that you can essentially do everything you want - but at the price of complexity in using that... let's say, well-performing and modular thing, you've created.
damke has joined #lisp
<beach>
phoe: The problem with any language without automatic memory management is that you can't know what module is keeping references to your objects when you pass an object to such a module.
<beach>
Er, phenoble, I mean.
<phenoble>
beach: using smart-pointers that introduce some book-keeping logic via reference-counting mechanisms is not per-se slow
<beach>
Oh, yes it is.
<beach>
phenoble: Consider something like (setf x y) or x = y in some other language.
<beach>
In Common Lisp, it is a half-cycle register operation.
damke_ has quit [Ping timeout: 252 seconds]
<beach>
With reference counters, you have to do the following:
<beach>
1. Decrement the reference counter of the object referred to by x.
flamebeard has quit []
<beach>
That involves a memory reference, some 10 times slower than a register operation.
<phenoble>
beach: ah, you're discussing this still in the context of automatic memory management
<phenoble>
beach: ok, sorry, that was not clear to me
<beach>
Then you have to test whether the reference counter is 0.
<beach>
That is a test that may defeat branch prediction.
<beach>
Then you have to increment the reference counter of the object pointed to by y.
<beach>
Now you have a second memory reference.
<beach>
Finally, you do the assignment.
<beach>
phenoble: My point is that those operations are intrinsically slow.
<beach>
phenoble: But you have no choice if you don't have automatic memory management.
<beach>
Or rather, you do have a choice, which is to break all modularity so that you know whether a module keeps a reference to your object.
<phenoble>
beach: Well, you could devise your own scheme of making sure that memory gets deallocated at the appropriate times I suppose.
<beach>
No you can't.
<phenoble>
beach: manually
pierpal has joined #lisp
<beach>
Not while preserving modularity.
<beach>
Hence: "it is not possible to write a C++ program that is both modular and fast".
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
pierpal has quit [Read error: Connection reset by peer]
<phenoble>
beach: ok, I'm not all that deep into language design under these aspects (modularity?). I can neither speak nor think with authority on this. You win :-).
<beach>
phenoble: But apparently C++ programmers are being lied to. They think they now have garbage collection in their language, and they think the compiler can generate fast code. Since they don't compare with anything else, they believe it.
pfdietz has joined #lisp
Guest31417 is now known as oleo
<TMA>
beach: to be fair, there is a sentence in the standard, that says basically 'if you do this, you will probably break garbage collector (if you happen to use a implementation that provides it)'
<Bike>
where's that?
<beach>
TMA: What standard?
<TMA>
C++17 iirc
pierpal has joined #lisp
<beach>
TMA: Yes, I hear that they are preparing C++ for automatic memory management.
fikka has joined #lisp
<Bike>
oh, in C++ you meant
<TMA>
(it is worded in a manner to be able to use "portably" BDW GC)
<beach>
I see, yes.
<oleo>
minion: help
<minion>
There are multiple help modules. Try ``/msg minion help kind'', where kind is one of: "lookups", "helping others", "adding terms", "aliasing terms", "forgetting", "memos", "avoiding memos", "nicknames", "goodies", "eliza", "advice", "apropos", "acronyms".
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
<beach>
phenoble: So let me just say one more thing. When I program an application in C or C++ (which I haven't done for some time), I use pointers for everything, so that I get uniform reference semantics, and I stick in the Boehm etc. garbage collector so that I don't have to worry about freeing objects that are dead.
pierpal has quit [Ping timeout: 260 seconds]
palmtree has joined #lisp
Cymew has quit [Remote host closed the connection]
Cymew has joined #lisp
matijja has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #lisp
scymtym_ has quit [Ping timeout: 265 seconds]
Cymew has quit [Ping timeout: 268 seconds]
Cymew has joined #lisp
python476 has joined #lisp
Guest26880 is now known as thekolb
Kundry_Wag has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 252 seconds]
Naergon has quit [Ping timeout: 268 seconds]
Cymew has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
surya has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
nika has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
moei has quit [Read error: Connection reset by peer]
moei has joined #lisp
fikka has joined #lisp
al-damiri has joined #lisp
jason_m has joined #lisp
xaotuk has quit [Ping timeout: 240 seconds]
palmtree has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
FreeBirdLjj has joined #lisp
palmtree has joined #lisp
al-damiri has quit [Ping timeout: 245 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
al-damiri has joined #lisp
pierpal has joined #lisp
shka_ has joined #lisp
beginner_supreme has joined #lisp
<phenoble>
beach: ok, I was not aware that the question on which data primitive to use for keeping reference to dynamically allocated memory is something to consider in the context of performance. In my day-to-day dealing with a large C++ codebase many other considerations took precedence (so far).
Kundry_Wag has joined #lisp
cage_ has joined #lisp
EvW1 has quit [Remote host closed the connection]
smurfrobot has quit [Remote host closed the connection]
tmf has quit [Quit: Leaving]
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
al-damiri has quit [Max SendQ exceeded]
al-damiri has joined #lisp
<beach>
phenoble: Yet, people often cite performance as the main reason to use C++. But then apparently, they don't care so much about it after all.
fikka has quit [Ping timeout: 248 seconds]
DGASAU has quit [Read error: Connection reset by peer]
<on_ion>
beach: also, large codebases that are already in C++.
DGASAU has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
<beach>
on_ion: Yes, it's very sad.
scymtym has joined #lisp
<phenoble>
beach: The performance bottlenecks have, so far, been elsewhere. Besides - performance is rarely a topic. There's many other considerations to take into account when deciding on which programming language to use.
<phenoble>
beach: I'm not sure that attributing a "do-not-care-attitude" to anyone, is part of it.
shrdlu68 has left #lisp [#lisp]
<beach>
I know. I just gave a talk to industry entitled "Choosing a programming language".
<beach>
So I know for a fact that many wrong decisions are made.
<on_ion>
beach: interesting, is it live ?
<on_ion>
online*
<phenoble>
beach: But I'm sure all those questions are highly dependent on context.
<on_ion>
giving a talk to industry does not make one an expert =) else trolling irc i would have big points
<jeosol>
any links beach
<on_ion>
beach: ty
<jeosol>
ok, cool, you did that already.
<beach>
phenoble: Yes, but in general, decisions are made by incompetent decision makers, as the talk explains.
<jeosol>
a couple of my buddies, who program in other langs, keep questioning my choice of CL for a project I started
<phenoble>
beach: sounds plausible, but if it's true I cannot say :-)
<on_ion>
jeosol how come
<beach>
on_ion: No, but (as my "bio" says), I have a life-long experience from academia and industry in 5 countries on 4 continents.
<beach>
on_ion: Does that count a bit?
<jeosol>
on_ion: good question, first they see my screen (emacs) and kept wanting to know what strange language I was using
<on_ion>
(ps.ocaml and erlang are also good examples for dominating implementations)
<jeosol>
beach: "programmer productivity is highly influenced by the language" very true.
<beach>
jeosol: Yes, and I often cite the article by Hudak and Jones for that.
<beach>
In fact, that's another talk I often give to industry.
kmurphy4 has joined #lisp
makomo has joined #lisp
FreeBirdLjj has joined #lisp
<on_ion>
beach: yea =)
<beach>
jeosol: Yes, there is a very significant psychological barrier to admit that someone else made a good choice when choosing a programming language.
<on_ion>
jeosol: perhaps they do not know much of 'other' languages. xml \
<beach>
on_ion: That is part of it, but, as my essay explains, there is a great psychological barrier to even learning more languages than they already know.
<jeosol>
on_ion & beach: thanks for the reference and info
<beach>
jeosol: Anytime. Hope it helps.
<jeosol>
this is something I will have to deal with more and more
<jeosol>
having to convince potential partners, about my strange choice of languages
<jeosol>
I feel working with CL, when you start out, you are productive, but that productivity, if you will, delta(productivity)/delta(time) actually increases, because of prior knowledge, prior building blocks etc
<jeosol>
you keep getting more done in less time.
fikka has joined #lisp
<phenoble>
jeosol: Is this different with other languages, for you?
<jeosol>
need to save those resources
<beach>
easye: I have no explanation for it, other than my service provider messing up.
<easye>
beach: Fair enough. Just keeping ya informed. Glad you can at least reproduce.
<beach>
jeosol: You are going to have a hard time convincing them.
damke has quit [Ping timeout: 252 seconds]
<jeosol>
phenoble: good question: my language history: fortran77, f90, then grad school (matlab, C/C++), upon graduating pick up CL,
<beach>
jeosol: Worse, you are putting yourself in a very bad position.
<beach>
jeosol: Let's say you manage to convince them to use (say) Common Lisp.
<jeosol>
when working some Perl, but eventually converted C/C++ code to Cl
<beach>
jeosol: Now suppose ANYTHING goes wrong.
<beach>
jeosol: They are going to blame both you and Common Lisp.
<jeosol>
beach: I am not sure convincing is the right word or good approach
<phenoble>
jeosol: interesting. I find that I get better at anything I seriously work with for a while - no matter the language :).
<beach>
jeosol: Exactly. I recommend not doing it.
<jeosol>
I agree, it is probably sth that you have to experience. The code base is large now
<phenoble>
beach: I'm not sure I understood the context the causality you predict.
damke has joined #lisp
<jeosol>
phenoble: my programs are usually written in layers (mostly CLOS), what I meant by increasing productivity is that, adding new functionality or feature is much easier as I pickup previous layers or module
<beginner_supreme>
I'm a bit of a beginner at CL (lot of ways of doing things -> hard to determine best way) but I feel it's probably the best language to use for the majority of applications one can think of
<beach>
phenoble: I said a lot of things. :) what are you referring to?
Oladon has joined #lisp
<on_ion>
beach: i think there may be a contrasting anti-barrier as well, for those knowing too many languages
<_death>
beginner_supreme: that just means you need to think of more applications..
<jeosol>
beach: so what is the way, not convince at all? In the case of investors what to do
<jeosol>
if you had to lead a project and had a free choice, you probably will have to explain, if not defend your choice right?
<phenoble>
beach: I just meant to say that I do not know in which context the causal relationships you describe ("They are going to blame you") .. happens.
<jeosol>
I mean lead an entirely new project.
<beach>
jeosol: The only way I have found to work is to show that you can do work better and faster than others. Then, eventually, initiative will come from others and whey will want to know what you are doing.
<xristos>
beginner_supreme: it's not the best language if you treat engineers like cogs in a machine (commoditization)
<jeosol>
ok, that's fair. I agree
<on_ion>
beach: 404 on psych.html
<on_ion>
*\
<xristos>
which is what i've observed in industry at large
<beginner_supreme>
xristos: completely agree
<beach>
on_ion: apparently, yes. I don't know what the problem is. It worked for me a few minutes ago. And I haven't changed anything since.
<jeosol>
beach: confirm error too
fikka has quit [Ping timeout: 245 seconds]
<on_ion>
okay. its alright =)
<phenoble>
xristos: interesting. What inherent quality of lisp makes you think that engineers using it are harder to treat like cogs in a machine, than, say, engineers using C++?
<beach>
jeosol: My talk emphasizes establishing a risk analysis to make the choices. In particular, if you include programmer productivity in that analysis, you can compare the gain to the cost of training staff, etc. But it is entirely possible that the decision makers do not accept that there is a productivity difference between different languages.
<xristos>
phenoble: well there's drastically less of them, to begin with
tomsen has joined #lisp
varjagg has joined #lisp
cage_ has quit [Read error: Connection reset by peer]
cage_ has joined #lisp
<jeosol>
beach: good point. I was actually at the point of starting to teach CL or at least introduce them gradually
<beach>
jeosol: That can be a good strategy.
<phenoble>
xristos: I'm not sure I understand this argument.
<jeosol>
but to train, they have to be willing to pick it up right.
<beginner_supreme>
There is an observation called "zipf's law" where the 2nd most common thing is about half as common as the first, the 3rd 1/3, etc... So you get an 20% of items cover 80% of the area.
<beginner_supreme>
This applies to languages as well.
fikka has joined #lisp
<jeosol>
parentheses complaints was not a big issue for me when I started, because I was coding C/C++ in emacs then.
varjag has quit [Ping timeout: 240 seconds]
<beach>
phenoble: If you want to be able to hire and fire programmers at will, you need to use a programming language that every programmer knows.
<beach>
phenoble: If you use Common Lisp, you have to invest in training and keeping your programmers.
ym has quit [Quit: Leaving]
<jeosol>
very true beach. essentially, your programmers are key to the project
<xristos>
phenoble: trying to find ron garret's post about the attitudes he encountered at Google
<beach>
phenoble: But since decision makers don't know that there might be a productivity difference between different languages, they can't justify the additional investment.
<_death>
the simple fact is that a huge amount of effort went into writing and supporting performant libraries in C and C++.. and Lisp is not on the radar for many performance-critical applications..
<beach>
jeosol: Yes, if they would just understand that. :)
<jeosol>
xristos: thanks for that link. Should be interesting to read
lonjil has quit [Quit: WeeChat 2.1]
<jeosol>
once spoke to guy at 21s inc, some company in the east coast, US, using mostly allegro, you guys may have heard of the company. He did say they use CL actively for defense projects
<beach>
_death: When I hear expressions such as "on the radar", I think of failure to do a real cost and risk analysis, and I think of incompetent decision makers making decisions based on "gut feeling", even though they have neither training nor experience with the alternatives.
tomsen has quit [Ping timeout: 260 seconds]
smurfrobot has joined #lisp
<beach>
_death: Slide 37 of my talk contains phrases that I hear over and over again.
<_death>
beach: ok.. when I used this expression, I meant that I recognize that it's off the radar given the current state of the world.. so in this case I would be the decision maker
fikka has quit [Ping timeout: 240 seconds]
<beach>
_death: Sure, I can admit that there are restrictions when you are faced with an existing code base.
<beach>
I explain that "We need all the speed we can get... so we choose C++" really means "No matter how minuscule the additional performance turns out to be with C++, we want it, and we are willing to spend any amount of money and any amount of time to get it."
<phenoble>
xristos: thanks for the anecdotal read.
<_death>
I use lisp (incl. ffi to said libraries) when I can get away with it, and when I know it'll give me a good advantage.. but otherwise, it really depends on what you're doing, and I'd be wary of generalization
fikka has joined #lisp
<phenoble>
_death: I very much agree with the generalization bit.
<beach>
I explain that "All our programmers already know Java, so we choose Java" really means "I know for a fact that there is no other language out there that would be so much more productive for this project that it could compensate for the investment in training our programmers".
<beach>
etc. etc.
smurfrobot has quit [Ping timeout: 240 seconds]
<beach>
_death: Totally agree. Hence my emphasis on risk analysis (which is most often not even considered).
<phenoble>
beach: But that argument does sound very reasonable to me, in a real-world scenario.
<phenoble>
beach: Or put another way: it's not an argument of which it'd be immediately obvious to me that it'd be blatantly wrong. Always. Everywhere. All the time.
<phenoble>
s/it'd/it's/
<phenoble>
s/be//
<beach>
phenoble: So you are against making an informed comparison between alternatives?
lumm has joined #lisp
<phenoble>
beach: I did not say that.
<beach>
Sorry, misread what you wronte.
<beach>
wrote
<beach>
Er, no I didn't.
fikka has quit [Ping timeout: 248 seconds]
<beach>
Yes, it sounds plausible, but that is also why decision makers have to force themselves to establish a real budget.
<phenoble>
beach: I said that it is not obvious to me that the decision against using Java in favour of e.g. CL (disclaimer: I hate Java), in a business context, is obvious in favour of CL. All the time. Everywhere.
<beach>
phenoble: Of course. All I am saying is that, in order to make an informed decision, you cant rely on "gut feeling", because it is often totally wrong.
<beach>
phenoble: It is plausible that Java or C++ comes out as the right answer, but then it should be the result of a real cost and risk analysis.
<phenoble>
beach: Yes. But if that is the take-away message, the take-away message seems a little thin to me.
<phenoble>
beach: isn't that obvious?
<phoe>
phenoble: not really
<_death>
in many applications, it may also be the case that Lisp would only need a little help.. and if that is done then it's awesome.. but then it also depends on the people you work with and their background..
<beach>
Not to me. It means that the software industry is making hugely incorrect decisions because they don't know how to make such analyses.
<beach>
_death: And in my talk, I also introduce the possibility of hiring different people for a new project. That is another item in the cost analysis.
<jeosol>
from the link xristos provided, the VP shut down the use of lisp, from the write out, without much discussion, hmmm.
pfdietz has quit [Read error: Connection reset by peer]
<beginner_supreme>
Maybe people aren't exposed to more languages, so they learn the ol' java and ye ol' c++ and stick to those forever because they're "good enough"
<jeosol>
so you don't get a chance to explain any merits
<beach>
beginner_supreme: And then those people are promoted to decision makers. Go figure!
<jackdaniel>
doesn't same problem of ignorance apply to any language (Lisp included)?
<beach>
It applies to people.
<phenoble>
jeosol: yes, I found the reasoning to be a little on the light side as well.
<_death>
beach: I see.. that may work in some fields.. some are quite specialized though and an informed analysis would likely still result in the "status quo" language of that the ecosystem
python476 has quit [Ping timeout: 260 seconds]
<beginner_supreme>
True but I for example enjoy reading about languages so I go looking for things like CL, Forth, and tcl.
rumbler31 has joined #lisp
<jeosol>
phenoble: yeah.
<beginner_supreme>
You need a genuine curiosity
<beach>
_death: Again, I agree. And in such fields, the cost of a different language choice would show up as a huge negative budget item.
<beginner_supreme>
That most people don't really have, they just consume languages and compilers
Naergon has joined #lisp
<jackdaniel>
good for you that you have a) time for learning new things; b) you are genuinely curious
<phenoble>
beginner_supreme, anecdotically: "good enough" is often a goal in life you very much hope to achieve
<beginner_supreme>
I should write that down, there is wisdom in the quote
<jackdaniel>
but it all comes to what you consider your goal. If you treat programming languages as a vehicle to carry your thought, then finding "good enough" language is an acceptable heuristic
<jackdaniel>
spending considerable amount of life on studying programming languages - arguably is not (given stated constraints)
<jackdaniel>
but I'm getting offtopic, sorry :-)
<beginner_supreme>
Perhaps selecting [close to] all-encompassing language would allow one to do both. In this case CL is a good choice, at least in my limited learning experience.
<phenoble>
jackdaniel: oh, we've ventured off discussing lisp in particular a while ago. I do find the discussion still relevant though.
fikka has joined #lisp
<_death>
beach: maybe your talk is aimed towards a target audience that does not consist of Lispers, so the intention is just to make possible a different train of thought with such considerations..
<beach>
Totally true.
<jeosol>
saw an aws talk on microservices where they stressed multi-language, i.e., used the best language for each service and make services talk to others. Is this really viable?
Kundry_Wag has quit [Remote host closed the connection]
<beginner_supreme>
I was just sitting here pondering this question and saw your message when I looked up
rumbler31 has quit [Ping timeout: 276 seconds]
<phenoble>
jeosol: good question. I've been learning haskell,elisp,CL and brushed up on some serious Python programming in the past 12 months, next to a day-job doing C++. I'm doing fine, but I suppose it's not for everyone.
<jeosol>
I didn't mean it not doable, I was coming from the point of building, maintaining a team
<_death>
today polyglot programming is much more widely practiced, I would think
<jeosol>
if each person in each of a microservice decides to use a different language, or have a small set of languagges, e.g., python for ML tasks, C/C++ for critical tasks, etc
<_death>
with both the good and the bad..
<beginner_supreme>
Maybe multi-language is viable when there are many people involved, but I would imagine that a single language (CL) that can absorb different features via macros/read-macros is better for smaller teams?
<phenoble>
jeosol: I didn't mean to comment on possibility, just that I can very much relate to that question :). I'd also guess it be pretty hard to manage (a) dev team(s) in such a "context".
<jeosol>
beginner_supreme: yeah, I think the mult-language is more amenable to large teams,
warweasle has joined #lisp
cage_ has quit [Read error: Connection reset by peer]
<phenoble>
(apologies for slight off-topicness, though author makes case against using too many languages in single company)
<jeosol>
phenoble: thx. Will read.
cage_ has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
<beginner_supreme>
Anyways - may I work as a lisp developer, amen.
<beginner_supreme>
Was a great talk guys! Bye
<jeosol>
maybe have a small set of languages, each focused on certain strengths.
Kundry_Wag has joined #lisp
<phenoble>
jeosol: actually, that's not the article. I was looking for his telling of his personal story. -Very- good read. Somewhere on that page...
<phenoble>
(sorry)
beginner_supreme has quit []
smurfrobot has quit [Ping timeout: 240 seconds]
<jeosol>
phenoble: ok, no worries,
<jeosol>
this was good discussion overall, some good points. may be no need to explain my choice of CL
Kundry_Wag has quit [Remote host closed the connection]
kmurphy4 has quit [Quit: kmurphy4]
<jeosol>
phenoble: do you ML stuff with python yet?
7GHAAV63X has joined #lisp
palmtree has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
7GHAAV63X has quit [Remote host closed the connection]
tomsen has joined #lisp
Kundry_Wag has joined #lisp
<phenoble>
jeosol: funny of you to ask, I'm planning on working on my machine-learning skills, and given the available tools and resources out there, Python will indeed be my choice for that.
<phenoble>
jeosol: but I am about to have a look at Racket for Scientific Programming soon, too.
Kundry_Wag has quit [Remote host closed the connection]
<phenoble>
jeosol: ...just got to finally finish works on my every-growing (but also every-improving) emacs configuration in elisp :)
<phenoble>
s/every/ever/
<_death>
write a burgled-batteries-like thing for Lua and use Torch in Lisp..
<jeosol>
cool.
smurfrobot has joined #lisp
damke_ has joined #lisp
<jeosol>
with more players in that space, we can add stuff to ML libs in CL.
<Josh_2>
Is there a library for the Instagram API?
<oleo>
oO
fikka has quit [Ping timeout: 240 seconds]
<Josh_2>
Guess I'll have to use Python :O
Ven`` has joined #lisp
<oleo>
did you look in cliki ?
makomo has quit [Ping timeout: 240 seconds]
<oleo>
and common-lisp.net ?
<Josh_2>
Nothing on Clik8i
<oleo>
ok
<oleo>
well then you have to write one
<oleo>
lol
<oleo>
congrats!
<oleo>
hahahahaa
<Josh_2>
Hopefully gonna have my first paid dev work over the summer because of my Uni project that I wrote in common lisp :)
Ven` has joined #lisp
Ven`` has quit [Read error: Connection reset by peer]
<Josh_2>
Nothing on Common-lisp.net either so yeh I suppose one day I'll have to write one
vtomole has quit [Ping timeout: 260 seconds]
comborico1611 has joined #lisp
<oleo>
i'm far away from writing libs.....
<oleo>
just coping with getting my text-editor run correctly ....
<comborico1611>
I'm right there with you.
Ven` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<oleo>
and learn further etc....
<oleo>
meh
<oleo>
:)
<beginner_supreme>
Same, learning vim to use vlime
<oleo>
vlime ?
<oleo>
wth
<oleo>
you mean slime ?
<oleo>
or is that a thing ?
karlosz has joined #lisp
<beginner_supreme>
I mean vlime, it's like slime but for vim. Similar to the slimv project except slimv is written in python, while vlime is a mix of CL and C
<Josh_2>
Why would you learn vim to use vlime?
<beginner_supreme>
emacs frightens me
<_death>
what's the "e" in "vlime"?
<Josh_2>
And not just learn Emacs (the superior editor) and Slime :O
<oleo>
hmmm
trittweiler_ has quit [Ping timeout: 245 seconds]
<oleo>
no idea but i'll definitely use stumpwm again some time in the future.....
<beginner_supreme>
I'd love to but I saw C-c C-x C-h C-<insert letters> and my brain cache had a few misses
<_death>
beginner_supreme: did you try portacle
<oleo>
if i need an all lisp, minimal DE
<beginner_supreme>
No
<oleo>
eheh
<Josh_2>
You don't have to repeatadly push control
<_death>
beginner_supreme: it has emacs already configured and you drop straight into a CL repl
vlatkoB has quit [Remote host closed the connection]
<oleo>
welp, i'm trying to not use emacs
<beginner_supreme>
I'll check it out then.
<oleo>
i try to use climacs as much as i can
smurfrobot has joined #lisp
<oleo>
tho from the commandline i'm using emacs as a vim of sorts
tomsen has joined #lisp
<oleo>
maybe someone will write a ncurses backend too....
<beginner_supreme>
There's also something similar to slime called Lem editor
<beginner_supreme>
Apparently
makomo has joined #lisp
<beginner_supreme>
So far I've been using a regular editor without the repl server connection.
<beginner_supreme>
And using macros to reduce the need for repetition
<phenoble>
beginner_supreme: you should try spacemacs (an emacs distribution) with evil (a vim emulation). Both together do away with what many would consider, Emacs' unintuitive keybindings.
<_death>
I would say this approach misses out very important aspects of Lisp
<beginner_supreme>
Yes =\
fikka has joined #lisp
smurfrobot has quit [Ping timeout: 245 seconds]
DemolitionMan has joined #lisp
<beginner_supreme>
I'll look into portacle and spacemacs (disclaimer: I don't use vim either - it just seemed less steep a learning curve)
<phenoble>
beginner_supreme: oh, any rabbit hole you go down into, you'll go down deep =)
<phenoble>
be it vim or emacs
<phenoble>
but it's worth it - consider it an investment that'll net returns many years on
<_death>
I don't know if the curve is that steep... especially if you're going to learn Lisp anyway
<beginner_supreme>
Thanks for the suggestions and the conversation!
<phenoble>
_death, beginner_supreme: The steepness might also depend on how satisfied you are with the default configurations of vim and emacs. I know that I wasn't, so,... 2 years later I'm on freenode in #lisp.
<oleo>
i'm not sure why an explicit upgrade of asdf after loading quicklisp makes so much problems
bugrum has joined #lisp
<oleo>
but this way quicklisp can decide if it wants to upgrade stuff from the asdf in common-lisp/source/asdf
<beginner_supreme>
phenoble: Haha
<oleo>
so ......
<beginner_supreme>
Anyways, thanks for the great conversation everyone, till next time [possibly with other nicknames, don't feel like registering yet]
Kundry_Wag has quit [Remote host closed the connection]
mooog has joined #lisp
beginner_supreme has quit []
Kundry_Wag has joined #lisp
phenoble has quit [Quit: WeeChat 1.9.1]
tomsen has quit [Ping timeout: 248 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<aeth>
Imagine if beginner_supreme registered and continued using that name for decades, while becoming one of the biggest experts in Lisp.
<Bike>
all socrateasing it up
<_death>
next time we should suggest expert_sovereign
kushal has quit [Remote host closed the connection]
energizer has joined #lisp
python476 has joined #lisp
python47` has joined #lisp
python47` has quit [Read error: Connection reset by peer]
python476 has quit [Remote host closed the connection]
octobanana has quit [Read error: Connection reset by peer]
Kevslinger has joined #lisp
sz0 has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
xaotuk1 has joined #lisp
python476 has quit [Read error: Connection reset by peer]
xaotuk has quit [Ping timeout: 240 seconds]
<aeth>
I wonder if a normally AOT Lisp could JIT FFI to increase CFFI performance. Apparently JIT CFFI function calls have lower overhead than equivalent C function calls. https://news.ycombinator.com/item?id=17171252
xaotuk1 has quit [Ping timeout: 252 seconds]
octobanana has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
jmercouris has joined #lisp
asarch has joined #lisp
lumm has quit [Quit: lumm]
jmercouris has quit [Ping timeout: 240 seconds]
Nilby has joined #lisp
Quetzal2 has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 256 seconds]
varjagg has quit [Ping timeout: 248 seconds]
<ZigPaw>
but the difference is probably insignificant (like few cycles). If you need to gain so few cycles, you are probably better off inlining the function (and it might be done by JIT I think). But I'm not an expert.
kmurphy4 has quit [Quit: kmurphy4]
Kundry_Wag has joined #lisp
papachan has quit [Quit: WeeChat 2.1]
Kundry_Wag has quit [Ping timeout: 264 seconds]
itruslove has joined #lisp
giraffe has joined #lisp
giraffe is now known as Guest80598
smurfrobot has joined #lisp
j0ni has joined #lisp
Arcaelyx has quit [Max SendQ exceeded]
pjb has quit [Remote host closed the connection]
Cymew has joined #lisp
pjb has joined #lisp
pjb is now known as Guest65334
Patzy has quit [Ping timeout: 268 seconds]
Patzy has joined #lisp
Guest65334 has quit [Remote host closed the connection]
<p_l>
aeth: quite probably the "optimization" involved is already done by most lisps :)
fikka has joined #lisp
<p_l>
(tl;dr one level of indirection less due to not using relocation/PLT and instead dynamically loading addresses into known space)
dtornabene has joined #lisp
johnvonneumann_ has quit [Ping timeout: 264 seconds]
drastik has left #lisp ["WeeChat 2.1"]
doanyway has joined #lisp
<aeth>
It would be interesting to benchmark. SBCL was not included in any of these benchmarks for some reason even though that's what everyone's interested in.
pierpal has quit [Ping timeout: 248 seconds]
markong has quit [Ping timeout: 248 seconds]
johnvonneumann has joined #lisp
johnvonneumann is now known as Guest73259
Josh_2 has quit [Remote host closed the connection]