<pjb>
serichsen: the problem is worse: you cannot access slots (even :allocation :class slots) without an instance!
fikka has joined #lisp
<kenster>
pjb: ah okay
fikka has quit [Ping timeout: 240 seconds]
<pjb>
kenster: now, notice that I used make-symbol. This doesn't intern the symbol. This show that you could just use gensym there, without concatenate etc.
<kenster>
oddly I still get
<kenster>
error:
<kenster>
(during macroexpansion of (DEFCMETHOD UPLOAD-SESSION
<kenster>
...))
<kenster>
There is no class named FILEBUCKET::UPLOAD-SESSION.
karlosz has quit [Quit: karlosz]
<kenster>
right, that makes sense
<pjb>
Right. Wrap the defclass in an (eval-when (:compile-toplevel :load-toplevel :execute) …)
<pjb>
I only tested it without compiling.
nickenchuggets has joined #lisp
moei has quit [Quit: Leaving...]
<pjb>
kenster: also, since as you can see you cannot access the struct-name slot without making an instance, usually class attributes are just kept in global variables. In this case, you need a map between class name and structure name in the compilation environment for use at macroexpansion time. You could keep this map in a global variable (a hash-table), and fill it with a specific macro. Or you could write your own class definini
<pjb>
macro that could expand into this at compiliation time, and the defclass form for run-time.
<kenster>
okay well I also had to remove read-only, that's only for structs
<kenster>
right
<pjb>
Didn't you read my source? I corrected your defclass form too!
<pjb>
kenster: this is because you compute the names instead of taking them as parameter to your macros.
<pjb>
kenster: cffi-method-name is not the name of the function defined with defcfun in cffi-defun, therefore no such function exist.
<kenster>
how do lightning fast spot this pjb, experience? lol
<pjb>
Yes.
<pjb>
Have fun! Good night!
<kenster>
thanks for the help, night
fikka has quit [Ping timeout: 260 seconds]
zachk has quit [Quit: Leaving]
dddddd has quit [Remote host closed the connection]
fikka has joined #lisp
smasta has joined #lisp
eli_oat has quit [Quit: Leaving.]
fikka has quit [Ping timeout: 265 seconds]
eli_oat has joined #lisp
karlosz has joined #lisp
fikka has joined #lisp
nydel has joined #lisp
eli_oat has quit [Quit: Leaving.]
eli_oat has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
rumbler31 has joined #lisp
lumm has quit [Quit: lumm]
siraben has joined #lisp
sjl has quit [Ping timeout: 248 seconds]
Patzy has quit [Ping timeout: 256 seconds]
Patzy has joined #lisp
fikka has joined #lisp
knicklux has joined #lisp
knicklux has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 268 seconds]
EvW1 has quit [Ping timeout: 260 seconds]
nicht has joined #lisp
nicht has quit [Max SendQ exceeded]
jibanes has quit [Ping timeout: 264 seconds]
jibanes has joined #lisp
johnnymacs has joined #lisp
fikka has joined #lisp
markoong has quit [Read error: Connection reset by peer]
markoong has joined #lisp
markoong has quit [Remote host closed the connection]
markoong has joined #lisp
eli_oat has quit [Quit: Leaving.]
fikka has quit [Ping timeout: 256 seconds]
mathZ has joined #lisp
markoong has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
Xof has quit [Ping timeout: 245 seconds]
robotoad has joined #lisp
kenster has quit [Quit: Konversation terminated!]
moei has joined #lisp
pjb has quit [Ping timeout: 260 seconds]
robotoad has quit [Quit: robotoad]
tripty has quit [Remote host closed the connection]
fikka has joined #lisp
brendyn has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
karswell_ has quit [Read error: Connection reset by peer]
skapata has quit [Remote host closed the connection]
karswell_ has joined #lisp
robotoad has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
mooshmoosh has joined #lisp
kozy has quit [Remote host closed the connection]
tripty has joined #lisp
ebrasca has joined #lisp
kozy has joined #lisp
SlowJimmy has joined #lisp
fikka has joined #lisp
AetherWind has joined #lisp
johnnymacs has quit [Ping timeout: 240 seconds]
SlowJimmy has quit [Ping timeout: 268 seconds]
nicht has joined #lisp
nicht has quit [Max SendQ exceeded]
fikka has quit [Ping timeout: 260 seconds]
shifty has joined #lisp
pierpa has quit [Quit: Page closed]
milanj has quit [Quit: This computer has gone to sleep]
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
<mathZ>
`pkg info maxima` => maxima-5.41.0, why doesnot maxima run ~/maxima-init.mac automatically after started ?
eschatologist has quit [Ping timeout: 244 seconds]
nickenchuggets has quit [Read error: Connection reset by peer]
nickenchuggets has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
gabiruh has quit [Ping timeout: 256 seconds]
mathZ` has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
pierpal has quit [Quit: Poof]
smasta has quit [Ping timeout: 260 seconds]
pierpal has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
scottj has joined #lisp
serichse` has joined #lisp
serichsen has quit [Ping timeout: 256 seconds]
buffergn0me has joined #lisp
buffergn0me has quit [Ping timeout: 248 seconds]
karswell_ has quit [Read error: Connection reset by peer]
karswell_ has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
oni-on-ion has quit [Read error: Connection reset by peer]
fikka has joined #lisp
oni-on-ion has joined #lisp
gabiruh has joined #lisp
buffergn0me has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
<LdBeth>
Good afternoon
<oni-on-ion>
welcome
doesthiswork has quit [Quit: Leaving.]
<LdBeth>
mathZ: it is described in man page
<LdBeth>
mathZ: see env $MAXIMA_USERDIR
<beach>
Good morning everyone!
<MichaelRaskin>
Good morning
<MichaelRaskin>
Sorry, I was being too optimistic about stabilising a non-merge sort.
<beach>
Oh! :(
<beach>
I guess lots of smart people with lots of time have already tried that. Not that this fact guarantees that it can't be done. Just that it might take some time. :)
<beach>
I mean, I make my living questioning what lots of smart people have agreed upon for decades, but that happens to no longer be true.
<beach>
MichaelRaskin: Have you found work for next year?
fikka has joined #lisp
eschatologist has joined #lisp
Bike has quit [Quit: Lost terminal]
oni-on-ion has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 260 seconds]
<MichaelRaskin>
Well, it is not definitive enough that I publically say yes without any qualifications on such a statement, but omst likely yes.
<beach>
Good. Congratulations.
<MichaelRaskin>
I don't accept congratulations until it becomes definitive enough…
<beach>
Right, sorry.
<MichaelRaskin>
As for smart people agreeing — well, my ICALP talk this year will be a set of ideas I had in around a week or two, together they (with something in the paper but not in the talk because technical details) disprove the conjecture most people in the field were inclined to believe… You never know.
<MichaelRaskin>
But as for the sort, I should have seen my idea were a bit too optimistic.
<beach>
Our colleague idurand worked with Aart Middledorp for some time. His standard format for a talk started with "In <year>, <person> wrote a paper in which it was proved that <theorem>. Here is a counterexample to that theorem." Very impressive.
<MichaelRaskin>
Heh. Yeah, that is impressive, but this is what I definitely cannot do — it needs studying something deeply.
<beach>
Oh?
<beach>
I am surprised.
<MichaelRaskin>
Well, in the sense that you need to actually look at a field, have a good grasp of what is known and what is not over a large area of related things, and read a lot of papers with this in mind. It is too much specialisation for me, I am more of «wait, you are applying this from adjacent field Y instead of a better fit in an almost-adjacent field Z» person.
skeuomorf has joined #lisp
<beach>
Yes, I see.
<beach>
That is definitely also a winning strategy in CS. Few people have the broad knowledge to do that, so there are lots of good results to be found.
<MichaelRaskin>
Well, it makes it harder to write «research interests» part of applications…
makomo has joined #lisp
fikka has joined #lisp
<beach>
Heh! Yeah, there is that. "Um, EVERYTHING".
<MichaelRaskin>
But few people know basic discrete probability well, or remember their second-year algebra — at all. Which is the reason for my ICALP papers in 2017 and in 2018.
<beach>
Nice!
fikka has quit [Ping timeout: 260 seconds]
<MichaelRaskin>
Then again, I am grateful to the people more immersed into the fields in question for telling me how to actually write that down (oh I did write it down on my own, but the target audience for that specific order of explanation turned out to be empty…)
<beach>
I know precisely what you mean.
<beach>
When I did my PhD and wrote an early paper, I wrote it so that people could understand what I was doing, and I was told that this is not how it is done. You reverse the order of your explanations in the paper.
<MichaelRaskin>
Not _just_ that.
<MichaelRaskin>
Reversing is enough for linear enough things, flattening a DAG is even more fun
oni-on-ion has joined #lisp
<MichaelRaskin>
(Can we please actually learn how to use hypertext, pretty please? I am not saying I know what exactly to do, I am saying there is not enough diversity of attempts)
<beach>
Sure. All I meant was that conventions are different in different domains, just like conventions are different for different programming languages. And one just has to learn and adapt.
<MichaelRaskin>
Yes, and when I am not insider in any specific field, that learning often needs direct explanations from insiders — every time.
<beach>
I can see that.
<MichaelRaskin>
But still, acceptance of learning to use hypertext would help…
<beach>
I suppose so.
milanj has joined #lisp
<MichaelRaskin>
It is definitely not a common knowledge in the I know they know I know sense; I wonder if it is universally obvious knowledge that just doesn't become common knowledge because pf coordination problems.
<beach>
Are you referring to hypertext again?
buffergn0me has quit [Ping timeout: 276 seconds]
<MichaelRaskin>
Yes
<beach>
I am convinced that not many colleagues even give it a thought. I mean, they don't even give any thought to the basic quality of their writing, as Steven Pinker so amusingly points out in his book and in his talks.
fikka has joined #lisp
<MichaelRaskin>
Well, then there is a clear incentive problem around basic quality of explanation.
<beach>
Indeed.
Inline has quit [Quit: Leaving]
<MichaelRaskin>
Not in the sense of lack of incentive — this can be overcome with appeals to morality, in the sense of visible negative incentives.
fikka has quit [Ping timeout: 264 seconds]
<MichaelRaskin>
(then again, the problem of negative results is easier to define and it is still not going anywhere)
<beach>
I am not sure that's enough. As pinker explains, most colleagues just don't know how to write, and learning that is not obvious.
<MichaelRaskin>
I can explicitly declare that the style I prefer to read is generally considered bad writing.
<MichaelRaskin>
And I have my doubts whether «good writing» is good for 80%-of-the-people-in-the-field, and not something like 45%-good with some alternatives having 15% and 20% target audience.
<beach>
Learning new things is hard. Most people, even scientists, mathematicians, and computer scientist, are "performance oriented" (have a "fixed mindset" as Carol Dweck puts it) in most domains, and they have trained themselves to overcome it in their own narrow domain.
<beach>
MichaelRaskin: I think there are different kinds of bad writing. I think you are referring to the bad writing that just does not follow conventions in the field. But what Pinker refers to is a much broader concept of bad writing, that I am very sure you would not appreciate either.
nickenchuggets has quit [Read error: Connection reset by peer]
nickenchuggets has joined #lisp
<beach>
Anyway, I finished my coffee, and I should get to work on the specification of the SICL garbage collector(s).
<MichaelRaskin>
It is not about locla conventions, it goes across the fields. The question is what is entangled mess and what is a good explanation that attaches all the associations where they are needed (yes, this is the same thing)
<MichaelRaskin>
Have a nice and productive day!
<beach>
You too.
<MichaelRaskin>
Thanks
nickenchuggets has quit [Read error: Connection reset by peer]
sauvin has joined #lisp
fraya has joined #lisp
xrash has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
mathZ has quit [Remote host closed the connection]
mathZ` has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
igemnace has joined #lisp
mathZ has joined #lisp
mathZ has left #lisp [#lisp]
mathZ has joined #lisp
les has quit [Quit: ""]
Smokitch has joined #lisp
les has joined #lisp
skeuomorf has quit [Ping timeout: 265 seconds]
les has quit [Client Quit]
shka_ has joined #lisp
les has joined #lisp
vlatkoB has joined #lisp
fikka has joined #lisp
<fiddlerwoaroof>
Was there a common lisp written in prolog released recently?
<fiddlerwoaroof>
I thought I remember announcements to this effect, but I can’t find any trace of it.
slyrus1 has joined #lisp
<MichaelRaskin>
In that direction, not the other way round? Probably not a Common Lisp, just some kind of Lisp, Common Lisp is just too large.
<fiddlerwoaroof>
I remember talk of a subset of Common Lisp.
<beach>
The call to LOOP is in capital letters, because I used M-p on a previous interaction.
iskander has joined #lisp
<LdBeth>
It seems a problem to save the graphic listener into a excitable
<LdBeth>
*excutable
<beach>
Sorry, I have never tried it, so I don't know what the problem might be.
Folkol_ has quit [Ping timeout: 240 seconds]
<LdBeth>
Anyway, I can still create a Command wrapper
fikka has quit [Ping timeout: 240 seconds]
robotoad has joined #lisp
jibanes has quit [Ping timeout: 248 seconds]
nowhere_man has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
Krisostoomus has joined #lisp
siraben has quit [Ping timeout: 256 seconds]
Krisostoomus has quit [Client Quit]
svillemo1 has joined #lisp
housel has joined #lisp
hph^ has quit [Remote host closed the connection]
buffergn0me has quit [Ping timeout: 264 seconds]
svillemot has quit [Remote host closed the connection]
svillemo1 is now known as svillemot
Naergon has joined #lisp
jibanes has joined #lisp
random-nick has joined #lisp
ogamita has joined #lisp
nowhere_man has joined #lisp
Folkol_ has joined #lisp
carmack has joined #lisp
iskander has left #lisp [#lisp]
milanj has joined #lisp
scymtym has quit [Ping timeout: 248 seconds]
mooshmoosh has quit []
ogamita has quit [Read error: Connection reset by peer]
Folkol_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
schweers has joined #lisp
robotoad has quit [Quit: robotoad]
Folkol_ has joined #lisp
Folkol_ has quit [Ping timeout: 268 seconds]
dddddd has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
jmercouris has joined #lisp
xrash has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
shrdlu68 has quit [Ping timeout: 248 seconds]
Folkol_ has joined #lisp
shrdlu68 has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
guaqua has quit [Ping timeout: 240 seconds]
<beach>
I need some advice. In SICL, a heap-allocated object is either a CONS cell or a GENERAL INSTANCE. A CONS cell is represented as two consecutive words. A general instance is represented as a two-word header where the first word points to the class and the second one to a RACK. The rack contains all other information like the slots of a standard object, the elements of an array, etc. etc.
<beach>
I was thinking of representing the rack pointer as an untagged value, but this is problematic for the garbage collector in that I would have to have information in each stack frame concerning what stack location and register contain rack pointers. Plus, after various optimization tricks, there might be raw pointers to an ELEMENT of a rack and not only to the beginning of it.
<beach>
However, I currently have one unused tag. I could use it for all rack pointers (to the beginning or to an element). This way of doing it would also make it possible to recognize whether a particular 2-word item is a CONS cell or a general instance because only general instances contain a rack pointer in the second word. Is this a good idea or am I missing something?
fikka has joined #lisp
FreeBirdLjj has joined #lisp
<beach>
This recent conundrum, by the way, shows the intimate relationship between data representation and the constraints on the garbage collector.
fikka has quit [Ping timeout: 260 seconds]
<flip214>
yeah, lots of interactions there
<flip214>
beach: do you anticipate that you'll need another tag in the future?
<beach>
No.
<flip214>
can you get more tags by changing some constant easily?
<flip214>
so, what's the downside to using that additional tag?
<beach>
One tag is for all immediate objects and they don't take up the entire word anyway.
<beach>
The downside is that I need an offset to access a rack element.
<beach>
For x86-64 that's not a problem.
<beach>
But RISC machines might require an addition.
<beach>
Probably not many.
<flip214>
and that'll be so often that it might become a performance problem?
ogamita has joined #lisp
<beach>
Yes, that's a frequent operation. But I think all RISC processor that don't have an offset in the instruction optimize this case.
<flip214>
my first reaction is "that is so low-level optimization that a special case in the compiler or a bit of assembly might fix that"
<flip214>
but I'm not that proficient about RISC -- not even sure whether eg. ARM would fall into that category
<beach>
I think ARM has a small offset in the instruction.
<flip214>
yeah, so that problem wouldn't even exist
<beach>
Well, it is not "fixable". What I could do is to make sure all rack pointers have to be recomputed after a function call.
<flip214>
I guess that main memory access has such a big penalty already (on cold caches at least) that the one ADD wouldn't be a problem
<beach>
Then the stack frame would contain no rack pointers.
<beach>
flip214: Yes, exactly. The addition would be a very fast operation compared to the memory access.
<beach>
And I presume such RISC machines are superscalar, so that they can do the addition in parallel with other stuff.
<flip214>
a stack frame _can_ contain rack pointers - as long as there's a visible reference to the _base_ of the rack too. then the other pointers could just be hidden
<flip214>
ie. as long as a _visible_ reference to the rack is on the stack, you can have any number of (GC-) _invisible_ pointers to the same rack as well
<beach>
That's true.
<flip214>
that would mean you have a bit more stack usage, but no register addressing or GC issues
<beach>
But that's a lot of information to keep around.
<jmercouris>
hello everyone
<flip214>
well, how many racks will a tight loop access simultaneously? at most 3 or 4, else it wouldn't be a tight loop anymore, right?
<beach>
Hello jmercouris.
<beach>
flip214: Yes, max 2 I would think.
<flip214>
or do you mean "a lot of information the compiler has to keep around"?
<beach>
Yes, that.
<jmercouris>
beach: I haven't gotten around to reading the papers yet, they are on my queue
<beach>
And for the GC to access.
<beach>
jmercouris: Don't worry about it.
ogamita has quit [Read error: Connection reset by peer]
fikka has joined #lisp
<flip214>
well, the compiler needs to have a few local variables (or make them thread-local?!), where references to things addressed opaquely by registers are referenced
<flip214>
so you'd only need a few pointers in the TLA, and a store to them every now and then
<flip214>
and the GC has a few more roots to look at
<flip214>
for the easiest (and perhaps worst) case, have one pointer in the TLA for each addressing register
d4ryus has quit [Quit: WeeChat 2.1]
<flip214>
when a rack address is loaded into the register, emit a store of the rack base address to the corresponding TLA pointer
<beach>
I am not sure I follow.
<flip214>
then the register itself can be used at will
<beach>
Oh, additional stores would be prohibitive.
<flip214>
beach: no, not necessarily.
<flip214>
first of all, they'd only be _concurrently_ read on the start of a GC (fetch all roots), and never concurrently _written_ by another thread.
<flip214>
so there's no bus contention or so.
<beach>
OK, let's do this from the start. I'm lost (as usual).
<flip214>
okay.
<flip214>
----------------
<flip214>
you've got space for a pointer for each CPU register in the thread-local-area.
<beach>
Hold on please.
<beach>
I was lost in your first phrase.
<beach>
We need to back up.
<beach>
Or you will emit more phrases that make me even more lost.
<beach>
You said "the compiler needs to have a few local variables... where references to things addressed opaquely by registers are referenced".
<beach>
There are at least 3 pieces of information in there that I don't understand.
<beach>
First "the compiler".
<beach>
Can I assume that you mean that those variables are not used during compilation, but that are needed so that the compiler can emit code using them?
<beach>
Next what is a "thing addressed opaquely"?
<beach>
More generally, what is "opaque addressing"?
fikka has quit [Ping timeout: 240 seconds]
<flip214>
one sec, I'll catch my thoughts and try to compose an email that's better worded.
<beach>
flip214: Sorry about all this. It's an occupational hazard. I was trained as an engineer and a scientist and I must understand every word.
<beach>
OK, that's better. No rush. When things are written down, we can make iterations.
aindilis has quit [Remote host closed the connection]
<beach>
This happens to me so often that I wonder why I seem to be one of the few people who can't understand quick exchanges like this.
<beach>
I mean, I don't think of myself as more stupid than most.
<beach>
Oh, well. Lunch time anyway. Time for a break.
fikka has joined #lisp
<flip214>
beach: the problem might as well be me, as I don't have formal training and so might have differences in my vocabulary.
<jmercouris>
anyone know of an implementation of DB Scan in common lisp?
Kaisyu has quit [Quit: Connection closed for inactivity]
nowhere_man has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
orivej has joined #lisp
<beach>
flip214: I guess we'll find out.
fikka has quit [Ping timeout: 260 seconds]
milanj has quit [Quit: This computer has gone to sleep]
djinni` has quit [Quit: Leaving]
djinni` has joined #lisp
aindilis has quit [Read error: Connection reset by peer]
heisig has joined #lisp
d4ryus has joined #lisp
fikka has joined #lisp
orivej has quit [Ping timeout: 268 seconds]
RTZ0x859 has joined #lisp
nowhere_man has joined #lisp
Folkol_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Folkol_ has joined #lisp
<shrdlu68>
How do I get the exact point where a condition was raised?
<shrdlu68>
The backtrace isn't very meaningful.
<jackdaniel>
if you press `v` on the frame (given you use sldb) it should open a buffer with the source location in question
<shka>
you may need optimize for debug
<loke>
And some lisps are better than others when it comes to debugging information
<loke>
I sometimes get expresment positively surprised when it comes to SBCL's ability to find the correct source line... Sometimes I get very disappointed too.
<loke>
I meant to say “extremely”. I have no idea how I managed to make such a typo.
fikka has quit [Ping timeout: 248 seconds]
light2yellow has joined #lisp
fikka has joined #lisp
markoong has joined #lisp
<jmercouris>
loke: sometimes when you are typing expresment fast it happens
jibanes has quit [Ping timeout: 256 seconds]
siraben has quit [Ping timeout: 240 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
shrdlu68 has quit [Ping timeout: 240 seconds]
housel has quit [Read error: Connection reset by peer]
shrdlu68 has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
<jkordani>
I like it, expresment
<jmercouris>
it sounds like a french way of saying extremely
<jmercouris>
like "ex-pre-se-mon!" or something
Ukari has quit [Quit: Leaving.]
<jkordani>
I go from refreshment to excrement to expression
<jkordani>
expresment: the thing you express.
shrdlu68 has quit [Ping timeout: 260 seconds]
shrdlu68 has joined #lisp
fikka has joined #lisp
JuanDaugherty has joined #lisp
igemnace has joined #lisp
lumm has joined #lisp
<jackdaniel>
loke: amusingly enough, in this lecture the speaker mentions how vovels and slips of a tongue are related to subconcious clash of words you could use: https://www.youtube.com/watch?v=n8m7lFQ3njk
fikka has quit [Ping timeout: 264 seconds]
milanj has joined #lisp
<dim>
expressément is indeed a French word that means “explicitely”
<jmercouris>
I knew it
fraya has joined #lisp
<dim>
it doesn't mean extremely thou, like “actuellement” in French means “currently” in English, and other traps like that ;-)
argoneus has quit [Quit: No Ping reply in 180 seconds.]
funnel has quit [Ping timeout: 255 seconds]
<jkordani>
a synonym for explicitely would be expressley
argoneus has joined #lisp
makomo has quit [Read error: Connection reset by peer]
funnel has joined #lisp
merodix has quit [Remote host closed the connection]
Folkol_ has quit [Ping timeout: 264 seconds]
milanj has quit [Quit: This computer has gone to sleep]
<beach>
jackdaniel: I will definitely watch it at some point. I have read a few books by Douglas Hofstadter and I like his writing very much.
<beach>
... but right now I am preoccupied by other stuff.
<schweers>
is tracing in sbcl known to be broken?
m00natic has joined #lisp
<JuanDaugherty>
tracing (anyplace) is known to be used in situations of brokenness
<schweers>
anyplace?
<JuanDaugherty>
irgendwo
shangul has quit [Remote host closed the connection]
nowhere_man has quit [Read error: Connection reset by peer]
nowhere_man has joined #lisp
<beach>
Different question, but related to my previous one: Suppose I want to implement the SICL garbage collector in Common Lisp. Such a thing must obviously be able to handle arbitrary addresses and arbitrary machine data, let's say in the form of unsigned 64-bit integers. I can see two ways to do it.
<beach>
Way number 1 is to pretend that memory is a Common Lisp array with element type (unsigned-byte 64). Way number 2 is to provide two functions for accessing memory like MEMORY and (SETF MEMORY).
<beach>
Way number 1 has the inconvenience that any element of the array that represents an address would have to be shifted right by 8 positions before it can be used as an index. But then, the compiler would generate code to shift it left again to get an address. I would then have to make sure that the compiler is able to cancel the two.
<beach>
For way number 2, the two functions must be declared to use arguments and values of type (unsigned-byte 64), they would have to be written in machine code (easy), but they still would need to be inlined, so that the compiler does not have to emit code to tag and untag them or (worse) convert them to bignums and back.
<beach>
Any thoughts about advantages and disadvantages of the two?
eli_oat has joined #lisp
<heisig>
beach: I have a better feeling about way number 2. The raw memory is semantically a different thing than a Lisp vector, and blurring this distinction might lead to confusion.
<jmercouris>
I like number 2 as it is an abstraction
pierpal has quit [Quit: Poof]
<beach>
heisig: I see, yes. The other thing with 2 is that one could add functions for accessing individual bytes if required.
pierpal has joined #lisp
<beach>
jmercouris: A tiny tiny one.
<jmercouris>
yeah, but still
<flip214>
beach: for an 8-byte type, only shift the index 3 bits.
<flip214>
and I guess that at some point you might need byte-addressing too - which would go against point 1
<beach>
Oh, sorry, yes.
<beach>
Other than the potential problems I listed, can anyone think of other ways in which I could get into trouble, i.e., what would I have to make sure I can convince the compiler to do?
<flip214>
beach: how many tag bits does SICL reserve?
<beach>
3
fikka has joined #lisp
<beach>
But fixnums are the ones with the last bit 0.
<flip214>
so a 64-bit-word "memory layout" means that even addresses as tagged integers go into a single register... that sounds like #1 would be much easier.
<beach>
Yes, that makes it easier.
<flip214>
and for byte-addressing needs you might have a second "special" array -- which would be used very infrequently, so a few bignum operations won't matter.
<flip214>
(which are very unlikely, as the top half of 64bit memory is reserved for the kernel anyway (typically), so userspace wouldn't have such adresses)
<beach>
Yeah, bignums are very unlikely.
<flip214>
the two functions sound much more better from an abstraction level... but does that really matter for such a low-level use?
<beach>
Though, SICL will be the basis for LispOS, so there is no "kernel space" then.
<flip214>
does that run in a virtual address space, or in physical address space then?
<beach>
I don't think so. I am more concerned about the clarity of the algorithms.
<beach>
What does?
<flip214>
the LispOS
charh has joined #lisp
<beach>
Virtual still, but with a fixed mapping.
<flip214>
will that have to deal with addresses of #x8000...000 and higher, or only smaller ones?
<flip214>
ah, okay
fyodost has joined #lisp
<beach>
It will have to deal with every possible address.
<flip214>
well, (AREF *MAIN-MEMORY* address) vs. (MEMORY address) sounds like a trivial difference
<beach>
So that speaks in favor of 2.
fikka has quit [Ping timeout: 240 seconds]
JuanDaugherty has quit [Quit: Exeunt]
<flip214>
so I'd say go with the second, and if you find out you want the first make (DEFMACRO MEMORY (a) `(AREF *MAIN-MEMORY ,a))
<beach>
flip214: yes, I kind of think that algorithm clarity will not be affected.
<beach>
So that's 3 votes for option 2 and 0 votes for option 1.
<flip214>
sounds like it
<flip214>
and after all option 2 can be changed into option 1 with a simple macro
<beach>
Yes, good point.
<beach>
Great! Thanks everyone as usual for all the help.
<froggey>
I use option 2 in mezzano, with accessors for different element types. memref-t, memref-(un)signed-byte-{8,16,32,64}
<beach>
4-0 then. Great, thanks froggey.
eli_oat has quit [Quit: Leaving.]
milanj has joined #lisp
doesthiswork has joined #lisp
Khisanth has quit [Ping timeout: 245 seconds]
<flip214>
beach: > Sometimes a majority simply means that all the fools are on the same side.
<beach>
I never said I would follow the outcome of the vote. :)
<shka>
Xach: i seriously would rip this code out and submit it quicklisp as library :]
<beach>
flip214: I changed the SICL specification so that racks are tagged, using a single commit so that it can be easily undone if necessary. Let me know if you see any problems with it.
Bike has joined #lisp
housel has joined #lisp
<Xach>
shka: thanks. i wrote a HTTP client that predated curl and wget, and put up a semi-joking comparison table when the others came around, and one of my plus features was "cool progress bar". but then curl and wget got really cool progress bars, too.
<Xach>
the quicklisp progress bar derives a bit from that experience.
scymtym has quit [Ping timeout: 276 seconds]
Cymew has quit []
zooey has quit [Ping timeout: 250 seconds]
guaqua has quit [Ping timeout: 260 seconds]
guaqua has joined #lisp
heisig has quit [Quit: Leaving]
samebchase has quit [Ping timeout: 268 seconds]
EvW has joined #lisp
smurfrobot has quit [Remote host closed the connection]
megalography has joined #lisp
zooey has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
rpg has joined #lisp
lumm has quit [Quit: lumm]
lumm has joined #lisp
surya has joined #lisp
smasta has joined #lisp
fikka has joined #lisp
smurfrobot has joined #lisp
sjl has joined #lisp
lumm_ has joined #lisp
flamebeard has quit []
lumm has quit [Ping timeout: 256 seconds]
lumm_ is now known as lumm
megalography has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 240 seconds]
nickenchuggets has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
fikka has joined #lisp
reu has quit [Ping timeout: 260 seconds]
jack_rabbit has quit [Ping timeout: 264 seconds]
scymtym has joined #lisp
trittweiler has quit [Remote host closed the connection]
reu has joined #lisp
dmiles has quit [Ping timeout: 245 seconds]
logicmoo has joined #lisp
surya has quit [Remote host closed the connection]
EvW has quit [Remote host closed the connection]
EvW has joined #lisp
nika has joined #lisp
nowhere_man has quit [Ping timeout: 276 seconds]
smurfrobot has quit [Remote host closed the connection]
robotoad has joined #lisp
sjl has quit [Quit: WeeChat 2.2-dev]
shrdlu68 has quit [Ping timeout: 245 seconds]
shrdlu68 has joined #lisp
fikka has quit [Quit: leaving]
trittweiler has joined #lisp
fikka has joined #lisp
shifty has quit [Ping timeout: 256 seconds]
shrdlu68 has quit [Ping timeout: 256 seconds]
housel has quit [Read error: Connection reset by peer]
shrdlu68 has joined #lisp
sjl has joined #lisp
Folkol_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
smasta has quit [Ping timeout: 260 seconds]
shrdlu68 has quit [Ping timeout: 264 seconds]
shrdlu68 has joined #lisp
sjl_ has joined #lisp
Beep-Lord has joined #lisp
shrdlu68 has quit [Ping timeout: 260 seconds]
shrdlu68 has joined #lisp
EuAndreh[m] has joined #lisp
sjl has quit [Ping timeout: 276 seconds]
smurfrobot has joined #lisp
shrdlu68 has quit [Ping timeout: 240 seconds]
shrdlu68 has joined #lisp
JuanDaugherty has joined #lisp
eli_oat has joined #lisp
montxero has quit [Remote host closed the connection]
edgar-rft has joined #lisp
eli_oat has quit [Client Quit]
buffergn0me has joined #lisp
lumm_ has joined #lisp
sjl_ has quit [Quit: WeeChat 2.2-dev]
eli_oat has joined #lisp
lumm_ has quit [Read error: Connection reset by peer]
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
lumm has quit [Ping timeout: 240 seconds]
sjl has joined #lisp
JuanDaugherty has quit [Quit: Exeunt]
argoneus has quit [Quit: No Ping reply in 180 seconds.]
eli_oat has quit [Quit: Leaving.]
MetaYan has quit [Ping timeout: 240 seconds]
reu has quit [Ping timeout: 265 seconds]
beaky1 has joined #lisp
reu has joined #lisp
eli_oat has joined #lisp
smasta has joined #lisp
xantoz has quit [Ping timeout: 276 seconds]
argoneus has joined #lisp
warweasle has quit [*.net *.split]
remix2000[m] has quit [*.net *.split]
mathrick has quit [*.net *.split]
gendl has quit [*.net *.split]
ioa has quit [*.net *.split]
ArthurAGleckler[ has quit [*.net *.split]
can3p[m] has quit [*.net *.split]
kammd[m] has quit [*.net *.split]
RichardPaulBck[m has quit [*.net *.split]
Guest9126 has quit [*.net *.split]
snits has quit [*.net *.split]
cgay has quit [*.net *.split]
jonh has quit [*.net *.split]
jasom has quit [*.net *.split]
gorgor_ has quit [*.net *.split]
himmAllRight has quit [*.net *.split]
|3b|` has quit [*.net *.split]
fe[nl]ix has quit [*.net *.split]
Blkt has quit [*.net *.split]
beaky has quit [Ping timeout: 255 seconds]
eli_oat has quit [Quit: Leaving.]
megalography has joined #lisp
fe[nl]ix has joined #lisp
Blkt has joined #lisp
remix2000[m] has joined #lisp
mathrick has joined #lisp
ioa has joined #lisp
can3p[m] has joined #lisp
kammd[m] has joined #lisp
|3b|` has joined #lisp
gendl has joined #lisp
himmAllRight has joined #lisp
jonh has joined #lisp
RichardPaulBck[m has joined #lisp
snits has joined #lisp
warweasle has joined #lisp
gorgor_ has joined #lisp
ArthurAGleckler[ has joined #lisp
jasom has joined #lisp
cgay has joined #lisp
Guest9126 has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
hhdave has quit [Ping timeout: 276 seconds]
pjb has joined #lisp
Amany has quit [Ping timeout: 265 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
dirb has quit [Ping timeout: 240 seconds]
wetha has quit [Ping timeout: 240 seconds]
katco[m] has quit [Ping timeout: 240 seconds]
LdBeth has quit [Ping timeout: 245 seconds]
equalunique[m] has quit [Ping timeout: 245 seconds]
thorondor[m] has quit [Ping timeout: 245 seconds]
z3r0d5y[m] has quit [Ping timeout: 245 seconds]
manila[m] has quit [Ping timeout: 245 seconds]
drunk_foxx[m] has quit [Ping timeout: 245 seconds]
Jachy has quit [Ping timeout: 245 seconds]
hdurer[m] has quit [Ping timeout: 240 seconds]
EuAndreh[m] has quit [Ping timeout: 240 seconds]
blep-on-external has quit [Ping timeout: 240 seconds]
remix2000[m] has quit [Ping timeout: 240 seconds]
ArthurAGleckler[ has quit [Ping timeout: 240 seconds]
kammd[m] has quit [Ping timeout: 240 seconds]
can3p[m] has quit [Ping timeout: 240 seconds]
kumori[m] has quit [Ping timeout: 240 seconds]
warweasle has joined #lisp
eatonphil has quit [Ping timeout: 240 seconds]
RichardPaulBck[m has quit [Ping timeout: 240 seconds]
Guest9126 has quit [Ping timeout: 240 seconds]
spectrumgomas[m] has quit [Ping timeout: 260 seconds]
plll[m] has quit [Ping timeout: 255 seconds]
eli_oat[m] has quit [Ping timeout: 255 seconds]
lyosha[m] has quit [Ping timeout: 265 seconds]
GNUPONUT[m] has quit [Ping timeout: 256 seconds]
CharlieBrown has quit [Ping timeout: 247 seconds]
theemacsshibe[m] has quit [Ping timeout: 256 seconds]
kolb has quit [Ping timeout: 240 seconds]
mrottenkolber has joined #lisp
mrottenkolber is now known as Guest67885
schweers has quit [Ping timeout: 260 seconds]
aijony has quit [Ping timeout: 240 seconds]
xrash has joined #lisp
aijony has joined #lisp
logicmoo has quit [Read error: Connection reset by peer]
nickenchuggets has quit [Read error: Connection reset by peer]
blt has quit [Ping timeout: 245 seconds]
lel has quit [Ping timeout: 260 seconds]
buffergn0me has quit [Ping timeout: 256 seconds]
Beep-Lord has quit [Ping timeout: 260 seconds]
lavaflow has quit [Ping timeout: 276 seconds]
saturn2 has quit [Ping timeout: 256 seconds]
vertigo has quit [Ping timeout: 248 seconds]
aeth has quit [Ping timeout: 264 seconds]
Guest53082 has quit [Ping timeout: 248 seconds]
vertigo has joined #lisp
sjl has quit [Ping timeout: 268 seconds]
aeth has joined #lisp
mflem has joined #lisp
xantoz has joined #lisp
jmercouris has joined #lisp
<jmercouris>
so, I have a lisp system that I can (asdf:make :system) to compile
<jmercouris>
how can I put this in a makefile or something?
<jmercouris>
or how can I issue a single command in the CL to compile?
<jmercouris>
what I'm doing now is typing in "sbcl" and then within the repl typing the command to compile
bigfondue has quit [Ping timeout: 265 seconds]
<jmercouris>
I was thinking something like sbcl --eval "some expression"
<jmercouris>
but i'm not sure how that works exactly
fikka has quit [Quit: Lost terminal]
<jmercouris>
well, I guess it works the way someone would imagine, I should have tried it before posting here
<jmercouris>
nvm then
aindilis has joined #lisp
<rpg>
jmercouris: Yeah, none of us have ever done that before! ;-)
<jmercouris>
rpg: :D
jmercouris has quit [Remote host closed the connection]
Beep-Lord has joined #lisp
shka_ has joined #lisp
sjl has joined #lisp
shrdlu68 has quit [Ping timeout: 260 seconds]
FreeBirdLjj has joined #lisp
nowhere_man has joined #lisp
dan64- has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<pjb>
in the expansion use , to expand the class parameter.
Beep-Lord has quit [Ping timeout: 255 seconds]
<pjb>
But the point is probably that "I want to pass in the upload-session class symbol and get 'upload-session" is not what you want.
<kenster>
oh okay
<pjb>
Your c-struct-name expression is ok.
FreeBirdLjj has joined #lisp
<pjb>
class is the bound to the class name (symbol).
<pjb>
So you don'tneed a new variable here.
<pjb>
(identity class) == class
<kenster>
yaaay
<kenster>
but you're saying I shouldn't be passing in the class symbol anyways?
<pjb>
Now, you need the *c-class-structs* table set up at macroexpansion time, in the compilation environment. The simpliest to fill it is to define a macro that expands to an eval-when setf gethash.
<pjb>
I'm saying you already have it passed in the class parameter.
<pjb>
Where is the definition of *c-class-structs*?
graphene has quit [Remote host closed the connection]
<ebrasca>
kenster: Have you read about mediagoblin ?
graphene has joined #lisp
graphene has quit [Remote host closed the connection]
<pjb>
And of course these days there's also peertube getting out.
nickenchuggets has joined #lisp
blt has joined #lisp
blt has joined #lisp
blt has quit [Changing host]
Demosthenex has joined #lisp
<Demosthenex>
anyone seen a lib that helps make TUI apps for cl? yes, ncurses exists, but the forms portion never seems to be included in the libs. widgets/forms aren't the same as screenhandling.
<pjb>
kenster: On unix, checking permissions is done by open.
graphene has joined #lisp
<ebrasca>
kenster: Yea I like decentralization.
<pjb>
Don't check before opening!
<Demosthenex>
i'm working on a trading database, and need a fast and simple frontend.
<pjb>
bbl
graphene has quit [Remote host closed the connection]
anon___ has joined #lisp
MetaYan has joined #lisp
graphene has joined #lisp
graphene has quit [Remote host closed the connection]
FreeBirdLjj has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 264 seconds]
eli_oat has quit [Quit: Leaving.]
fikka has joined #lisp
rumbler31 has quit [Remote host closed the connection]
bigfondue has quit [Ping timeout: 245 seconds]
Beep-Lord has quit [Ping timeout: 255 seconds]
random-nick has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
samebchase has joined #lisp
jkordani has quit [Read error: Connection reset by peer]
eli_oat has joined #lisp
ebrasca has quit [Read error: Connection reset by peer]
ebrasca has joined #lisp
fikka has joined #lisp
NotSpooky has quit [Ping timeout: 245 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
Beep-Lord has joined #lisp
smurfrobot has joined #lisp
bigfondue has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
smurfrobot has quit [Read error: Connection reset by peer]
milanj has quit [Quit: This computer has gone to sleep]
Beep-Lord has quit [Ping timeout: 256 seconds]
eli_oat has quit [Quit: Leaving.]
escapist_ has joined #lisp
escapist has quit [Ping timeout: 245 seconds]
NotSpooky has joined #lisp
mindCrime_ has joined #lisp
eli_oat has joined #lisp
mindCrime has quit [Ping timeout: 256 seconds]
eli_oat has quit [Client Quit]
fikka has joined #lisp
nowhere_man has quit [Ping timeout: 245 seconds]
fikka has quit [Ping timeout: 240 seconds]
terpri has joined #lisp
escapist_ has left #lisp ["WeeChat 2.1"]
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
fikka has joined #lisp
fyodost_ has joined #lisp
milanj has joined #lisp
<fortitude>
do any lisps provide a way to have global variable that /aren't/ dumped as part of an image?
megalography has quit [Ping timeout: 240 seconds]
fyodost has quit [Ping timeout: 240 seconds]
CrazyEddy has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 245 seconds]
<Xach>
fortitude: you can use save-hooks to clean up what you like in sbcl
EvW1 has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
megalography has joined #lisp
Beep-Lord has joined #lisp
megalography has quit [Ping timeout: 245 seconds]
vlatkoB has quit [Remote host closed the connection]
jmercouris has joined #lisp
rumbler31 has joined #lisp
megalography has joined #lisp
<charh>
Hello! lispers, I have a beginner question. I am a systems administrator (Unix) and a beginner and autodidact.
<charh>
I write code in shell mainly. All my developments are related to operating systems. it's okay. but ... I want to be a true developer ... and I love Common Lisp as a language.
fikka has joined #lisp
<charh>
I am reading practical common lisp, but finally I do not "click" with the development outside of an operating system
<charh>
My friends, my boss and any other people tell me "Do not learn lisp... is old and deprecated..., learn Java, Python, C, C ++, Rust ..." but I want Common Lisp, for me lisp is magic... I have a small code (in my git) and i love.
<charh>
Any suggestion for my way? follow? or I need learn first other language?
<charh>
I want follow, but i don't know if a good decision
<charh>
yes, the question is more a suggestion from your experience, but i don't know any friend for talk o read about that.
<charh>
please and thanks lispers :)
nickenchuggets has quit [Read error: Connection reset by peer]
<trittweiler>
I think you need to familarize yourself with a Common Lisp development environment. For example Emacs, and Slime (the Common Lisp editing mode)
nickenchuggets has joined #lisp
nickenchuggets has joined #lisp
mflem has quit [Ping timeout: 245 seconds]
<trittweiler>
The application design of Emacs can be quite illuminating by itself. (There definitely are other development environments, though, in case Emacs is just not your cup of tea)
NotSpooky has quit [Ping timeout: 260 seconds]
<charh>
thanks trittweiler :), i have installed and configured (emacs + slime), I go to learnd (and read) more about that
<Demosthenex>
charh: i'm a systems guy too. CL is great for all kinds of backend tasks. python and java etc are for frontend stuff
<charh>
s/learnd/learn
<Demosthenex>
emacs is life.
<charh>
oh, fine Demosthenex :) thanks
NotSpooky has joined #lisp
<Demosthenex>
charh: did you ever learn latin?
<charh>
a little Demosthenex
<Demosthenex>
there's an analogy between learning lisp and latin. learning latin made you understand more about many different languages, it gave you depth, insight. lisp is the same
<trittweiler>
SICP (Structure and Interpretation of Computer Programs) is a very good book on learning the foundations of programming. It uses Scheme, a cousin of Common Lisp.
<Demosthenex>
with the exception where latin died off in usage, lisp is still used. all other languages are graduallying adding features lisp had many decades ago
<trittweiler>
there are also video lectures available from the 80s, which I found very enjoyable.
<Demosthenex>
common lisp and modern schemes are both quite good
<Demosthenex>
trittweiler: omg! the green chaulkboards!
fikka has quit [Ping timeout: 256 seconds]
<charh>
oh fine Demosthenex! thanks! and you too trittweiler
<Demosthenex>
i'm chafing over the gui and web frontends to everything. i'm tinkering with some personal apps that are often simple CRUD interfaces to a sql database. i don't want a gui, i want a curses based forms frontend
<Demosthenex>
i despair that all the libs are no longer available
<charh>
oh ok, Demosthenex, fine! and thanks again :), any library for read and alternate between code and books?
<trittweiler>
If it's a good use of your time to learn Common Lisp is arguable. People in this channel would of course say yes. :) Python and Go would probably be more easily marketable skills (I think those are quite common in the devops world.) If your aim is to learn programming as a craft, Lisp will be a very good foundation like Demosthenex said
<Demosthenex>
i wish i learned lisp a decade earlier.
<Demosthenex>
ESR and other great programmers talk about a moment of enlightenment, where it just goes *SNAP* in your head and you gain insight. i was skeptical, but it's true
<charh>
Perfect trittweiler, thanks for your answer, i want to learn programming as a craft.
<Demosthenex>
absolutely changes your perspective when dealing with programming problems and other languages.
<Demosthenex>
i did a self study through "Practical Common Lisp" several years ago, it was time well spent.
<charh>
thank you very much, then I will follow this path
<charh>
i will read more about your suggestions, thanks Demosthenex and trittweiler
smasta has quit [Ping timeout: 260 seconds]
smasta has joined #lisp
<Demosthenex>
charh: even if you don't learn lisp
<Demosthenex>
charh: use emacs. it'll open your eyes. plus it runs on lisp, so you can tinker anytime without needing a dev environment for little hings
<Demosthenex>
s/hings/things/
<Demosthenex>
and as a system's guy, org-mode will change your life
mindCrime has joined #lisp
<charh>
thanks Demosthenex :), I will search very information about emacs, your suggetions is goooood/great for me
Bike has quit [Ping timeout: 260 seconds]
<Demosthenex>
i have found Structured Terminal Forms Library (STFL), s-lang, ncurses forms, and others... but few bindings for cl.
fikka has joined #lisp
mindCrime_ has quit [Ping timeout: 264 seconds]
shka_ has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 248 seconds]
klm2is has quit [Quit: Leaving]
fikka has joined #lisp
<whartung>
emacs is all fine and good, but it doesn’t need to be the first step. You certainly don’t need Slime or anything fancy out of the box either. What you need, at a minumum is an editor that helps you with parentheses matching. Emacs will do that, but so will vi. emacs is nice because it’s got “lisp aware” indenting, which helps.
<whartung>
You ceratinly don’t need to “understand” emacs to learn CL
<whartung>
what kidn of problems do you want to solve charh ?
<whartung>
learning in a vacuum is all well and good, but it’s better if you’re trying to solve some problem. Computers without problems to solve are also known as “room heaters”
<whartung>
unless you’re a vintage computer collector, then they become sclupture.
nirved has quit [Ping timeout: 245 seconds]
<pjb>
Yes, emacs is not necessarily the first step. But once you start using it, you'll always regret not having used it sooner.
<pjb>
I started using emacs in 1992, and I would have hit myself for not having started using it much earlier.
smasta has quit [Ping timeout: 256 seconds]
<charh>
whartung: my first step is a mix unix/CL and resolve problems outside shell scripting, I will rewrite my shell scripts in CL or the functionality
<whartung>
ok. That’s good. You might consider scsh — it’s a “Scheme Shell”, so, it’s a Scheme, not a Common Lisp, but it is designed to be a shell and has artifacts in place to handle things like sub processes and pipes and such.
<whartung>
that’s always been the problem I could never surmount in my “Lisp as shell” dabbling — finding a suitable usable pipe replacement, as it’s so engrained in the shell experience.
Bike has joined #lisp
<whartung>
I edit with emacs, but that’s it. I leverage it’s autoformatting the most. I run Lisp in a separate window, and just continually reload my work. (defun l () (load “file.lisp”), and then just type (l) over and over (typiecally with REPL history ala readline)
<whartung>
it suits me with my projects.
<whartung>
I only say this as it’s one thing to want to learn from forms and the language, another to have to tool up an entire environemtn just to learn those forms and language — it’s not the same
<charh>
thanks whartung i was don't sure about scsh, but i will prove it! and read mooooore about emacs and CL :D