<ulfvonbelow>
heh, I'd say they both have their charm, but I do like the lack of opinion of CL, the gradual typing system, the simplicity of writing macros, and the fact that the standard designers thought of just about everything possible (want to specialize your data structure that requires an integer serialization to hold characters, but don't know how high a char-code can go? CHAR-CODE-LIMIT, built right into the standard!)
Guest-liao has quit [Quit: Ping timeout (120 seconds)]
<mzan>
I tried Typed Racket, and it seems very good in this regard. My first impression with CL and SBCL it is that it is all more professional and industrial grade.
Guest-liao has joined #commonlisp
pieguy128 has joined #commonlisp
asarch has joined #commonlisp
random-nick has quit [Ping timeout: 260 seconds]
selwyn has joined #commonlisp
Guest-liao has quit [Quit: Client closed]
selwyn has quit [Read error: Connection reset by peer]
Psybur has quit [Remote host closed the connection]
<hayley>
(It is for Lisp code, not that anyone cares, but I need to check how the instructions work. And I don't know where else you ask a question like that.)
brettgilio has quit [Read error: Connection reset by peer]
jsatk has quit [Ping timeout: 260 seconds]
iisi has quit [Ping timeout: 260 seconds]
iisi has joined #commonlisp
brettgilio has joined #commonlisp
jsatk has joined #commonlisp
rdrg109 has quit [Ping timeout: 260 seconds]
rdrg109 has joined #commonlisp
taiju has quit [Ping timeout: 260 seconds]
jealousmonk has quit [Ping timeout: 252 seconds]
tyson2 has quit [Remote host closed the connection]
taiju has joined #commonlisp
prxq has joined #commonlisp
prxq_ has quit [Ping timeout: 268 seconds]
Devon has quit [Read error: No route to host]
<White_Flame>
copec: files could be brought together arbitrarily, you could have your own potentially overlapping groupings of views of related toplevel forms, you could have some things (or just their docstrings) always in view for reference, etc
<White_Flame>
s/files/functions/
<White_Flame>
the model of each having a fixed place in a linear file and only a file-based view is limiting and fundamentally disorganized
<White_Flame>
and yes, the actual storage doesn't have to match what's onscreen at all in terms of how it composes into a saved artifact
<White_Flame>
it's similar to not having to manually deal with the b-tree structures in your database when you're just grabbing rows or browsing tables
<White_Flame>
the file's specific format & on-disk layout should just be a hidden implementation detail
<White_Flame>
however, CL would have to change, as its toplevel forms are not necessarily unordered declarations, but ordered mutations to an image or compilation unit state
<beach>
Good morning everyone!
<White_Flame>
y
<White_Flame>
y0
semz has quit [Ping timeout: 245 seconds]
semz has joined #commonlisp
opcode has quit [Quit: WeeChat 3.3]
opcode has joined #commonlisp
skeemer__ has joined #commonlisp
skeemer has quit [Remote host closed the connection]
jealousmonk has joined #commonlisp
jealousmonk has quit [Client Quit]
Bike has quit [Quit: Lost terminal]
srhm has quit [Ping timeout: 265 seconds]
taiju has quit [Ping timeout: 265 seconds]
Guest-liao has joined #commonlisp
taiju has joined #commonlisp
ulfvonbelow has quit [Remote host closed the connection]
ulfvonbelow has joined #commonlisp
ulfvonbelow has quit [Ping timeout: 260 seconds]
ulfvonbelow has joined #commonlisp
frgo has quit [Remote host closed the connection]
asarch has quit [Quit: Leaving]
taiju has quit [Ping timeout: 260 seconds]
igemnace has quit [Ping timeout: 260 seconds]
gaqwas has joined #commonlisp
Lord_of_Life has quit [*.net *.split]
Mandus_ has quit [*.net *.split]
jeosol has quit [*.net *.split]
luna-is-here has quit [*.net *.split]
sm2n has quit [*.net *.split]
jcowan has quit [*.net *.split]
aeth has quit [*.net *.split]
mzan has quit [*.net *.split]
borodust has quit [*.net *.split]
mingus has quit [*.net *.split]
samebchase has quit [*.net *.split]
igemnace has joined #commonlisp
snits has joined #commonlisp
Spawns_Carpeting has quit [Ping timeout: 265 seconds]
pve has joined #commonlisp
<pjb>
About cryptography, C compilers can also perform optimizations that could be counter-productive to the security of the cryptographic system. Even writing it in assembler is not a guarantee, since the processor itself may have optimization features or other. It may be difficult to find in a processor, instructions that wouldn't leak some RF or some power usage depending on the data being processed.
<pjb>
That said, those cryptographic system requirements are not something that can be dealt with at the language level, but at the implementation level.
<pjb>
It is therefore quite possible to design an implementation with an option to generate code that would be adequate to implement cryptgraphic systems.
<madnificent>
pjb: with infinite research budget, introducing unexpected changes into the layers of abstraction sounds like a great way to create issues which are nearly impossible to catch during a code review. one could even introduce them on another layer after the code has been reviewed.
<madnificent>
I strongly suspect our reality is much simpler and that many issues found in systems are far simpler than incompatibilities between the layers of abstraction but it would be a cool thing to pursue.
frgo has joined #commonlisp
makomo has joined #commonlisp
taiju has joined #commonlisp
frgo has quit [Ping timeout: 252 seconds]
frgo has joined #commonlisp
cranium has joined #commonlisp
igemnace has quit [Remote host closed the connection]
<jackdaniel>
madnificent: but this comes even without such unobvious things like encryption. you assume that when you write a conforming program you are safe, but implementations have bugs and even interpret differently some parts; there may be changes inside the compiler you did not anticipate
<pjb>
madnificent: well, implementing an algorithm can be validated. In cryptography, the problem is that it's not sufficient to have a correct algorithm. The code must be written so as to minimize physical and logical side effects induced by the execution of the correct code, that could lead to leaking information about the keys or other cryptographic elements.
<pjb>
Already, running on a VM is bad, since the VM can see what's occuring. But there are solutions: white-box cryptography, where the key are encrypted, and kept encrypted when used.
<pjb>
But other statistical properties about the keys could be detected from temperature, power, speed variations (physical phenomenon outside of the direct influence of the algorithm and code).
Cymew has joined #commonlisp
<pjb>
Perhaps (setf x (* 2 x)) produces more heat when x is full of 1s instead of full of 0s? Perhaps (setf x (ash x 1)) produces the same heat in both cases?
<pjb>
Depends on the compiler and hardware. Algorithmically, it's the same. Both codes are correct.
<pjb>
What I'm saying is that it's better to have a compiler option to let it ensure that the code generated from both forms minimize the heat produced and execution speed variation.
<pjb>
Actually, that it's the only way to ensure that the cryptographic system requirements are met.
<pjb>
You must include in the requirement fulfillment the specific compiler and hardware, to validate the cryptographic system.
<pjb>
So, write all the cryptographic code you want, it's not up to the programmer to ensure validity of the final cryptographic system, but up to the integrator who will select the compiler and compiler options, and the hardware.
cosimone has joined #commonlisp
<pjb>
Of course, the designers of cryptographic algorithms can help by avoiding things like "if bit 0 of x is 1 then do-something-taking-little-time-and-energy else do-somethign-taking-a-lot-of-time-and-energy".
<pjb>
But as programmers, as long as we implement the algorithms, we've done our job.
mingus has quit [Ping timeout: 252 seconds]
aartaka has joined #commonlisp
Cymew has quit [Remote host closed the connection]
frgo has quit [Remote host closed the connection]
gaqwas has quit [Ping timeout: 245 seconds]
Guest-liao has quit [Ping timeout: 256 seconds]
notzmv has quit [Ping timeout: 245 seconds]
Guest-liao has joined #commonlisp
hendursa1 has joined #commonlisp
hendursaga has quit [Ping timeout: 276 seconds]
makomo has quit [Ping timeout: 252 seconds]
Guest-liao has quit [Quit: Client closed]
notzmv has joined #commonlisp
selwyn has joined #commonlisp
taiju has quit [Ping timeout: 252 seconds]
cosimone` has joined #commonlisp
cosimone has quit [Ping timeout: 252 seconds]
Qwnavery has joined #commonlisp
heisig has joined #commonlisp
<JeromeLon>
Are there any active projects to make a new lisp IDE or to make alternative/radical improvements to emacs/slime? Code or variable extraction, inlining, renaming, real-time warnings, smarter completion, are all taken for granted nowadays, but are not available when using emacs. Presumable these all require the editor to have a deeper understanding of what each character means, which in turns
<JeromeLon>
would requires swank to expose a knowledge that goes beyond its capabilities.
<beach>
Yes, we are working on an IDE but progress is slow.
<beach>
... mainly be cause we are both busy with other things.
<JeromeLon>
anything you can share about this project?
<beach>
Then the plan is to run the code through the first phase(s) of a compiler-like think to determine determine the role of each expression.
<beach>
From that result, we compute indentation (which I kind of know how to do, but that I haven't worked out the mechanics of yet) and highlighting information.
hendursa1 has quit [Remote host closed the connection]
hendursaga has joined #commonlisp
Mandus_ has quit [Ping timeout: 264 seconds]
azimut_ has quit [Ping timeout: 276 seconds]
Mandus_ has joined #commonlisp
frgo has joined #commonlisp
<beach>
pjb: Wow, MIT LOOP is worse than what you pointed out. This is SBCL: (loop for x in '(a b c) append (cons x 'foo)) => (a b c . foo)
<beach>
and (loop for i from 1 to 2 if (oddp i) append (cons 'a 'b) else collect 'c) => (a c)
Mandus_ has quit [Ping timeout: 268 seconds]
Mandus_ has joined #commonlisp
makomo has quit [Ping timeout: 252 seconds]
Mandus_ has quit [Ping timeout: 268 seconds]
<beach>
pjb: (defparameter *l* '(c d)) (tailp *l* (sicl-loop:loop for l in (list '(a b) *l*) append l)) => T
<beach>
pjb: (defparameter *l* '(c d)) (tailp *l* (cl:loop for l in (list '(a b) *l*) append l)) => NIL
Mandus_ has joined #commonlisp
Inline has joined #commonlisp
<beach>
pjb: (sicl-loop:loop for x in '(a b c) append (cons x 'foo)) => type-error
<beach>
pjb: (cl:loop for x in '(a b c) append (cons x 'foo)) => (a b c . foo)
ahc has joined #commonlisp
Mandus_ has quit [Ping timeout: 245 seconds]
<beach>
In https://github.com/robert-strandh/SICL/tree/master/Code/Loop there are three files collect-clause.lisp, append-clause.lisp, and nconc-clause.lisp where I changed the methods on BODY-FORM specalized to COLLECT-FORM-CLAUSE, APPEND-FORM-CLAUSE, and NCONC-FORM-CLAUSE respectively. But there is significant duplication, and I did not change the methods specialized to the -IT- or -INTO- clauses. If someone feels like fixing the existin
<beach>
duplication and changing the remaining methods, feel free.
<beach>
Then run the test suite.
<beach>
Also, ANSI tests should be added for the issues I indicated above.
Mandus_ has joined #commonlisp
<beach>
That someone could also extract the entire LOOP code to a separate repository. Then we would have a LOOP library that is much more conforming that what most implementations currently have.
<beach>
Oops, forgot to push the update.
<beach>
There.
<jackdaniel>
doesn't part about append fall into "undefined behavior"? the loop append is specified to exact as the function append and the latter says that arguments (except for the last one) must be proper lists, but doesn't mention what happens when they are not
<jackdaniel>
in contrary to tailp which mentions the exceptional situation
<jackdaniel>
s/exact/behave/
amb007 has quit [Ping timeout: 245 seconds]
Mandus_ has quit [Ping timeout: 252 seconds]
amb007 has joined #commonlisp
<beach>
You might be right. Let me check the dictionary entry for APPEND.
molson__ has joined #commonlisp
Mandus_ has joined #commonlisp
<beach>
Yes, you are right.
<beach>
So SICL LOOP conforms to WSCL as well as to the Common Lisp standard. :)
<beach>
On the other hand, SBCL APPEND signals an error, and LOOP is supposed to behave as if APPEND were used.
<beach>
"... as if they were arguments to the function APPEND."
molson_ has quit [Ping timeout: 245 seconds]
ahc has quit [Quit: Client closed]
<jackdaniel>
I'd interpret that: so if they are not proper lists, then undefined consequences follow - expecting uniform undefined consequences would be quite a requirement ;)
<beach>
It is not terribly important. What is important is that it is better to have a stricter LOOP version than a sloppier one.
<beach>
But, yes, your interpretation is valid.
<beach>
Also, I encourage people to replace the native version of LOOP by the SICL one, because it is more strict. Xach has been known to do this to check whether systems in Quicklisp are conforming.
<beach>
And I encourage maintainers of Common Lisp systems to load SICL LOOP as a replacement for the native one, unless the native one is as conforming of course.
<beach>
Anyway, time for a lunch break. I'll screen all the candidates when I get back, and make a long list sorted by experience, availability, and attitude.
gaqwas has joined #commonlisp
frgo has quit [Remote host closed the connection]
<Gnuxie>
candidates?
selwyn_ has joined #commonlisp
<jackdaniel>
people who will replace loop of the implementation of their choosing and maintainers who will replace loop in the implementation
<jackdaniel>
(I think)
makomo has joined #commonlisp
selwyn has quit [Ping timeout: 260 seconds]
<beach>
Yes, s/candidates/applicants/
gaqwas has quit [Ping timeout: 250 seconds]
Mandus_ has quit [Ping timeout: 245 seconds]
attila_lendvai has quit [Ping timeout: 260 seconds]
Mandus_ has joined #commonlisp
theBlack1ragon has joined #commonlisp
theBlack1ragon has quit [Client Quit]
amb007 has quit [Ping timeout: 245 seconds]
selwyn__ has joined #commonlisp
selwyn_ has quit [Ping timeout: 260 seconds]
amb007 has joined #commonlisp
random-nick has joined #commonlisp
amb007 has quit [Ping timeout: 252 seconds]
amb007 has joined #commonlisp
Guest-liao has joined #commonlisp
amb007 has quit [Ping timeout: 260 seconds]
amb007 has joined #commonlisp
<_death>
beach: nice, I tried testing one of my systems with sicl-loop, and it found a nonstandard loop form, the usual (loop while ... for ...) which again filled me with knee-jerk anti-loopism and made me replace it with DO
<hayley>
What's wrong with good ol' (loop for nil = (when blah (return)) for x = y ...)
<_death>
tagbodies, tagbodies everywhere
<skeemer__>
does common lisp support having tests within the same file of the implementation such as racket ?
<jdz>
skeemer__: Tests are code, and yes, code can be put with other code.
<jdz>
Another question is whether one should.
mingus has joined #commonlisp
rogersm_ has joined #commonlisp
<ecraven>
skeemer__: it all depends on your test framework / library
<skeemer__>
ecraven, what test framework od you suggest? what is the most used one?
NeoCron has joined #commonlisp
<ecraven>
unfortunately, I have no idea ;)
<hayley>
I like Parachute.
<jackdaniel>
recently there was a lenghy comparison blogpost about test frameworks
<jackdaniel>
the most popular seems to be fiveam, then many people hold dear lift and/or parachute
<hayley>
I used to use fiveam, but then ported to Parachute. Can't remember why though.
<skeemer__>
what do users of common lisp think about clojure? what are the drawbacks of it?
<skeemer__>
wrt common lisp
<mfiano>
Too much hand holding. Not enough "stay out of my way and let me code how I want".
<hayley>
I like objects.
Guest-liao has quit [Ping timeout: 256 seconds]
frgo has joined #commonlisp
<jackdaniel>
Clojure was designed by a person with specific needs and opinions while Common Lisp standard is a result of trying to accomodate various needs of different parties
<skeemer__>
mfiano, hand holding for what?
Guest-liao has joined #commonlisp
<mfiano>
Pretty much everything. It is a very opinionated language.
<hayley>
Cliff Click once rated using STM for side effects a "double unsmiley", though I think I might have some use for it in CL code.
<jackdaniel>
that leads to a situation that clojure as a language promotes "the right way" (whatever that means for the language) while common lisp as a language supports you in implementing whatever abstraction you like
<jackdaniel>
in the worst case scenario this whatever abstraction is a garbage :)
<mfiano>
I'm not a fan of "gimmick languages". Clojure is no exception.
attila_lendvai_ has quit [Quit: Leaving]
attila_lendvai has joined #commonlisp
Tomte has joined #commonlisp
Tomte has quit [Client Quit]
Tomte has joined #commonlisp
<beach>
_death: That's a strange reaction.
amb007 has quit [Ping timeout: 264 seconds]
amb007 has joined #commonlisp
<hayley>
Well, I used FOR NIL = ... in my least favourite module, which does something tricky with locks. Not that translating it to DO would help, but it might be a sign that something has been designed wrong.
azimut has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
dec0d3r has quit [Remote host closed the connection]
<hayley>
Out of curiosity, has anyone considered modifying Ironclad to use the x86-64 extensions for SHA1 and SHA2 operations? I noticed that they have accelerated AES already, but I can't find much on hashing.
Cymew has joined #commonlisp
tyson2 has joined #commonlisp
euandreh has quit [Ping timeout: 265 seconds]
<yitzi>
*no-defun-allowed*: I would find an accelerated SHA2 (including digests) in its own library very useful. I know they are talking about making Ironclad more modular.
Bike has joined #commonlisp
<pjb>
beach: appending non-proper-lists seems correct; it's implementation dependent anyways. #+ccl (loop for x in '(a b c) append (cons x 'foo)) #| --> (a b c . foo) |# (append '(a . b) '(c . foo)) #| ERROR: The value b is not of the expected type list. |# but indeed, append signals an error.
<pjb>
(loop for i from 1 to 2 if (oddp i) append (cons 'a 'b) else collect 'c) #| --> (a c) |# (nconc (append '(a . b)) 'c) #| --> (a . c) |#
<pjb>
hmmm collect not nconc… (append (append '(a . b)) (list 'c)) #| ERROR: The value b is not of the expected type list. |#
<pjb>
beach: congratulation for sicl-loop being conforming! :-)
<beach>
Yes, it is undefined behavior.
<beach>
Thank you!
jeosol has quit [Remote host closed the connection]
Jach has joined #commonlisp
<pjb>
beach: but still, I think that wscl should do something about it, because in the case where we append into a variable, at each step, the last element should not be copied (I would infer that intention from the specification); this would be quite impractical.
<beach>
I totally agree, which is why I made SICL LOOP do the right thing.
euandreh has joined #commonlisp
<beach>
It wasn't very hard. I just do a "lazy copying" of CONS cells.
<beach>
A suffix of the accumulated list that has been attached by APPEND is copied only when new stuff is attached.
<beach>
Very simple.
<pjb>
Yes, after all, just a matter of ordering in the loop body…
<beach>
Exactly.
robin has quit [Remote host closed the connection]
robin has joined #commonlisp
azimut has quit [Ping timeout: 276 seconds]
azimut_ has joined #commonlisp
<beach>
I no longer accept applications from potential loop maintainers for the abstractions I suggested (because I implemented them myself). But if someone wants to extract the entire module to a separate repository and work on it there, I am still interested.
OlCe` has quit [Quit: ERC (IRC client for Emacs 27.1)]
<beach>
They did with CLIM. In #clim they would know more.
<beach>
But McCLIM is a better CLIM implementation that theirs, I believe.
<lisp123>
I see
<lisp123>
I wonder how Allegro Serve compares vs Hunchentoot
<lisp123>
Hmmm "AllegroServe works on all versions of Allegro Common Lisp since 6.0." --> Guess it might not be portable
<beach>
That phrase does not imply what you said.
<lisp123>
No it doesn't
<yitzi>
AllegroServe is LGPL I believe.
Guest-liao has quit [Quit: Client closed]
cosimone has quit [Remote host closed the connection]
xsperry has quit []
<lisp123>
I see
<lisp123>
They seem to get a bad rap while LispWorks gets a good one
<lisp123>
(between the paid distributions of course)
CptKirk has joined #commonlisp
srhm has joined #commonlisp
srhm has quit [Read error: Connection reset by peer]
knobo has quit [Ping timeout: 256 seconds]
srhm has joined #commonlisp
cranium has quit [Quit: Leaving]
molson__ is now known as molson
igemnace has joined #commonlisp
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
tyson2 has joined #commonlisp
srhm has quit [Ping timeout: 250 seconds]
srhm has joined #commonlisp
jeosol has joined #commonlisp
makomo has quit [Ping timeout: 252 seconds]
notzmv has quit [Ping timeout: 260 seconds]
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
kevingal has joined #commonlisp
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Ping timeout: 265 seconds]
amb007 has joined #commonlisp
tyson2 has joined #commonlisp
amb007 has quit [Ping timeout: 252 seconds]
amb007 has joined #commonlisp
<frgo>
lisp123: I do use AllegroCL Enterprise Edition currently and have been using Lispworks in the past. As you may be aware, the value (i.e. usefulness, applicability, flexibility, a.s.o) depends on the actual use cases. Whatever someone else says about a *tool* (LW and ACL are not enduser apps) like these CL implementations, may be entirely biased. I do have use cases where only ACL fits.
makomo has joined #commonlisp
waleee has joined #commonlisp
makomo_ has joined #commonlisp
<pve>
frgo: does the use case involve AllegroGraph?
<frgo>
Well, yes, it does.
<pve>
ok
<lisp123>
frgo: Thanks & Agree
Spawns_Carpeting has joined #commonlisp
dstein64 has quit [Ping timeout: 264 seconds]
aeth has quit [Ping timeout: 265 seconds]
<JeromeLon>
sbcl newbie here. I can't get sbcl to step into a function call, it's as if any function call leaves the debugger. What am I missing?
aeth has joined #commonlisp
lottaquestions has quit [Ping timeout: 246 seconds]
mfiano has quit [Ping timeout: 250 seconds]
lottaquestions has joined #commonlisp
dstein64 has joined #commonlisp
<JeromeLon>
With the following:
mfiano has joined #commonlisp
<JeromeLon>
(declaim (optimize (speed 0) (space 0) (debug 3))) (defun f2 () (format t "hello~%")) (defun f1 () (break) (f2) (format t "a~%"))
<lisp123>
Seems to work
<lisp123>
(step (f1 3))
<JeromeLon>
I am getting to "Evaluating call: (F2) With arguments: [Condition of type STEP-FORM-CONDITION]", press s, and everything else runs without any debug step
<lisp123>
CS325-USER> (step (f1))
<lisp123>
hello
<lisp123>
a
<lisp123>
NIL
makomo_ has quit [Quit: WeeChat 3.2]
CrashTestDummy3 has joined #commonlisp
makomo_ has joined #commonlisp
<lisp123>
After immediately running it, I get "Evaluating call: (F1) With Arguments ...."
amb007 has quit [Read error: Connection reset by peer]
<lisp123>
Then I pressed 0 to [STEP-CONTINUE]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
<JeromeLon>
lisp123: precisely. I was expecting to be able to [S]tep into the (f2) expression call, then to [s]tep into the format call.
amb007 has joined #commonlisp
<Bike>
well, format probably wasn't compiled with stepping
<JeromeLon>
But as soon as I step into "(f2)" everything else runs in one go.
<lisp123>
JeromeLon: Okay, sorry I understand what you mean and get the same. See Bike's comments above I guess
<Bike>
also, with a constant format string, sbcl is probably going to not actually call format in the compiled code... i don't know if (debug 3) disables that
CrashTestDummy2 has quit [Ping timeout: 252 seconds]
kevingal has quit [Remote host closed the connection]
<JeromeLon>
Bike: oh, right, so format is not a good one to experiment. I have a much bigger case that doesn't work, and was hoping to exhibit my issue with this minimal case using format. I'll come up with a better example and come back. Thanks!
amb007 has quit [Ping timeout: 265 seconds]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<JeromeLon>
Yes, that was it. A lot of stuff is optimized away despite (debug 3). Adding some (setq x (+ x 42)) everywhere makes everything work.
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
<skeemer__>
people is anybody here using SLIME while also using evil mode?
<skeemer__>
i can't understand how to navigate the history of the repl...
<lisp123>
skeemer__: I do but I'm not an advanced user
hendursaga has quit [Remote host closed the connection]
<skeemer__>
me neither lisp123
<lisp123>
skeemer__: This may help (add-to-list 'evil-emacs-state-modes 'eww-mode)
<lisp123>
If you can figure out which mode Evil is affecting you, you can set to revert to Emacs state
hendursaga has joined #commonlisp
<lisp123>
for that
<lisp123>
If you mean navigating via M-p and M-n, it seems to work well for me in normal mode
<Arcsech>
I use SLIME with evil but my solution is just: don't use the repl history so not super helpful 🤷
<skeemer__>
lisp123, ok i was missing the M-p M-n
<skeemer__>
thanks a lot
<lisp123>
Welcome :)
<skeemer__>
lisp123, although you said you are a beginner you solved my problem thanks
<skeemer__>
i am very excited with common lisp
<skeemer__>
seems a reasonable lisp
<lisp123>
Is your background Scheme or another Lisp?
synbian has joined #commonlisp
<synbian>
hello
<lisp123>
(Common Lisp is great, but this is #commonlisp channel, so it might be a biased view ;)
<synbian>
all will become lisp btw
<skeemer__>
lisp123, yeah i started with scheme
<skeemer__>
lisp123, i think scheme is not approachable by beginners for real world practical projects, seemed to fragmented, except racket
<skeemer__>
which some somebody is not reallyh a scheme anymore
<lisp123>
synbian: Yes, indeed. Lisp is the singularity of all higher level programming languages
<synbian>
i see the complete oposity skeemer__, data types on racket is too verbose and also the way the language is evolve to become some kind of java for lisps...
<lisp123>
skeemer__: Yes I found the same, I like Scheme as well (especially built in continuations), but for anything serious, Common Lisp seems to be a much better platform
<synbian>
and is, mustely because of MACROs, CL is the lisp for macros, sorry little schemer...
<skeemer__>
lisp123, i also saw that there is an idea of saving data as s-expression as a sort of small file databases... is this a lispy thing?
<lisp123>
skeemer__: I'll let someone more experienced come back to you on that. (I think there are various considerations / issues when serialising data, for example the state of the image at the time when you write the s-expressions to file vs. when you read them)
<Arcsech>
I mean, it's hella easy (in the simple case at least) because you can just `PRINT` it out and the `READ` it back in, which is enabled by the lispiness, but just writing out representations of data structures to small files like that isn't especially lispy.
<Arcsech>
But like any other language you'll hit edge cases and security concerns and it's probably best to just use sqlite from the start if you need to save files to a disk but don't really care about how that's done
<lisp123>
Its a Lisp Library that lets you add a few words to your class definitions and get them to automaically save to file
<Arcsech>
Looks weird, I'll have to check it out. I have some concerns about how that would work long-term or in a production setting but it's cool
<lisp123>
Every time you create a class instance, it writes to the data store, you can then read instances based on their properties
<lisp123>
Arcsech: I use BKNR in conjunction with XML for a "backup" solution. The authors are pretty well regarded so I think its quite robust. You could substitute SQLite for XML (but you would have to write that code yourself)
<Arcsech>
It seems like in a long-running system you'd build up enough instances that loading the dribble file (or whatever its called) would be slow. And your data set needs to fit in memory. As long as you're okay with those limitations it seems like it might be neat to use.
<lisp123>
Agree
<Arcsech>
I'd also want to know what the implementation looks like, the naive implementation of this would be semi-likely to lose data in the event of a crash/power failure/etc
lisp123 has quit [Quit: Leaving...]
lisp123 has joined #commonlisp
lisp123 has quit [Client Quit]
cosimone has joined #commonlisp
lisp123e has joined #commonlisp
notzmv has joined #commonlisp
lisp123e has left #commonlisp [#commonlisp]
tyson2 has joined #commonlisp
waleee has quit [Ping timeout: 268 seconds]
synbian has quit [Ping timeout: 250 seconds]
lisp123 has joined #commonlisp
amb007 has quit [Ping timeout: 265 seconds]
amb007 has joined #commonlisp
Tomte has quit [Quit: Leaving]
amb007 has quit [Read error: Connection reset by peer]
cosimone has quit [Remote host closed the connection]
amb007 has joined #commonlisp
waleee has joined #commonlisp
lottaquestions has quit [Ping timeout: 260 seconds]
rogersm_ has quit [Quit: Leaving...]
rogersm has joined #commonlisp
rogersm has quit [Quit: Leaving...]
lottaquestions has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
cage has joined #commonlisp
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
<skeemer__>
can't understand if he is a respected member of the community or not, because it seems to talk bad about weverything lisp but still uses lisp
<pjb>
skeemer__: he's a weirdo, but he still contributes some nice pages.
<semz>
I don't think Xah Lee can be categorized
<skeemer__>
he was talking about race and stuff like that
<skeemer__>
seemed weird
<skeemer__>
actually
<pjb>
skeemer__: at least he was clothed in this video!
<pjb>
(incf semz)
<skeemer__>
ahahaha wtf???
<pjb>
really…
<skeemer__>
pjb, well he said that the infix syntax lisp used is stupid and harder to read
<skeemer__>
pjb, he is the same xach who is on this channel?
<Arcsech>
I don't know of any other `xach`s in the lispiverse
<etimmons>
skeemer__: The person you linked to is Xah Lee (no c)
<etimmons>
so no, the xach in this channel is not Xah Lee
<Arcsech>
Ah, that's what that was in reference to. Yeah, xach's homepage is https://xach.com/lisp/
<skeemer__>
ohh okok thanks etimmons Arcsech
aartaka has quit [Ping timeout: 252 seconds]
makomo has quit [Ping timeout: 245 seconds]
pve has quit [Quit: leaving]
gaqwas has joined #commonlisp
aeth has quit [Ping timeout: 264 seconds]
aeth has joined #commonlisp
<pjb>
skeemer__: not at all. He's Xah Lee, (not Xach). Our Xach who wrote quicklisp is Zach Beane https://www.xach.com
<skeemer__>
ok thanks pjb
<pjb>
Preceeded by Arcsech ;-)
<skeemer__>
pjb, i was wondering if the book "land of lisp" illustrates also how to do games with graphics
<pjb>
skeemer__: I've not read it, but the echoes I've had from it, don't reflet it as a very good CL book. It seems to be full of personal idiosyncrasies.
<pjb>
skeemer__: better ask in #lispgames for state of the art graphics in games.
<skeemer__>
thanks pjb
<pjb>
skeemer__: I'd say the graphics situation in CL is complicated…
<skeemer__>
pjb, why do you say it is complicated?
<skeemer__>
there are no good ways to do graphics in it?
<pjb>
Because there's a lot of choices that will depend on your implementations and on the target platform, and on the application, and the portability level you want.
<pjb>
There are certain good ways to do graphics in CL. It's a general problem.
<skeemer__>
pjb, i just care about linux
<skeemer__>
x86_64
<pjb>
For example, you could consider McCLIM as a "pure" CL option.
<pjb>
(therefore portable, but only where McCLIM backend exist).
<pjb>
On linux you could use plain X11, but it's a little raw. So often people will prefer to use some graphic/GUI library, but this means you will use it thru FFI.
<pjb>
(plain X11 has the advantage that you can talk to the X11 server using sockets directly from lisp).
<pjb>
Just browse that cliki page and see for yourself…
<pjb>
Let's say that in general you will have other constraints that will direct your choice.
<pjb>
So, apart from McCLIM, since the AI winter and the fall of the lisp machines, we haven't had any native lisp graphic system.
<pjb>
Even if eg. X11 was prototyped in lisp originally (hence the X11 keysym = key symbol represented as 29-bit integers (ie. fixnums with 3 tag bits!)).
<pjb>
For games, there are a lot of different games with different requirements for graphics. From 3D real-time fist-person shooters where you'd want to run stuff on the GPU, down to games like Hangman: https://cliki.net/com.informatimago.hangman where the graphical aspect is only a cherry on the cake, and could be implemented with any means.
aeth has quit [Ping timeout: 245 seconds]
<skeemer__>
pjb, i would have liked something similar to racket 2htdp/image or 2htdp/universe to create animations and stuff like that
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 245 seconds]
<pjb>
skeemer__: opengl or sdl can also be used.
<pjb>
There are nice games written in lisps, ask in #lispgames.
aeth has joined #commonlisp
Lord_of_Life_ is now known as Lord_of_Life
<skeemer__>
thanks a lot pjb you have been very helpful and kind
heisig has quit [Quit: Leaving]
akoana has joined #commonlisp
xaotuk has joined #commonlisp
asarch has joined #commonlisp
asarch has quit [Read error: Connection reset by peer]
cosimone has quit [Remote host closed the connection]
asarch has joined #commonlisp
khrbt has quit [Ping timeout: 265 seconds]
asarch has quit [Remote host closed the connection]
<skeemer__>
people what do i use to parse command line arguments and options ?
<danirukun[m]>
I setup SLIME in Emacs, but for the life of me can't remember how to get autocomplete to work in Lisp buffers, which seems like something SLIME would just do out of the box.
asarch has joined #commonlisp
asarch has quit [Remote host closed the connection]
<JeromeLon>
danirukun[m]: c-c tab?
dre has quit [Remote host closed the connection]
asarch has joined #commonlisp
dre has joined #commonlisp
asarch has quit [Client Quit]
akoana has left #commonlisp [#commonlisp]
dec0d3r has joined #commonlisp
<danirukun[m]>
JeromeLon: I see, but is it possible to also get it as an interactive dropdown with candidates at point, like it is in this one completion box package (can't remember the name)