kevingal has quit [Remote host closed the connection]
renzhi has joined #lisp
aeth has quit [Ping timeout: 246 seconds]
mrchampion has quit [Read error: Connection reset by peer]
aeth has joined #lisp
zulu-inuoe has quit [Read error: Connection reset by peer]
mrchampion has joined #lisp
rumbler31 has joined #lisp
Codaraxis_ has joined #lisp
Codaraxis has quit [Ping timeout: 268 seconds]
rumbler31 has quit [Ping timeout: 265 seconds]
zaquest has joined #lisp
mmmattyx has quit [Quit: Connection closed for inactivity]
sjl has joined #lisp
orivej has quit [Ping timeout: 265 seconds]
luna_is_here has joined #lisp
frost-lab has joined #lisp
DGASAU has quit [Ping timeout: 260 seconds]
raeda has joined #lisp
DGASAU has joined #lisp
klltkr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
renzhi has quit [Ping timeout: 246 seconds]
logand`` has joined #lisp
logand` has quit [Ping timeout: 246 seconds]
indathrone has quit [Quit: Leaving]
ikrabbe|2 has joined #lisp
ikrabbe has quit [Ping timeout: 265 seconds]
mindCrime_ has quit [Ping timeout: 265 seconds]
orivej has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
aeth_ has joined #lisp
aeth has quit [Ping timeout: 260 seconds]
aeth_ is now known as aeth
slyrus has joined #lisp
slyrus has quit [Ping timeout: 265 seconds]
DanklyTuned has joined #lisp
Josh_2 has quit [Ping timeout: 240 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
trcm has joined #lisp
contrapunctus has joined #lisp
Alfr is now known as Guest90541
Alfr has joined #lisp
<beach>
Good morning everyone!
Guest90541 has quit [Ping timeout: 258 seconds]
slyrus has joined #lisp
slyrus has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
silasfox has joined #lisp
akoana has quit [Quit: leaving]
skapata has quit [Remote host closed the connection]
ebrasca has quit [Remote host closed the connection]
davisr__ has joined #lisp
ech has quit [Ping timeout: 240 seconds]
davisr_ has quit [Ping timeout: 240 seconds]
aartaka has joined #lisp
hypercube has joined #lisp
hypercube has quit [Ping timeout: 246 seconds]
hypercube has joined #lisp
waleee-cl has quit [Quit: Connection closed for inactivity]
Nilby has joined #lisp
bitmapper has quit [Quit: Connection closed for inactivity]
hypercube has quit [Ping timeout: 258 seconds]
hypercube has joined #lisp
aartaka_d has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
aartaka has quit [Ping timeout: 240 seconds]
contrapunctus has joined #lisp
silasfox has quit [Ping timeout: 260 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<alandipert>
hi beach o/
Bike has quit [Quit: leaving]
<beach>
alandipert: Hey! What's up?
<alandipert>
not a whole lot, you?
<beach>
Same here. I am working on implementing my idea for a register-allocation algorithm. And, as usual, I got the abstractions wrong the first few times, so more work than the idea should have generated.
<beach>
I think I must find a way to delegate the implementation of my ideas.
<beach>
So far, I have had more ideas per time unit than I have time to implement, so there is a fairly large backlog.
davisr__ has quit [Remote host closed the connection]
davisr__ has joined #lisp
<alandipert>
ah i know what you mean. i'm perpetually in the same boat with my various (and less impressive) projects
<jackdaniel>
jmercouris: the reason is because the goal of this proof of concept wasn't to have reload-less page - I didn't need javascript yet
<jackdaniel>
mfiano: there are no dependencies outside of cl the world (except for hand-written css file)
<jackdaniel>
the final thing will have three types of frame handlers: static (get/post), ajax-based for one-way updates, and a dynamic one with websockets
lawt has quit [Read error: Connection reset by peer]
ikrabbe|2 is now known as ikrabbe
<beach>
alandipert: But you work for a private company. Usually, in that world you can convince someone to invest money if the idea is a good one, and then you can hire someone to do it. No?
sauvin has joined #lisp
<beach>
alandipert: That's one problem I have with academia. What is considered a good idea, and thus subject to funding, is a complicated set of considerations like nation-wide or union-wide "strategies", and (above all) fads.
<alandipert>
well, i'm freelance currently and so have clients with disparate needs, so for my longer term and more conceptual bets, i'm the investor
<beach>
Oh, I see.
<beach>
I think I have another problem with my ideas. It might be possible at this point to start some crowdfunding effort for my projects, but I don't know how to find people who are both available and qualified.
<alandipert>
yes, i have enough friends and family in academia to be acutely aware of how difficult it can be to inhabit
<moon-child>
beach: I don't think industry is worse than academia in that respect. I daresay industry usually involves a more perverse (if consistent) set of incentives
<beach>
moon-child: That's my point, yes.
<alandipert>
i find industry incomparable to academic, but i've personally spent little time in academia, and understand there are many variables
<beach>
I would have to gather enough funding to convince a qualified person to quit the current dayjob, and that is very unlikely to happen.
<moon-child>
beach: err, I meant to say, I don't think industry is better than academia in that respect
<beach>
Oh!
Kundry_Wag has quit [Remote host closed the connection]
<moon-child>
(although, I don't have personal experience with academia. So I may be mistaken. Grass is greener and all that)
<beach>
I have worked both in industry and academia, though mostly in academia. But you may be right, my memory of industry may no longer be accurate.
<alandipert>
beach perhaps you could gather enough funding to quit your own current dayjob?
<beach>
That would be very very stupid.
<beach>
1. I have 10 months to retirement. 2. My dayjob allows me to work full time on my projects already.
<alandipert>
ah. clearly your best bet is to never retire :->
<beach>
That is unfortunately not an option. French law makes it impossible to continue after this date.
zaquest has quit [Quit: Leaving]
<beach>
What we need is another J. C. R. Licklider.
zaquest has joined #lisp
<alandipert>
regarding the scarcity of qualified help, you might consider how to market the project to those outside of the lisp community (although i understand at least with regard to paper abstracts, you're averse to that, and for good reasons)
<beach>
What would be the advantage? It would require some significant training to get those people to be of any use, no?
<alandipert>
well, there are vastly more programmers outside lisp than inside. and i posit good/experienced outside people usually learn lisp quickly once interested, and can have enough experience to appreciate its advantages in a way that neophytes cannot
<alandipert>
the important part being, "once interested"
<beach>
Yes, I see.
narimiran has joined #lisp
opcode has joined #lisp
<Nilby>
I think it's hard to get availible and highly qualified Lisp programmers to do what you want without the coercion of employment. I think there's quite a numer who live in post-scarcity and are available, but would need a mighty big carrot.
<beach>
alandipert: I am not averse to that. I just have no idea how to make such a thing happen.
<beach>
Nilby: I suspect that even with employment, it would be hard to get them to do what I want. :)
<Nilby>
Yes. Quite.
<Nilby>
I think the old Lisp companies somehow had a magic mixture of employment coercion and shared goals and belief in the work.
<Nilby>
And a bunch of already qualified very talented people.
slyrus has joined #lisp
<White_Flame>
and a mixture of government contractor money
lawt has joined #lisp
<Nilby>
White_Flame: Sadly, yes, that's what seemed to make it possible and then pulled the rug out.
slyrus has quit [Ping timeout: 240 seconds]
_paul0 has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
<pjb>
beach: well, in the current paradigm, the way to make qualified and talented people do your bid is by having a lot of money. You can have a lot of money by earning it, eg. starting a web software company like Zip2, selling it, with the money, starting up an online bank like Paypal, selling it, and with the money start up a company to build and sell EV cars, another to build rockets to go to Mars, and another to dig tunnels to run
<pjb>
cars and dig habitats on Mars.
<pjb>
beach: an alternative paradigm is proposed by Bernard Frio (quite intersting), but unfortunately, we're far from achieving such a system... (even if, as he argues, we already had half of it).
<pjb>
beach: note that this gives you a hint on how to gather work force around your project: don't aim at newbies, but at retired programmers!
<pjb>
Which in the case of a lisp project, is not a bad idea after all…
Mandus has quit [Remote host closed the connection]
<beach>
Sure.
silasfox has joined #lisp
<beach>
They would be amply qualified, and they don't need to spend all day making money to feed the family.
<pjb>
The quantity of retired programmers should increase a lot in the next years…
<pjb>
(or you can also win the lotto, and just start up a lisp company).
<beach>
First time I hear of Barnard Friot. I'll certainly read more.
shka_ has joined #lisp
<beach>
Anyway, my current strategy is to do the implementation work myself, hoping to get to a native executable SICL system not too far in the future. Once that is done, I hope to see more interest in helping out by people who are both qualified and available. I have no idea whether this strategy will work, of course.
<Nilby>
I'm hoping that there may some kind of convergence in the Lisp community when some of the various projects that people have been working on for years might be able to used a more cohesive whole.
<beach>
Nilby: That was one of the things I hoped to achieve with the SICL project. I secretly hoped to create high-quality "modules" that would then be adopted by existing Common Lisp implementations. I now think that hope was unfounded.
<no-defun-allowed>
Looking further in time when we may ask the same questions for CLOSOS (though there is surely a similar pressure for beach's more immediate projects), I am aware that programmers around my age are also often fed up with current compilers, operating systems and so on, but discussing the proposed solutions and projects leads to "knee-jerk" reactions #lisp participants may be familiar with.
<Nilby>
I'm not sure it's unfounded, it's might just take longer, since implementations necessarily have to be quite conservative.
<beach>
One thing that has a chance of success though is McCLIM. It is maintained and developed by a bunch of good people. It is quickly becoming the best choice for Common Lisp GUI code, as opposed to FFI solutions.
<no-defun-allowed>
For the most part, I believe there are people with time, but funding them and encouraging them to act on their complaints are very hard. (Though, of course, not everyone wants to write a compiler or operating system or whatever else, and that's fine too.)
<beach>
Nilby: I hope you are right.
<beach>
no-defun-allowed: Yes, it is very hard to get the message across to people with a long-term investment in more traditional technology.
<no-defun-allowed>
Instead what I see is people saying self-deprecating things like "computers were a mistake" and generally just sticking to small changes. The latter would be rational, but both make me sad.
<beach>
How strange.
<beach>
What is very surprising to me is that people write end-user applications in a language such as C++. I am thinking of things like MuseScore.
<beach>
I guess Firefox would qualify as well.
<no-defun-allowed>
beach: I'm not sure how long "a long-term investment" is, but they don't have much in the way of investments. I suppose they are used to some technologies, but they are often hobbyists with lots of spare time, and some groups iterate through many libraries and frameworks and whatnot relatively quickly.
<beach>
I am less surprised about things like LLVM. They probably try to target existing system programmers.
<beach>
no-defun-allowed: I see. That make their attitude more puzzling.
<beach>
Though, even with LLVM, it would probably have been easier to write it in some high-level language with automatic memory management, and then provide bindings for C and C++, rather than the other way around.
<no-defun-allowed>
(My last attempt to change anyone's attitude was to be equally as mindlessly optimistic, trying to say that computers and programming could, in fact, be very fun. But the "mindless" part of that plan is a problem, when it is not the norm.)
<beach>
no-defun-allowed: "last" as in "final" or as in "latest"?
<no-defun-allowed>
"latest"
<no-defun-allowed>
I should try something else, but right now I am taking a break from that project (and any substantial programming work).
<Nilby>
I have to intersperse serious work with fun work or else I might get the same feeling.
<no-defun-allowed>
On the contrary, I think programming requires a creative process, and if one is able to follow their creative process without too many restraints, then it is probably fun.
<beach>
I know of only one way that (sometimes) works to convert people, and that does not come across as proselytizing, namely to try to do good work that in some way improves on the existing state of things.
random-nick has joined #lisp
<no-defun-allowed>
Though, if everyone I was referring to had acted on what they were saying, it is likely most of them are not going to work on the projects we are looking for help with. But I would be happy if they did just about anything.
elflng has joined #lisp
hypercube has quit [Ping timeout: 265 seconds]
hypercube has joined #lisp
elflng_ has joined #lisp
elflng_ has quit [Client Quit]
elflng has quit [Ping timeout: 260 seconds]
elflng_ has joined #lisp
elflng_ is now known as elflng
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 260 seconds]
fourier has joined #lisp
Kundry_Wag has joined #lisp
rgherdt has joined #lisp
motersen_ is now known as motersen
tgbugs has quit [Ping timeout: 246 seconds]
Kundry_Wag has quit [Ping timeout: 240 seconds]
pve has joined #lisp
tgbugs has joined #lisp
fourier has quit [Changing host]
fourier has joined #lisp
surabax has joined #lisp
elflng has quit [Read error: Connection reset by peer]
elflng has joined #lisp
<splittist>
I think the progress on SICL has been nothing short of amazing. Particularly when the offshoots - eclector etc. - are taken into account. And the talent it has attracted is impressive.
<beach>
Absolutely right. The independent modules have become impressive thanks to the qualified people who agreed to develop and maintain them.
heisig has joined #lisp
<beach>
Not all those modules are excellent (yet). But I am convinced they will be.
<beach>
In my discussions, I was referring mainly to the SICL-specific code.
gitgood has quit [Remote host closed the connection]
Codaraxis has joined #lisp
hendursa1 has joined #lisp
Codaraxis_ has quit [Ping timeout: 265 seconds]
hendursaga has quit [Ping timeout: 240 seconds]
Danishman has joined #lisp
silasfox has quit [Quit: Ping timeout (120 seconds)]
silasfox has joined #lisp
<hypercube>
do you guys think Common Lisp will make a return to industry?
<beach>
Hard to say, given the sorry state of the software industry.
<splittist>
hypercube: I don't think it ever left. Perhaps it hasn't grown at the same rate as other (newer) languages, but there are pockets of lisp we rarely hear about. (Perhaps because it's in law enforcement and intelligence.)
<splittist>
When LAMBDA for Excel drops later this year, and joins the fairly recent LET, we can claim lisp IS the language of industry (:
heisig has quit [Quit: Leaving]
<hypercube>
im pretty new to common lisp and got into it mainly through taking a scheme course at school, but im surprised that programming isnt done that way more
<Nilby>
splittist: for printfcl (printf "%+0.ld % .0d %+0.0ld" 0 0 0) is not entierly valid, but seems to differ from the C version.
<beach>
hypercube: It shouldn't surprise you if you know how programmers are trained and chosen, and how little management knows about software development in general.
<beach>
Then again, maybe you don't know that.
<lukego>
Hey what's the appropriate time to split code into a separate package? I only have a few KLOC of code and I'm feeling the urge to break this up into separate logical packages but I also have a feeling that's possibly just unproductive busy-work
<hypercube>
i guess i realize that students arent exposed to this paradigm at all in academia
<splittist>
Nilby: thanks - I'll have look.
<beach>
lukego: I break my code up into "modules", where each module resides in a directory, has an ASDF system definition, and a component (file) containing a package definition.
galex-713 has quit [Ping timeout: 260 seconds]
<beach>
lukego: I extract a module whenever I see a reasonable (usually CLOS-based) protocol emerging.
<lukego>
beach: thanks, I was looking for a reference example of that style, and see now SICL repo is such
<beach>
Indeed.
<beach>
There are plenty of examples in there.
<no-defun-allowed>
hypercube: It makes sense to me, given whoever runs the industry wants perhaps the opposite of people doing whatever they want (for the most part).
<Nilby>
splittist: I wrote a printf in a blub language and had some old test file around which I think I got from cygwin.
<lukego>
yeah I have the vague feeling that having everything in the same package is making it too easy to have murky interfaces that I am not thinking out
<hypercube>
no-defun-allowed: true
<hypercube>
do you have any recommendations if i want to get serious about common lisp programming? any good books or courses?
<beach>
lukego: Yes, that's the risk. Plus, now when we have package-local nicknames, having a package for each module is not a problem.
<beach>
minion: Please tell hypercube about PCL.
<minion>
hypercube: look at PCL: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
<lukego>
hypercube: I think that Common Lisp is used in industry, mostly quietly in small groups, and seems likely to continue that way. maybe it's healthy that the amount of CL used in industry is driven by the number of geeks learning CL and looking for opportunities to work with it. better than e.g. if Gartner told the S&P500 they all need to adopt Lisp and the mess that would create.
<beach>
lukego: Well put!
<hypercube>
thank you beach!
<beach>
Pleasure.
<beach>
minion: Thanks!
<minion>
np
<Nilby>
I'm afraid industry would want to turn CL into Clojure or something.
<splittist>
Nilby: more tests always welcome!
<moon-child>
Nilby: let them eat cake!
<hypercube>
lukego: i suppose that's write
<hypercube>
right**
<Nilby>
moon-child: Yes. And stay out of my imaginary palace.
<Nilby>
splittist: They should be able to be read by your test code.
<splittist>
Nilby: awesome!
villanella has joined #lisp
<Shinmera>
lukego: In my mind files are for the maintainer's organisational structure, and packages are for the user's organisational structure. If you don't have users, then it doesn't matter much, but as soon as you see a part that could stand on its own, it can be useful to extract it.
karlosz has quit [Quit: karlosz]
<lukego>
I'm mostly asking myself whether multiple package namespaces will be a plus or a minus e.g. using symbols like BGA-NAME verses BGA:NAME verses NAME. I'm a CLOS n00b here and it's already bothering me having the same symbol for unrelated slots of different classes e.g. NAME or ID.
<splittist>
With a sufficiently smart editing environment (tm) (and perhaps a sufficiently smart programmer...) files should be a backing detail, and the programmer should be looking at whichever 'view' of the code makes sense for the task at hand (e.g. methods grouped by function or by specialised argument)
<Shinmera>
lukego: I wouldn't let that bother me. It's fine.
rvirding has quit [Ping timeout: 248 seconds]
theruran_ has quit [Ping timeout: 248 seconds]
gendl has quit [Ping timeout: 248 seconds]
<beach>
splittist: Indeed. Some people are working on such an environment.
<Shinmera>
lukego: But if you want to be stricter about it, as beach mentioned, design your protocols first, and separate them out into a package per protocol.
infra_red[m] has quit [Ping timeout: 248 seconds]
<lukego>
splittist: but now you're describing the environment that I switched /away/ from to work in Lisp :-) i.e. GToolkit in Pharo Smalltalk
antoszka has quit [Ping timeout: 248 seconds]
shrysr_ has quit [Ping timeout: 248 seconds]
stylewarning has quit [Ping timeout: 248 seconds]
plisp2 has quit [Ping timeout: 248 seconds]
theruran_ has joined #lisp
gendl has joined #lisp
anticrisis has quit [Read error: Connection reset by peer]
plisp2 has joined #lisp
<splittist>
lukego: heh
<lukego>
splittist: but I'm not really in that school of thought -- I'm more into embracing the limitations of the file-based representation e.g. as a means of putting a narrative order onto code that is lost when you slice and dice it up
<Nilby>
After using Pharo I appreciate files more.
terpri_ has quit [Remote host closed the connection]
antoszka has joined #lisp
<splittist>
lukego: fair enough. War and Peace v. Zork
terpri_ has joined #lisp
<Nilby>
"narrative" is a good way to put it
terpri_ has quit [Excess Flood]
terpri_ has joined #lisp
<lukego>
also as an old-school DEFSTRUCT kind of Lisp hacker it bugs me a bit with CLOS - and indeed with Smalltalk - that `M-.' doesn't hop you straight to the code you want but rather makes you scroll through to the relevant method even though that's usually painfully obvious to you as a programmer. but for better or worse I'm CLOS'ing this project
<lukego>
Maybe that copy of AMOP that I ordered a month ago will turn up one day and then I'll share everyone else's enthusiasm for this stuff :)
<Nilby>
Maybe we need a version of `M-.' that does compute-applicable-methods.
villanella has quit [Ping timeout: 246 seconds]
<Shinmera>
it would need to know the type of the arguments, which is usually not available because inference around CLOS is weak.
rvirding has joined #lisp
<lukego>
I'd like to have a DWIM version of `M-.' that jumps to some dynamic but predictable place e.g. the most recent method actually invoked from the callsite where I pressed `C-u M-.'
<scymtym>
you would also need COMPUTE-APPLICABLE-METHODS-USING-TYPES
<lukego>
(actually it could be an interesting form of "JIT" if SBCL would compile two copies of a function, one with lots of instrumentation for debugging and editing and so on and one without, and then enable the fast one only when it's actually "running hot")
<lukego>
Or maybe I'm dreaming of the Bad Old SBCL that had an interpreter that it used sometimes
<lukego>
ha!
<lukego>
I think I've asked this before but it's way too early to do real development in a SICL-hosted-on-SBCL, right?
<no-defun-allowed>
A JIT would still instrument in order to know when to give up on an optimisation, and a good one would still preserve semantics of the slow code.
<beach>
lukego: Yes, that will not be the goal of that environment.
h4ck3r9696 has joined #lisp
Feldman has joined #lisp
scymtym has quit [Ping timeout: 268 seconds]
<lukego>
no-defun-allowed: I meant without the various downsides of a highly dynamic JIT i.e. you still compile the same statically optimized machine code ahead of time but you also have a slow/instrumented version that you can swap in whenever you like e.g. to say "the next time we run that function let's log how each method invocation is resolved and store that for reference by an M-. command"
hypercube has quit [Ping timeout: 260 seconds]
<lukego>
beach: SICL is more about the long game of having a complete environment unto itself right?
<beach>
lukego: As opposed to what?
<lukego>
hosted inside another Lisp and used together e.g. SICL frontend over SBCL backend
<beach>
Oh, yes, definitely a complete environment.
<lukego>
(aside: it's remarkable how much instrumentation you can put into machine code on modern out-of-order CPUs without having much impact on performance e.g. conditional branches to hooks that are speculated away by the CPU)
<lukego>
I need to start reading SBCL internals so that my ideas can be less uninformed
<lukego>
beach: SICL sounds great but as a humble practitioner I'm not sure how to connect it with anything I'm doing
scymtym has joined #lisp
aartaka_d has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
Kundry_Wag has joined #lisp
<h4ck3r9696>
I have a problem with usocket: sometimes, when I try to use wait-for-input, it throws an exception: "couldn't read from #<SB-SYS:FD-STREAM for "socket 192.168.0.46:4444, peer: 192.168.0.27:35932" {1007AA9A43}>: Connection reset by peer [Condition of type SB-INT:SIMPLE-STREAM-ERROR]". I don't think this is normal, but if it is, how can I fix this?
<Shinmera>
It means your connection was terminated. You "fix" it by either somehow having internet that never breaks, or handling the error and establishing a new connection.
Kundry_Wag has quit [Ping timeout: 260 seconds]
<h4ck3r9696>
I see. I should try to reconnect to every peer, then.
Mandus has joined #lisp
<beach>
lukego: Right, it is not meant for you (at the moment). Once the environment is in working condition, I hope you will see some nice features.
_jrjsmrtn has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 260 seconds]
Major_Biscuit has joined #lisp
diamondbond has quit [Ping timeout: 250 seconds]
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
hjudt has joined #lisp
supercoven_ has joined #lisp
Feldman has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
supercoven has quit [Ping timeout: 240 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
* splittist
realises he's had Harbison & Steele on his shelf all along; proceeds to schedule printfcl rewrite
<splittist>
Nilby: that should be fixed. Thanks for the report and the tests!
<hhdave>
ikrabbe (or ikrabbe|2): I noticed over on #clim you were talking about using CL for devops. I'm doing that these days using https://github.com/Virtual-Insurance-Products/cl-sysop (which I wrote). I handled the executing commands on remote systems bit - it can bounce over several systems via SSH (also uses zlogin for executing things in SmartOS (solaris) zones). It handles all the shell quoting.
rumbler31 has joined #lisp
EffBezos has quit [Quit: Connection closed]
rumbler31 has quit [Ping timeout: 246 seconds]
<Nilby>
splittist: You're welcome. Thanks for making it.
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
vegansbane6963 has joined #lisp
jeosol has quit [Quit: Connection closed]
lotuseater has joined #lisp
johs has left #lisp [#lisp]
cosimone has joined #lisp
skapata has joined #lisp
<ikrabbe>
hhdave: Thanks for the note. I first transfer the sequence of commands send to a system into a list. I scan this list with a recursive function. That is a bit more complex, but far more flexible, as I searched a general solution for a common problem. The quoting is done by the structure of the list.
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
ask6155 has joined #lisp
<ask6155>
hello
<ask6155>
is there a function which opens up lists?
<no-defun-allowed>
Opens up?
<jmercouris>
maybe flattens? what do you mean exactly?
<ask6155>
like (open '(x y)) will return (x y)
<ask6155>
yeah flatten
<jmercouris>
alexandria:flatten
<ask6155>
is there nothing built-in?
<jmercouris>
no
<Nilby>
'(x y) is (x y)
<jmercouris>
perhaps you don't mean flatten though
<jmercouris>
because as Nilby pointed out, those expressions are equivalent
<hhdave>
ikrabbe: oh right. In my system I have a method which makes a command for a certain host which consists of a comamnd name and a list of arguments. I'd be interested to see what you come up with. I think there are other implementations of similar things. I've built up a system for declarative devops using CLOS.
<jmercouris>
(quote (x y)) -> (x y)
<ask6155>
a function takes a list, how do I return that list?
<ask6155>
actually bad question
<contrapunctus>
ask6155: what are you trying to do?
<ask6155>
I want to return a list with the items in the list x plus some more items at the end
<ask6155>
in one list with no sublists
<contrapunctus>
ask6155: append
<no-defun-allowed>
Huh? '(x y) and (x y) are not equivalent. The former evaluates to the latter though.
<ikrabbe>
or `(,@some-list ,an-element ,@the-elements-of-another-list)
<Nilby>
ask6155: Just be aware that the last argument to append must be a list e.g. (append '(1 2) (list 3)) => (1 2 3)
<ask6155>
thanks append works
<no-defun-allowed>
APPEND returns an improper list when the last argument is not a list.
<no-defun-allowed>
Interesting advice from #lisp today.
<ask6155>
I'm using common-lisp and in append I had to make all arguments lists like this '(x) I cannot use 'x it gives an error 'x needs to be a list. I have 3 args and x is the first
kevingal_ has joined #lisp
<no-defun-allowed>
Yes, the other arguments must be lists though.
<ask6155>
do all arguments need to be lists?
<no-defun-allowed>
If you have a list bound to X, then the call should look like (append x (list other elements here))
kevingal has quit [Ping timeout: 248 seconds]
vv8 has joined #lisp
<ask6155>
ok I getit
aeth has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
'x and x are not equivalent under evaluation, but I suppose reality is not being communicated well when someone who writes A LARGE POPULAR LISP APPLICATION is telling people that sort of nonsense.
<no-defun-allowed>
Whew, that's my shouting for the day.
aeth has joined #lisp
<ask6155>
i dont remember any popular lisp apps
<no-defun-allowed>
ikrabbe's suggestion to use quasiquotation would also work, e.g. `(,@x 1 2 3)
<ask6155>
i've not learned that yet
Feldman has joined #lisp
<no-defun-allowed>
Note that 1, 2 and 3 there are not evaluated - well, append would work fine for now.
<Nilby>
If someone can succeed despite my technically wrong advice, then they might have a chance with the harder stuff.
ask6155 has left #lisp ["bye!"]
<lukego>
speaking of things having to be lists I have a function (defun listify (x) (if (listp x) x (list x))) and was surprised not to immediately see it already existing in CL / alexandria / serapeum unless I missed it?
<no-defun-allowed>
alexandria:ensure-list or something like that?
<lukego>
no-defun-allowed: yes! fool that I am, I was looking for LISTS in the alexandria docs ToC and totally overlooked CONSES
<no-defun-allowed>
Nilby: The qualifier "technically" isn't necessary; that is absolutely confusing advice.
Kundry_Wag has joined #lisp
<no-defun-allowed>
And, from my point of view, progress was made in part because I had to correct you and jmercouris, and I would prefer to not have to do that.
Nilby has left #lisp ["lossage_handler() returned"]
Kundry_Wag has quit [Ping timeout: 240 seconds]
creat has joined #lisp
silasfox has joined #lisp
silasfox has quit [Client Quit]
igemnace has quit [Remote host closed the connection]
rodriga has joined #lisp
<lukego>
are you chastising people for the quality of the free help that they are offering in good faith to strangers on the internet? that's harsh :)
xaotuk has joined #lisp
t99 has joined #lisp
<ikrabbe>
not when they lead people in the wrong direction, though the critic was a bit strong, for a little quote :)
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
aartaka_d has joined #lisp
<ikrabbe>
ask6155: it took myself a good amount of time, to realize that append can be replace, especially in situations, where the result is not known: (apply #'append '(a-list) (return a few lists, to be appended)) is far more complex, than `(,@a-list ,@(return a few lists, to be appended))
<rodriga>
has anybody here ever worked in a Lisp startup? or have any connections to a Lisp startup or "internships"?
orivej has joined #lisp
<ikrabbe>
ask6155: actually I learned that while trying to understand onLisp
Bike has joined #lisp
aartaka has quit [Ping timeout: 248 seconds]
Feldman has joined #lisp
scm_ has joined #lisp
<mfiano>
Whenever I see #'append in my code, I consider it a red flag and I stop and think very carefully whether it can be expressed in a more efficient manner.
<mfiano>
Though I am normally writing high performance code where that thinking is required.
Kundry_Wag has joined #lisp
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
<ikrabbe>
As you first learn about quasiquote as "the somehow used macro definition leader", it is replaced by append when you begin your list juggling.
<mfiano>
"quasiquote" is a Schemism
<mfiano>
We call that "Backquote"
<no-defun-allowed>
Eh, I call it quasiquotation.
Kundry_Wag has quit [Ping timeout: 240 seconds]
<Bike>
we do call it quasiquote sometimes
<no-defun-allowed>
So does e.g. the library fare-quasiquote
<Bike>
also eclector. also the clhs suggests copying scheme. so it's fine
<mfiano>
Fair enough. It can be confusing to someone trying to reference the bible is all.
devrtz has quit [Ping timeout: 258 seconds]
devrtz has joined #lisp
* edgar-rft
quasiquotes the ten commandments
frost-lab has quit [Quit: Connection closed]
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
curtosis has joined #lisp
wsinatra has joined #lisp
cage_ has joined #lisp
<jcowan>
edgar-rft: And what parts of them do you provide as commatose variables?
orivej has quit [Ping timeout: 240 seconds]
yitzi has joined #lisp
<ikrabbe>
I think quasiquote is a quote good word, to express the function of the backquote character (at least far better than "the somehow used macro definition leader")
<lukego>
rodriga: I've worked in a Lisp startup and have a new embryo-phase Lisp startup now. what are you wondering?
aeth has quit [Ping timeout: 248 seconds]
aeth has joined #lisp
<beach>
lukego: Probably whether you propose employment or internships.
<ikrabbe>
mfiano: I just wikipedia'ed the word and found that quasiquote is actually a semantic concept of quotation, that matches our usage very well.
<lukego>
I guess that if one is looking for a lisp job/internship that list of Lisp companies is a good place to look. I only saw this for the first time this week. https://github.com/azzamsa/awesome-lisp-companies
Necktwi has quit [Ping timeout: 260 seconds]
<mfiano>
ikrabbe: It is the same concept. My point was that it is not a defined term in the Common Lisp standard. It was borrowed from Scheme to mean the same thing as an existing term in our standard.
waleee-cl has joined #lisp
Kundry_Wag has joined #lisp
<jcowan>
It's also used in Bourne shell terminology: '...' is quotation, "..." is quasiquotation
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
silasfox has joined #lisp
<jmercouris>
no-defun-allowed: pretty sure if one form evaluates to another they are equivalent...
<Xach>
if you are uncomfortable with all the mysterious unquoting rules, it's queasyquotation
seabass[m] has joined #lisp
<lukego>
where is the "like" button in irc...
<beach>
jmercouris: Not by any reasonable definition of "equivalent".
curtosis has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
<beach>
jmercouris: There is nothing wrong with the relation "evaluates to". It is reasonably well defined in Common Lisp.
<seabass[m]>
Hello!
seok has joined #lisp
<beach>
Hello seabass[m].
<seabass[m]>
I've got a JSON file that I'd like to turn into constants for Common Lisp
<seabass[m]>
Is there a way to do this at compile time with macros?
<beach>
Why would you use macros rather than functions?
<seabass[m]>
I was under the impression that it was macros that ran at compile time, rather than functions
<seabass[m]>
But if functions do the job, then that's also great! :)
<beach>
You can do anything at compile time with (eval-when (:compile-toplevel) ...)
<seabass[m]>
I'd really appreciate any code examples of this
<seabass[m]>
ooh, nice - so every CL compiler also has an internal intepreter?
<beach>
No. Most modern Common Lisp systems compile on the fly, so there is no interpreter present.
sz0 has joined #lisp
<seabass[m]>
wow, even better
<seabass[m]>
Lisp never ceases to amaze me :)
<seabass[m]>
...neither does the Lisp community, BTW ;)
mmmattyx has joined #lisp
<Xach>
beach: doug k had a very interesting example of how adding an interpreter to SBCL made parallel compilation faster
<seabass[m]>
I didn't expect to meet you this quickly upon joining the channel, lol :)
<aeth>
I don't doubt that you could do everything as a function but... this really does seem like a place where macros are more straightforward. Read/parse file at macroexpansion time, generate DEFCONSTANTs. The only issue is that macros can be evaluated more than once (and SBCL often evaluates them twice), so side-effects (including reading a file, I guess? it would happen twice) are discouraged.
<Xach>
beach: basically, if you have serial dependencies A, B, C, interpreting A and B with an interpreter only to provide the required compile-time side-effects of the code allowed C to be compiled before A or B is compiled.
<Xach>
beach: of course, this requires a complex and fast interpreter optimized for that purpose...not a "traditional" interpreter that helps with debugging or macroexpansion etc
<lukego>
Xach: interpreter is making a comeback in sbcl? any link on that?
<seabass[m]>
aeth, I guess I could read the file into a variable with a function
<seabass[m]>
and then convert them into constants with macros?
<Xach>
lukego: this is from many years ago, not new, but i feel it is not well-understood
<beach>
Xach: Makes sense.
<beach>
aeth: Entirely possible. Since I don't understand the problem statement, I was merely asking a question.
<aeth>
seabass[m]: even simpler than that, you can just check to see if the constants already exist, maybe?
<seabass[m]>
aeth, sorry what do you mean? This is a particular set of data specific to my program
<seabass[m]>
It's not a constant like Pi or anything
<seabass[m]>
By using constants I can avoid this huge JSON file being parsed every invocation, and also make the binary 'portable' by not needing a /usr/share dir
* lukego
gets some popcorn, has never really grokked the intersection between compile time evaluation and macro definition
<Xach>
lukego: when the interpreter was being developed (a long time ago), i thought it would really help for interactive debugging, but it's really just to avoid the overhead of the smart compiler generating nice code.
<Xach>
(slowly)
<lukego>
*nod* think of this any time I run CCL and it all feels so blazingly fast
<aeth>
seabass[m]: If you're using DEFCONSTANT it will be an error to redefine it on recompile. Two issues. First, it can run multiple times (wasting the later efforts assuming that the two definitions match). Second, if the file changes it will just error on recompile.
<aeth>
seabass[m]: The easiest workaround would just be to use a global, which at that point can just be done at the first run (assuming that it's a program or a framework, and not a library with many entry points)
<lukego>
aside: edebug for emacs has wonderful user experience for interactive stepper-style debugging, based on a metacircular interpreter afaik
<seabass[m]>
aeth, Hmm, that's interesting
<Xach>
lukego: allegro and lispworks are really fast too. it's interesting to see the kind of mindset that develops around many (most?) users of free CLs thinking SBCL is the only way to go and the best at everything
<seabass[m]>
Maybe I should give you an overview of what I'm trying to achieve more generally
<Xach>
(i love and use SBCL, but it is not the best at everything)
<seabass[m]>
Essentially, I've got this big JSON file. The JSON file is updated every few months
<seabass[m]>
the end user would need to download my source code, and then download any version of the JSON file into the source directory
<seabass[m]>
Then compile, and boom all the constants are there and the program never needs to read a JSON file again
<seabass[m]>
If I manually wrote the constants in the Lisp source, I'd need to change them manually at every release of the JSON data
charles` has quit [Ping timeout: 276 seconds]
klltkr has joined #lisp
aeth_ has joined #lisp
<lukego>
seabass[m]: I guess it's two related problems. One, how to load the data at compile time, perhaps with EVAL-WHEN; two, what to do with that data after it's loaded, e.g. keep it in a list that you lookup from, or translate it into Lisp-level compiler constants via macros.
<seabass[m]>
lukego, yes I think that's a good way of putting it
rodriga has quit [Read error: Connection reset by peer]
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
Codaraxis_ has joined #lisp
quazimodo has quit [Ping timeout: 268 seconds]
<lukego>
I really don't have this stuff swapped in but I am also curious about what is the idiomatic solution :). Maybe it depends on the way in which you're compiling your application e.g. into compiled modules (fasls) verses as a snapshot (image)?
<seabass[m]>
now you really are going over my head :)
Codaraxis has quit [Ping timeout: 265 seconds]
<lukego>
I hope that I'm not side-tracking you here but one relevant feature that Lisp has is being able to snapshot the whole Lisp process into a file -- basically a coredump -- and then run that again later. it's like a suspend-to-disk and all of the data you have loaded is included. I'm not sure if/how this applies to your situation though
<seabass[m]>
hmm that sounds cools but probably a bit advanced for me as well as my target userbase
<seabass[m]>
*cool
silasfox has quit [Quit: Connection closed]
<lukego>
I don't quite follow what the interface for your end-users will be. are they getting a stand-alone binary from you? or are they really getting source + json? and you plan to ship those on different schedules e.g. new lisp daily but new json monthly?
<seabass[m]>
Hmm, OK I'll try to expain better
quazimodo has joined #lisp
<seabass[m]>
Most users will simply get a binary release from me
<seabass[m]>
The releases that I make will always use the latest combination of JSON + Lisp code
<seabass[m]>
But if my users want to use a different version of the JSON, they can download them seperately and create that binary themselves
<lukego>
Maybe consider building on Xach's buildapp? https://www.xach.com/lisp/buildapp/ iiuc that's a simple way to create stand-alone executables that can easily load both code and data during build.
<Xach>
i like and use buildapp but investing time in learning how asdf's binary building works is probably better
<seabass[m]>
Ideally they shouldn't need to know any Lisp - just run make
<Xach>
from what i've seen, it's pretty easy
<beach>
seabass[m]: Maybe if you remove JSON from the discussion, and just let us know what the parser for the JSON file would return.
<beach>
seabass[m]: And then, tell us what you want that result to turn into, in terms of Common Lisp forms.
<lukego>
oh I didn't know that asdf had that function. neat.
<seabass[m]>
beach, it would return a list, containing a list of two keywords and their values each
<Xach>
i couldn't figure out cl-launch, so i made buildapp, which is simpler. then asdf was updated to be a little simpler than buildapp (i think)
<seabass[m]>
Hmm maybe I should try to explain that in Algol-like pseudocode
<seabass[m]>
even with a hint of python :)
<beach>
And what would you like your Common Lisp code to look like as a result of that example?
<beach>
I mean, it can't be (defconstant :a "string") etc.
<seabass[m]>
erm, why not?
Josh_2 has joined #lisp
<beach>
seabass[m]: Because you are not allowed to define Common Lisp keywords as constants.
<seabass[m]>
oh, right. Hmm.
<beach>
Plus, there are two :A and two :B so that would be a conflict.
<seabass[m]>
So can I define a constant list of keywords?
<seabass[m]>
equivilento `list[n].a` and `list[n].b` in Python, say
<beach>
Sure. But I don't see anything in your example that would suggest a Common Lisp name that could be used in a DEFCONSTANT form.
<seabass[m]>
haha, I just invented a nice word there
<seabass[m]>
'equivilento' :D
gxt has quit [Remote host closed the connection]
gxt has joined #lisp
<beach>
seabass[m]: It would be even better if you explain what you want without reference to programming languages that some people here might not master.
<seabass[m]>
beach, fair enough, but I'll have to think longer to get it into 'lispy' formats :)
<beach>
seabass[m]: So neither the keywords not the string literals can be used as the name of a Common Lisp constant. Therefore, you need to tell us what name you would like for your example.
<beach>
seabass[m]: Then, you need to explain what you had in mind when you thought it was possible to use keywords as names of constants, but then your example has duplicates, which would mean defining a constant in two different ways.
<seabass[m]>
hmm, yeah
<seabass[m]>
I guess I'd like to have one constant that is a list, where each item has keyworded values
<beach>
Oh, like a property list (plist)?
<seabass[m]>
ahah! That maybe it
* seabass[m]
looks up plists
<seabass[m]>
that sounds exactly like what I'm looking for
<beach>
Still, the duplication will be a problem. It doesn't make sense to have a plist with duplicate keys.
<seabass[m]>
So, is there a way of populating such a plist in a loop (which can ignore duplicate keys), and then 'set that it stone' for the binary?
<beach>
Or, it could make sense, but you need to explain what it would mean.
<beach>
seabass[m]: That's trivial. If you have the list in your example, then just turn it into (defconstant +mumble+ '((:a "string" :b ...) (:a ...)))
<lukego>
This example runs standalone.lisp that creates the executable ./standalone. This executable includes the contents of the file /etc/protocols at the time that the executable was created. Running ./standalone will print the contents of /etc/protocols -- not by opening that file but by "remembering" the value that was compiled in.
<seabass[m]>
great! So I populate a variable, and then defconstant it into a constant, all within a 'at compile time' section?
<seabass[m]>
lukego, that's really nifty
Feldman has joined #lisp
<seabass[m]>
That's pretty much what I wanted do to; can that be compiled into a binary and still work?
<seabass[m]>
as opposed to --load
<beach>
seabass[m]: Or perhaps (defconstant +mumble+ '((:a "string") (:b "...") (:a ...) (:b ...))) or even (defconstant +mumble+ '(:a "string" :b "..." :a .... :b ...))
<beach>
But you need to decide which one.
<lukego>
well in my interpretation the defconstant business is just a distraction. all you need is to have the data passed from compile time to runtime. the details of how you parse it, how you store it in variables, etc, are up to you and straightforward once you grok the bit above
<lukego>
seabass[m]: Yes. The --load will have the side-effect of creating ./standalone which is an executable.
<seabass[m]>
that's neat
wsinatra has quit [Ping timeout: 268 seconds]
<seabass[m]>
Thank you very much for your help here!
Feldman has quit [Client Quit]
wsinatra has joined #lisp
<lukego>
The way it does this is basically to "core dump" into that file -- i.e. suspend the Lisp process to disk such that it can be resumed in a new process -- but that's not really a scary thing in Lisp, and it's handy because all your state is preserved e.g. values you have loaded from disk or libraries you have loaded etc (but not open files/sockets/etc of course that die with the process and don't persist)
<lukego>
you're welcome
<seabass[m]>
that's certainly something that'd be scary in C
<lukego>
Maybe if you take this approach you could just parse the JSON data at runtime if that makes it easier to think about. You can still have the JSON data loaded at runtime and stored in the executable -- but it's probably not necessary to translate it into Lisp code since if you have it in a Lisp string you can just parse it into a Lisp data structure at any time.
<seabass[m]>
There's also something I'd like to ask for the benefit of the user
<seabass[m]>
There's a portion of the JSON that'll never be needed for my program, so I think it probably makes sense just to save the data I need
aindilis` has joined #lisp
aindilis has quit [Ping timeout: 240 seconds]
rodriga has joined #lisp
hendursa1 has quit [Ping timeout: 240 seconds]
<lukego>
So what you have here is really a general suspend/resume facility. You can decide what data you want to have in the process at the time you do the suspend. In this example you have the raw contents of the file stored in a variable, but you could instead e.g. pass that to a function that extracts only the part you need, or compresses it, or parses it and stores the parse tree, or translates it into lisp code, etc.
_jrjsmrtn has quit [Ping timeout: 248 seconds]
__jrjsmrtn__ has joined #lisp
<lukego>
Since the suspended Lisp process includes the whole Lisp compiler you should also be able "at runtime" to load in new data and generate a new executable containing that instead.
<seabass[m]>
isn't that a little wasteful?
aindilis` has quit [Remote host closed the connection]
<seabass[m]>
Compared to C, for instance, which only has the code that you wrote
<lukego>
So this is about half way between C and Docker.
<seabass[m]>
sorry, I don't know Docker :)
<lukego>
So basically it's very wasteful by the standards of the 1990s. By today's standards I'd call it borderline restrained.
aindilis has joined #lisp
<seabass[m]>
that's a fair point :)
<lukego>
anyway, it's a starting point if you want to get up and running, quite possibly you'll find a better solution later if you want to reduce your file size etc.
<seabass[m]>
yeah, that's true
<seabass[m]>
Again, thank you :)
<lukego>
(maybe other people have better suggestions for you, I'm only taking the time now because it looked to me like you were getting side-tracked with thinking about how to represent JSON data as Lisp code, when it really seemed like your main problem was just embedding some data in your program)
<lukego>
welcome
dinnu93 has joined #lisp
<seabass[m]>
yup, pretty much
<seabass[m]>
I have a tendency to go down those sort of side-tracks :)
<shka_>
hi all
<lukego>
Lisp will offer you plenty of possibiliites for that, don't worry.
<seabass[m]>
o/ shka_
<shka_>
i am looking for a really good example of pretty printing code
<shka_>
please, aid me
<seabass[m]>
hmm there's probably a good file or two in GNU Emacs for that
<shka_>
well, common lisp to be specific
<seabass[m]>
ah, OK
voidlily has quit [Ping timeout: 258 seconds]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<seabass[m]>
shka_, M-x find-function RET indent-line-to RET, just in case you're interested anyway :)
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
<shka_>
seabass[m]: appreciated
<seabass[m]>
no problem :)
<seabass[m]>
shka_, do you use Emacs?
<seabass[m]>
It surely must be the best Lisp editor in existence
<shka_>
beach: that's exactly what i wanted to type
<shka_>
anyway, emacs is not even bad
<beach>
Sorry I beat you to it. :)
<seabass[m]>
beach, it's fine as long as you have long fingers and small keyboards :D
davisr has joined #lisp
<shka_>
but we could have something so much better
davisr__ has quit [Ping timeout: 240 seconds]
<mason>
seabass[m]: Bah, foot peddles do away with all of that.
<seabass[m]>
mason, ooh, you actually have one?
<seabass[m]>
Does it plug into the mic jack or USB?
<mason>
seabass[m]: No, but I want one so I can be a better Emacs user.
<beach>
seabass[m]: No, it is not fine. It doesn't have a good idea of what the code in the buffer represents, so it often gets indentation wrong, and it confuses non-forms and forms.
<seabass[m]>
ah, OK :)
<beach>
seabass[m]: etc, etc,.
<lukego>
decades of Emacs use and no foot pedals, then I took up soldering and suddenly I have five under my desk right now :)
<seabass[m]>
beach, that's funny, I've never had any issues with that. But then again, I'm not too advanced at Lisp right now, as you can see :)
<mason>
beach: What's a good editor? Or isn't there one?
<seabass[m]>
lol! that's funny lukego
<beach>
mason: Like I said, I agree that "sadly" Emacs is the best.
contrapunctus has joined #lisp
<seabass[m]>
I'll ask you then - is it audio jack or USB?
contrapunctus has left #lisp [#lisp]
<seabass[m]>
I guess you'd need some sort of uc for USB
<beach>
seabass[m]: That's the very problem. People seem content with this situation.
<shka_>
beach: i think that emacs has a few extra benefits for people who program in multiple languages
<seabass[m]>
nope, I haven't actually considered one for myself
<beach>
shka_: Yes, but I was answering: <seabass[m]> It surely must be the best Lisp editor in existence
contrapunctus has joined #lisp
<mason>
seabass[m]: I think it's probably worthwhile since Emacs, despite protestations, is in fact modal. "I've got the control key down" is a mode.
<shka_>
righ
<shka_>
t
<seabass[m]>
yes, I agree
<mason>
Really, having a control key on the floor is all the pedal I'd want.
<seabass[m]>
on a technical basis, of course, there's no difference
<seabass[m]>
And you could very easily remap non-control keys to anything else
<seabass[m]>
(global-set-key (kbd "a") 'execute-extended-command) or whatever
<beach>
lukego: I would like a keyboard with a much more narrow space bar, and I would like the extra space to be used for control and meta, one for each thumb. I take it Japanese keyboards are like that, but for different reasons.
<seabass[m]>
beach, absolutely agree with you there
<seabass[m]>
The Japanese keyboards are themselves hyper-modal
<lukego>
beach: yeah. I always shop for the keyboard with the narrowest spacebar that I can. ironically it means wanting a Windows key. the best I can usually do it having Space flush with the left of C e.g. on my Thinkpad and Mac keyboards. Sometimes it comes out below X and then I get hand cramps reaching for Meta.
<seabass[m]>
the Chinese just gave up and use Pinyin :D
renzhi has joined #lisp
<lukego>
though I only use my left hand for modifiers I think. pinky for control (capslock) and thumb for meta.
<lukego>
once upon a time I had my spacebar mapped to a Hyper key but I was in a bad place then and stopped escalating my keyboard hacks as the hand cramps started :)
<seabass[m]>
lukego, me too unless my left hand hurts, then I use my right hand for modifiers for a few hours
<pjb>
Actually two small space keys separated by a ⋅ key.
<shka_>
beach: i use redox keyboard, it has ctrl just under the thumb
<lukego>
interesting keyboard pjb!
<beach>
pjb: That looks good!
<seabass[m]>
pjb, wow that's a beautiful keyboard, but it sure is expensive
voidlily has joined #lisp
<shka_>
on the standard keyboards, i used to remap caps lock to act as a ctrl
<seabass[m]>
My budget is more like USD$60
<beach>
shka_: Yes, but C-a becomes a bit hard to type.
<shka_>
and ctrl to act as escape
<seabass[m]>
shka_, on Colemak Caps Lock is backspace
<shka_>
which also makes some sense
hjudt has quit [Ping timeout: 240 seconds]
<shka_>
honestly, caps lock has no place on the modern keyboard imho
<lukego>
I have been gradually expanding my notion of what is a reasonable price for a keyboard as I keep on buying more and more cheap and crappy ones and wishing I'd been less stingy :)
<lukego>
but just using the thinkpad now, and Barrier to share the laptop keyboard/mouse with the desktop.
<beach>
pjb: That look like precisely what I desribed.
<beach>
described.
<seabass[m]>
lukego, I know one of the maintainers of Barrier btw
<pjb>
beach: unfortunately, out of stock. They may take orders for a possible future batch.
<shka_>
beach: you gonna need a rather large desk for this one :-)
<seabass[m]>
always grumbling because the GitHub project owner won't give push privs :D
<lukego>
seabass[m]: cool :) it's a great piece of software! though one day I must work out how to get it to auto-start on startup. each time I reboot one of my machines I end up fishing out a backup keyboard/mouse to manually start barrier with :). maybe I could just start it from the command-line, have to check that..
<beach>
pjb: Oh, too bad.
<seabass[m]>
lukego, you could ues an initrc/systemd unit maybe?
<lukego>
I suppose actually that barrier makes total sense as a text-based command line application, I wonder if it has such a mode, it's awkward to start in GUI mode since in principle I don't have a keyboard/mouse on the client machine
<lukego>
yeah, one day I'll finally do that...
<seabass[m]>
I don't use Barrier but I could knock up a systemd unit for you if you want
<seabass[m]>
not in such yellowed state, I may add :D
<lukego>
old school :)
Feldman has joined #lisp
<seabass[m]>
my father's first IBM-PC clone keyboard :)
<lukego>
thanks but I'm on NixOS so that'll be another whole kettle of fish to integrate the script into and I don't have the motivation just now :)
hypercube has joined #lisp
<seabass[m]>
lukego, sure, I forgot that you used NixOS
<seabass[m]>
Even though it's plastered all over that code you displayed :D
<lukego>
I can't remember what sin I am atoning for by using NixOS but it's probably a whopper
<seabass[m]>
aw cute you call your laptop thinky
quazimodo has quit [Ping timeout: 265 seconds]
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
renzhi has quit [Ping timeout: 260 seconds]
jerme_ has quit [Ping timeout: 260 seconds]
sz0 has quit [Ping timeout: 258 seconds]
b20n has quit [Ping timeout: 246 seconds]
dunk has quit [Read error: Connection reset by peer]
quazimodo has joined #lisp
jerme_ has joined #lisp
b20n has joined #lisp
dunk has joined #lisp
sz0 has joined #lisp
skapata has quit [Remote host closed the connection]
<lukego>
Here's my latest abuse of unicode, this time because (required-argument) takes too much horizontal space:
<lukego>
(define-symbol-macro ⊥ (error "⊥"))
slyrus has joined #lisp
<phoe>
required-argument takes an argument name, no?
<lukego>
optionally
t99 has quit [Ping timeout: 252 seconds]
<phoe>
oh! I see
<lukego>
(defstruct foo (name ⊥ :type string)) ;; scratches an itch for me ...
ech has joined #lisp
rogersm has joined #lisp
<_death>
it takes a name so that it can produce a better error message
<lukego>
yeah. I never give that name though because I'm always bothered about the verbosity.
<lukego>
(and because often the reason I'm using defstruct in the first place is because I couldn't stand the redundancy of defclass :))
<lukego>
maybe I should be using one of those easy-defclass macros.
<lukego>
but it's nice to let my hair down and allow myself to indulge some symbol/reader macros and funny syntax sometimes too.
<_death>
it's easy-defclass to those who know and love it.. for others it's "oh man, now I gotta learn another stupid defclass shortcut library to understand this form"
<_death>
that or "now I gotta macroexpand"
<_death>
the former is more likely if I also want to modify it
aeth has quit [Ping timeout: 240 seconds]
fourier has quit [Ping timeout: 240 seconds]
<lukego>
yeah. I guess I've been struggling and failing to get the taste for CLOS for like twenty years now so a crutch might be helpful. but I do have AMOP on order.
<_death>
defclass is verbose, but it's a small price to pay
aeth has joined #lisp
hendursa1 has joined #lisp
<lukego>
I have made one apparent step forward by factoring slots out into mixins like (defclass indexed () ((index ...))) when I often use the same slots in various classes
<lukego>
(defclass foo (indexed banked sided) ()) saves a lot of text compared with entering the slots manually every time.
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<beach>
lukego: There is redundancy in DEFCLASS only if you don't care about modularity and consistent protocols.
notzmv has joined #lisp
<lukego>
beach: so the Erik Naggums of the world keep telling me, but I don't believe it's as black and white as that.
<beach>
lukego: In practice, not every slot should have an :INITFORM, not every slot should have an :INITARG, not every slot should have a :READER, and not every slot should have a :WRITER.
<jmercouris>
lukego: we use hu.dwim.class star
<beach>
jmercouris: I am sorry to hear that.
<lukego>
to me it sounds like saying that Java class definitions are only verbose if you don't care about scope, mutability, and allocation policy. but that doesn't excuse typing "public static final ..." ten thousand times
<jmercouris>
lukego: it is in my opinion way better than just defclass by itself
<jmercouris>
beach: I find it quite convenient :-)
<jmercouris>
I can use all of defclass when needed
<lukego>
jmercouris: thanks! I'll try joining you at the philistines table and see how I fit in :) but I am guessing that reading AMOP will change my idea of what is appropriate, for better or worse, and I don't know in what direction
<jmercouris>
Otherwise I use define-class
<lukego>
jmercouris: love your work btw :) have only recently found out about nyxt
<jmercouris>
lukego: thanks, that’s very kind of you to say
<beach>
jmercouris: Yes, it is no doubt quite convenient... if you don't care about modularity and consistent protocols, like I said.
<lukego>
beach: I'm often just creating internal data structures and not public interfaces. the way in other languages one might use a throw-away dictionary or tuple.
<jmercouris>
Sometimes I do, sometimes I don’t
<jmercouris>
It depends on whether I’m writing a library or an application
<beach>
Wow.
<jmercouris>
beach: you are a much more conservative programmer than me :-D
<beach>
lukego: Even for those, it pays off to think about what kind of options you want to give to MAKE-INSTANCE, what slots you want to be writable, etc.
long4mud has quit [Ping timeout: 240 seconds]
<jmercouris>
If Encapsulation is important, you’ll end up writing getters and setters anyways
<beach>
Er, what?
<jmercouris>
Talking about using class instances as a way to pass state around , instead of thinking about them as objects
<beach>
Don't tell me you write things like (defmethod get-stuff (x) (slot-value x 'stuff)).
<jmercouris>
beach: of course not 11
<jmercouris>
I’ll just add an accessor
<jmercouris>
I do write getters sometimes that have more logic than that though
<beach>
Those are known as "slot readers" and "slot writers", not "getters" "setters".
<beach>
And you can always write auxiliary methods on the corresponding generic functions.
<beach>
There is typically always a slot reader, but not always a slot writer on a slot.
aartaka_d has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
<beach>
... independently of encapsulation issues.
<beach>
In particular, you may not want to use :ACCESSOR if you want client code to read the slot, but not write it.
<beach>
... since the same symbol can be used both to read and write the slot then.
<mfiano>
I even go as far as to define a %-prefixed accessor in addition to a reader that is exported, rather than use slot-value for internal code, since it is often wanted to extend that protocol
<beach>
Exactly.
<beach>
It doesn't have to be prefixed as long as it is not exported.
<mfiano>
Right. It's just a convention
<jackdaniel>
if the reader is exported, then (setf reader) is kinda exported too
<beach>
I sometimes do (%name :reader name :writer (setf other-name))
<mfiano>
One that is recognizxed by others at that, but mostly personal :)
<mfiano>
err recognized*
<beach>
jackdaniel: Exactly my point, yes.
<mfiano>
Yes, that was what I was implying.
<beach>
But sometimes I just use REINITIALIZE-INSTANCE internally.
<mfiano>
If I don't want users to write, I'll export a symbol used for :reader, and give myself a non-exported symbol for :accessor/:writer
<beach>
Right.
<jackdaniel>
howerver given that you bother to write down how to use your system and you do not mention the writer (setf foo), then if someone uses it then it is violating the library protocol
gxt has quit [Ping timeout: 240 seconds]
<jackdaniel>
so it is still kind of internal
<lukego>
This may shock you guys but I sometimes even pass around data as *lists of atoms* :)
<beach>
jackdaniel: Sure. But it is good to give warnings or errors in case of incorrect use.
rogersm has quit [Quit: Leaving...]
gxt has joined #lisp
<mfiano>
It surprises me at how many codebases use the same symbol name for the slot as the accessor (in the general sense, not :accessor)
ech has quit [Remote host closed the connection]
long4mud has joined #lisp
<mfiano>
THat is an accident waiting to happen in most cases
<jackdaniel>
beach: I tentatively agree but one could consider adding (setf %extra) accessors clobbering from the code perspective (and one more sub-protocol to keep in mind when working on the system)
ech has joined #lisp
aeth_ has joined #lisp
<beach>
Sure.
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
<lukego>
It bothers me how much this discussion sounds like #java in the 1990s :(
<jackdaniel>
that sounds as if some very smart people worked on java back then ;-)
<pve>
lukego: you might use emacs to generate an initial defclass form for you, and then edit as necessary
<lukego>
The whole "ravioli code" concept with layers of empty calories between every tiny morsel of meat :)
<pve>
instead of a CL macro, I mean
<lukego>
pve: okay now you're just copy-pasting from a java forum I'm sure of it :)
<pve>
haha no I'm serious
<pve>
you end up with a defclass form that everyone understands, without having to type it all out
<lukego>
This is the big challenge with CLOS for me. I don't /want/ to agree with what you guys are saying :) I like the kind of Lisp code that Peter Norvig writes and he's more likely to use DEFCLASS with :TYPE LIST than any of this business
<lukego>
DEFSTRUCT rather
<lukego>
but maybe it is more of an applications verses libraries thing. I'm writing code that I expect to churn quickly and not be seen by anyone else's eyes before being rewritten a couple of times. so it doesn't seem rational to spend time worrying about how a hypothetical unknown third party might interact with this code. different situation if you're pushing libraries to github/quicklisp.
<jmercouris>
You’ve nailed it
<jmercouris>
All of the advice so far has been given within the context of third party consumers and some robust foundation
<jmercouris>
When neither exist, it is a pointless exercise
<beach>
Sure. If you don't expose your code to anyone else, you can do whatever you want.
<lukego>
Thank you :)
<beach>
Who needs DEFSTRUCT anyway. You can just use CAR/CDR.
<lukego>
I can also understand that if you spend time teaching people to program in Lisp, you will want to be focusing on the best practices for doing this properly, since people can always use their judgement to take shortcuts later.
<jmercouris>
Not sure if your being sarcastic, but Eitaro would agree with you
<jmercouris>
You’re *
varjag has joined #lisp
<jmercouris>
He uses lists for everything!
<lukego>
I'm reading some ACL2 code that has page-long definitions on which each line is of the form (defun foo-quux (foo) (caddddddddddr foo))
<Xach>
there's also a big difference between "there's no reason for [the way defclass works]" and "i don't like how it works" or "the problems that it solves aren't that important to me" etc
<beach>
jmercouris: I am saying that DEFSTRUCT is already a way to make your code more modular and with defined protocols. If you don't think you need such things, there might be no point in using DEFSTRUCT either. Lists could be more flexible.
<Gnuxie[m]>
I hope you are including co-workers as third parties
<Xach>
change [the way defclass works] to whatever you like
<lukego>
so even for throw-away code I appreciate easy ways to get accessors, places to hang print functions, etc.
<jmercouris>
beach: agreed
galex-713 has quit [Ping timeout: 260 seconds]
<beach>
Gnuxie[m]: I include my future self as a third party.
<beach>
Gnuxie[m]: But that might be because of my notorious bad memory.
<lukego>
beach: that's a good point. in other languages I would do exactly that e.g. if they have pattern matching to make it convenient. could well be that in serapeum there are such facilities and some of my structs could be lists because I don't need dedicated accessor functions.
<Bike>
i wish structure objects were defined with defclass, and defstruct was a library macro to define accessors with convenient names
* lukego
makes mental note to read some idiomatic serapeum code e.g. implementation of serapeum itself
<Gnuxie[m]>
beach: that's wise
<Gnuxie[m]>
gives yourself less work in either case
<jackdaniel>
Bike: in the vast undefined behavior (defclass foo () () (:metaclass structure-class)) works on some implementations
<Bike>
yeah. that's nice.
<beach>
Bike: Your wish is my command! :)
<Bike>
mm hm
<jackdaniel>
ah, but adding slots doesn't work so nice
<splittist>
mixins and generic functions are a great way to allow for unforeseen behaviour modification. And every time I worry about performance I tell myself the world now runs on javascript over the network.
<lukego>
Gnuxie[m]: I do a lot of rewriting. I'll probably rewrite all this particular code at least a couple of times before I share it with anyone else. I've already rewritten much of it once.
<Bike>
you'd probably have to do something funky to ensure the class is defined at enough at compile time to allow subclassing
<Bike>
while keeping the fast access, i mean
<Shinmera>
splittist: My game engine makes heavy use of CLOS :)
sauvin_ has joined #lisp
<jackdaniel>
ah, that's it, I've tried redefining foo, when I define a "fresh" class, then I can put slots in there
<mfiano>
My game engine makes heavy use of structure-object and standard-object
<Bike>
defstruct has to do funky stuff of that kind. defstruct is kind of entirely funky stuff
<jackdaniel>
funcallable-standard-object idea is also cool
<Bike>
well, doesn't have to, but does if defstructs have any point over defclass
<Bike>
i'm pretty sure sbcl has funcallable structure objects
<jackdaniel>
well, they are mandated by mop
<Bike>
internally, obvs
VincentVega has joined #lisp
<Bike>
they are?
<VincentVega>
Hi! Is there a portable way to suppress a redefinition warning?
<jackdaniel>
ah, funcallable *structure* object
<jackdaniel>
I've meant *standard* :)
<Bike>
ah. yeah.
sauvin has quit [Ping timeout: 258 seconds]
<pve>
lukego: I once worked on an old application that stored everything (or a lot, anyway) in symbol plists. A curious design choice, but it did work..
<Bike>
i would also like upgraded-structure-slot-type and a pony.
<lukego>
pve: thank you for normalizing the use of whatever quirky representation one prefers in the privacy of one's own codebase :)
<jackdaniel>
I have a turtle and upgraded-array-type, will do? ,)
* jackdaniel
gets back to work
<Bike>
turtles are nice too.
<Xach>
If your program does something very useful, people will often adapt to it, rather than demand vice versa
<mfiano>
THat's a major problem with Lisp. People often care more about the code than the artifact
ikrabbe has quit [Ping timeout: 240 seconds]
<Xach>
It's a problem with many forms of endeavor - obsession with the tools and their proper use rather than the product of the tools. But there's no denying that a nice tool, used properly, is a delight.
<pve>
lukego: I just assumed it was a trendy style in the early 90's and left it at that :)
<lukego>
I'll admit that I allow myself to spend much more creative energy on editing Lisp code than most other languages. I enjoy that though. keeps me amused while I'm programming
* Xach
thinks of people who post pictures of their workbench and planes rather than the useful objects produced with them
<Shinmera>
I hate my level editor a whole lot, but simply don't have the time to make it nice.
<Shinmera>
In some ways, having deadlines and such pressures is good.
<Bike>
if you're a compiler dev your work is increasingly elaborate pictures of workbenches
<pve>
lukego: but to be fair, it was written mostly by computational linguists who only wanted to get the job done
<beach>
Shinmera: Do you have a deadline for your game?
ikrabbe has joined #lisp
<Shinmera>
Well the most pressing deadline is me running out of money, so I have to be very smart with that.
<beach>
Hmm, yes, I see.
<Shinmera>
Other than that we also have a release schedule we're aiming for, which is roughly 2 years from now.
Feldman has joined #lisp
<beach>
Deadlines far in the future are tough.
akoana has joined #lisp
cosimone has quit [Remote host closed the connection]
ikrabbe|2 has joined #lisp
slyrus has quit [Remote host closed the connection]
ikrabbe has quit [Ping timeout: 240 seconds]
<shka_>
see: the global warming
Major_Biscuit has quit [Ping timeout: 260 seconds]
slyrus has joined #lisp
curtosis has joined #lisp
t99_ has joined #lisp
t99 has quit [Ping timeout: 260 seconds]
slyrus has quit [Ping timeout: 268 seconds]
ikrabbe|2 is now known as ikrabbe
hiroaki has joined #lisp
karlosz has joined #lisp
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
davisr_ has joined #lisp
ikrabbe has quit [Ping timeout: 265 seconds]
<_death>
jackdaniel: I'm surprised ;).. I expected some resistance, at least for the draw-arrow stuff, if not the keybindings (which I supposed must have had some good reason not to be there in the last 20 years)
<jackdaniel>
_death: after testing them I've decided that they are fine (and minor)
davisr has quit [Ping timeout: 260 seconds]
<jackdaniel>
thanks!
kevingal has joined #lisp
<_death>
jackdaniel: cool :).. I also had to patch the coordinates stuff, which currently has exact comparisons incl. on floats that causes trouble with ellipses, but I noticed the commented version and some old mcclim-devel discussions and some issues on github so I thought another approach may be on the queue
<jackdaniel>
I want to change the ellipse representation from parralelogram to something more stable (transformation-wise)
<_death>
yeah, that's one of things I gathered.. the exact comparisons may caused issues elsewhere too
kevingal_ has quit [Ping timeout: 260 seconds]
<jackdaniel>
comparisons are one issue, but the current code can error because of a non-reversible transformation (due to rounding errors)
<jackdaniel>
i.e after trying to rotate the ellipse
bitmapper has joined #lisp
<_death>
right.. there are two issues.. the inversion is easy to reproduce with the Fig example, and the comparison is easy with https://www.artm-friends.at/rm/kytron/kytron-clim.html (after small tweaks to make it work)
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
sz0 has quit [Quit: Connection closed for inactivity]
galex-713 has joined #lisp
davisr_ is now known as davisr
notzmv has quit [Ping timeout: 240 seconds]
davisr has quit [Read error: Connection reset by peer]
davisr has joined #lisp
<_death>
I also have some changes to scigraph, but it may be that it doesn't work right only for me.. I guess the most annoying issue right now is the repeated mapping and unmapping (with lots of match error 42) that happens if I switch windows in stumpwm, usually once per application frame.. also, (setf clim:*default-server-path* :clx) looks cool and retro :)
Feldman has joined #lisp
<_death>
(to make clear, this issue is not limited to scigraph.. it often happens with any arbitrary application frame)
<jackdaniel>
the only moment I've worked with scigraph was the effort to make it "start"
<jackdaniel>
so I won't be much help with it :)
Sheilong has joined #lisp
davisr has quit [Ping timeout: 248 seconds]
dinnu93 has quit [Remote host closed the connection]
galex-713 has quit [Ping timeout: 248 seconds]
gitgood has joined #lisp
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
rgherdt has left #lisp ["Leaving"]
Feldman has joined #lisp
hypercube has quit [Ping timeout: 265 seconds]
monaliza has joined #lisp
galex-713 has joined #lisp
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
Jachy has joined #lisp
monaliza has quit [Quit: monaliza]
galex-713 has quit [Ping timeout: 248 seconds]
galex-713_ has joined #lisp
galex-713_ has quit [Ping timeout: 240 seconds]
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
hypercube has joined #lisp
sauvin_ has quit [Read error: Connection reset by peer]
<hypercube>
minion: source code
<minion>
please stop playing with me... i am not a toy
<gabc>
phoe: just received your book, thanks for making it :)
slyrus has joined #lisp
<phoe>
gabc: hope it serves you well
Keyboard1orrier has quit [Ping timeout: 240 seconds]
galex-713 has quit [Ping timeout: 248 seconds]
<albusp>
Trying to get sly working with emacs, currently I don't have slynk running (no lisp process active), and indenting code in *.lisp files gives the error "Symbol’s function definition is void: sly-common-lisp-indent-function". I'm checking sly.el and others, and found a line in slynk.lisp mentioning the function: https://github.com/joaotavora/sly/blob/e927cdae984b2c3383e1e2358e37f1a4115b142e/slynk/slynk.lisp#L3996.
<albusp>
Does this mean the indent function will appear after a slynk starts running?
<phoe>
albusp: do you by any chance have sly and slime installed/loaded at the same time?
<albusp>
no, I removed slime after issues.
<albusp>
slynk is not yet running because it doesn't compile on abcl (yet - i'm trying to fix it)
<albusp>
maybe I should try sbcl case to see if the indent is running. let's see...
slyrus has quit [Ping timeout: 248 seconds]
pjb has quit [Quit: upgrading to Bug Sure :-/]
<albusp>
yes, indent function appears after a slynk starts. :)
ebrasca has joined #lisp
Krystof has quit [Ping timeout: 240 seconds]
ljavorsk has quit [Ping timeout: 268 seconds]
Oladon has joined #lisp
curtosis has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
galex-713 has joined #lisp
thinkpad has quit [Ping timeout: 260 seconds]
thinkpad has joined #lisp
curtosis has joined #lisp
<contrapunctus>
"Who needs DEFSTRUCT anyway. You can just use CAR/CDR." lol I had to do a double take here, until I read the previous message 😄
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
galex-713 has quit [Read error: Connection reset by peer]
galex-713 has joined #lisp
g_SG has joined #lisp
slyrus has joined #lisp
notzmv has joined #lisp
skapata has joined #lisp
galex-713 has quit [Ping timeout: 248 seconds]
galex-713 has joined #lisp
slyrus has quit [Ping timeout: 246 seconds]
VincentVega has quit [Quit: Connection closed]
ukari has quit [Remote host closed the connection]
galex-713 has quit [Ping timeout: 248 seconds]
galex-713 has joined #lisp
ukari has joined #lisp
<logand``>
;
narimiran has quit [Ping timeout: 240 seconds]
supercoven_ has quit [Ping timeout: 260 seconds]
galex-713 has quit [Ping timeout: 248 seconds]
galex-713 has joined #lisp
seok has quit [Ping timeout: 248 seconds]
rogersm has joined #lisp
g_SG has quit [Ping timeout: 240 seconds]
Lord_of_Life_ has joined #lisp
galex-713 has quit [Ping timeout: 240 seconds]
jeosol has joined #lisp
slyrus has joined #lisp
Lord_of_Life has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
Lord_of_Life_ is now known as Lord_of_Life
amb007 has joined #lisp
silasfox has joined #lisp
slyrus has quit [Ping timeout: 240 seconds]
Feldman has joined #lisp
galex-713 has joined #lisp
<aeth>
Everyone comes into Common Lisp for different reasons so there's no real one true way to represent something. If you really wanted to just use conses for everything, though, CL isn't really the right language for that because they're not optimized. (destructuring-bind is a very nice macro for handling conses, though)
phossil has joined #lisp
silasfox` has joined #lisp
silasfox has quit [Ping timeout: 258 seconds]
rogersm has quit [Remote host closed the connection]
silasfox` has left #lisp [#lisp]
gigetoo has quit [Ping timeout: 260 seconds]
gigetoo has joined #lisp
kevingal has quit [Remote host closed the connection]
Krystof has joined #lisp
lawt has joined #lisp
yitzi has quit [Quit: yitzi]
slyrus has joined #lisp
galex-713_ has joined #lisp
galex-713 has quit [Ping timeout: 248 seconds]
curtosis has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
slyrus has quit [Ping timeout: 246 seconds]
contrapunctus has quit [Ping timeout: 248 seconds]
galex-713_ has quit [Ping timeout: 248 seconds]
galex-713 has joined #lisp
<jmercouris>
a way to (format "~a" 'symbol) in lowercase?
<jmercouris>
a directive for this?
<jmercouris>
(format nil "~a" 'symbol)
<_death>
~(
<jmercouris>
_death: ?
<jmercouris>
ah: (format nil "~(~a~)" 'symbol)
<_death>
you don't speak format directivish?
<jmercouris>
apparently I do :-D
<jmercouris>
just took me a second to realize what you meant
hiroaki has quit [Remote host closed the connection]
notzmv has joined #lisp
hiroaki has joined #lisp
galex-713 has quit [Read error: Connection reset by peer]
mindCrime_ has joined #lisp
ljavorsk has quit [Ping timeout: 240 seconds]
lawt has quit [Ping timeout: 248 seconds]
galex-713 has joined #lisp
notzmv has quit [Ping timeout: 246 seconds]
h4ck3r9696 has quit [Quit: Leaving.]
phossil_ has joined #lisp
galex-713 has quit [Ping timeout: 248 seconds]
mindCrime_ has quit [Ping timeout: 240 seconds]
t99 has joined #lisp
kmeow has joined #lisp
skapata has quit [Ping timeout: 260 seconds]
orivej has quit [Ping timeout: 240 seconds]
villanella has joined #lisp
wsinatra has quit [Ping timeout: 240 seconds]
galex-713 has joined #lisp
orivej has joined #lisp
h4ck3r9696 has joined #lisp
h4ck3r9696 has quit [Quit: Leaving.]
aartaka has quit [Ping timeout: 248 seconds]
skapata has joined #lisp
karlosz has quit [Quit: karlosz]
aartaka has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
lawt has joined #lisp
Sheilong has quit [Quit: Connection closed for inactivity]
aartaka_d has joined #lisp
hiroaki_ has joined #lisp
notzmv has joined #lisp
aartaka has quit [Ping timeout: 265 seconds]
notzmv has quit [Ping timeout: 260 seconds]
notzmv has joined #lisp
myall has joined #lisp
myall has quit [Changing host]
myall has joined #lisp
DHARMAKAYA has quit [Ping timeout: 246 seconds]
aartaka_d has quit [Ping timeout: 248 seconds]
orivej has quit [Ping timeout: 268 seconds]
<no-defun-allowed>
jmercouris: I think that if the result of evaluating X and X are equivalent, then you are saying that every evaluation has a fixed point.
phossil_ has quit [Quit: Konversation terminated!]
<no-defun-allowed>
That could be the case in e.g. Miranda or Haskell, as e.g. [x, y :: z] could evaluate to [1, 2, 3] which evaluates to [1, 2, 3] but not any Lisp.
<jmercouris>
I think when answering a question one should consider the context
random-nick has quit [Ping timeout: 260 seconds]
<jmercouris>
Answer to the audience skill level
<no-defun-allowed>
I think when using a word, one should consider what that word means.
<jmercouris>
Instead of giving a technically correct, but unhelpful response
<no-defun-allowed>
evaluates-to is not an equivalence relationship.
<jmercouris>
That’s not my point
<no-defun-allowed>
If it were, then e.g. X should always evaluate to 'X. I won't make an example for transitivity.
<jmercouris>
Not sure who you are explaining what to
Helmholtz has quit [Ping timeout: 265 seconds]
<no-defun-allowed>
You.
<jmercouris>
Oh I see
<jmercouris>
No need, I understand this concept already
ech has quit [Remote host closed the connection]
surabax has quit [Quit: Leaving]
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<no-defun-allowed>
So it would be evident why "equivalent" has a particular meaning when used in the context of Lisp evaluation?
notzmv has quit [Ping timeout: 260 seconds]
Feldman has joined #lisp
ech has joined #lisp
villanella has quit [Ping timeout: 260 seconds]
maiqthefalse has joined #lisp
DGASAU has quit [Ping timeout: 260 seconds]
<no-defun-allowed>
(Actually, that is probably not even the case in Haskell or Miranda. We might say 2 and 1 + 1 are equivalent forms, but an evaluator for one of those languages might reduce 1 + 1 to 2, but not the other way around.)
<sm2n>
blah blah referential transparency, they are equal within the denotational semantics of the language
<sm2n>
(in haskell or whatever)
<sm2n>
in pure fp things are given their identity by their normal form under reduction, by church-rosser or related
<sm2n>
(assuming your stuff terminates)
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
hiroaki_ has quit [Ping timeout: 248 seconds]
hiroaki has quit [Ping timeout: 248 seconds]
akoana has left #lisp [#lisp]
igemnace has joined #lisp
notzmv has joined #lisp
<phantomics>
Hey all, wondering if there's a library that converts HTML-encoded characters like " to Unicode. Tried some HTML parsers that didn't do it and can't see anything to do it on CL package lists
slyrus has joined #lisp
<raeda>
The numeric encoding is the code point number iirc. SBCL has unicode lookup by code point and you might be able to use CL-PPCRE to find & replace
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<raeda>
Not sure if there's any good way to convert the named escapes like <
KeyboardWorrier has joined #lisp
lotuseater has quit [Quit: ERC (IRC client for Emacs 27.1)]
sxmx has quit [Quit: WeeChat 3.1]
villanella has joined #lisp
phossil_ has joined #lisp
phossil has joined #lisp
mindCrime_ has joined #lisp
Oladon has joined #lisp
villanella has quit [Ping timeout: 240 seconds]
<Xach>
phantomics: see the html-entities system
Codaraxis has quit [Remote host closed the connection]
<moon-child>
no-defun-allowed, sm2n: no denotational semantics required, you can define equality strictly in terms of halting
Codaraxis has quit [Remote host closed the connection]
Codaraxis has joined #lisp
slyrus has quit [Remote host closed the connection]
<moon-child>
given two expressions e1 and e2 in some language L, consider the universe of hole-containing programs within L. For each of those programs, substitute each of e1 and e2 for the hole. If there's any case when e1 causes a halt and e2 does not (or vice versa) then the expressions are not equivalent
<moon-child>
otherwise they are
sxmx has joined #lisp
torbo has joined #lisp
phossil_ has quit [Quit: Konversation terminated!]
Codaraxis has quit [Remote host closed the connection]
Codaraxis has joined #lisp
<no-defun-allowed>
This is somewhat more interesting than arguing that EVAL is not an equivalence relation.